]> 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
added more properties
[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 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2475 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2476 #define SWIGTYPE_p_wxArrayString swig_types[10]
2477 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2478 #define SWIGTYPE_p_wxBitmap swig_types[12]
2479 #define SWIGTYPE_p_wxBitmapDataObject swig_types[13]
2480 #define SWIGTYPE_p_wxBoxSizer swig_types[14]
2481 #define SWIGTYPE_p_wxBusyCursor swig_types[15]
2482 #define SWIGTYPE_p_wxBusyInfo swig_types[16]
2483 #define SWIGTYPE_p_wxCURHandler swig_types[17]
2484 #define SWIGTYPE_p_wxCaret swig_types[18]
2485 #define SWIGTYPE_p_wxChar swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboard swig_types[21]
2488 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[23]
2490 #define SWIGTYPE_p_wxCloseEvent swig_types[24]
2491 #define SWIGTYPE_p_wxColour swig_types[25]
2492 #define SWIGTYPE_p_wxCommandEvent swig_types[26]
2493 #define SWIGTYPE_p_wxConfig swig_types[27]
2494 #define SWIGTYPE_p_wxConfigBase swig_types[28]
2495 #define SWIGTYPE_p_wxConfigPathChanger swig_types[29]
2496 #define SWIGTYPE_p_wxContextMenuEvent swig_types[30]
2497 #define SWIGTYPE_p_wxControl swig_types[31]
2498 #define SWIGTYPE_p_wxControlWithItems swig_types[32]
2499 #define SWIGTYPE_p_wxCursor swig_types[33]
2500 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
2501 #define SWIGTYPE_p_wxDC swig_types[35]
2502 #define SWIGTYPE_p_wxDataFormat swig_types[36]
2503 #define SWIGTYPE_p_wxDataObject swig_types[37]
2504 #define SWIGTYPE_p_wxDataObjectComposite swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectSimple swig_types[39]
2506 #define SWIGTYPE_p_wxDateEvent swig_types[40]
2507 #define SWIGTYPE_p_wxDateSpan swig_types[41]
2508 #define SWIGTYPE_p_wxDateTime swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[43]
2510 #define SWIGTYPE_p_wxDisplay swig_types[44]
2511 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[45]
2512 #define SWIGTYPE_p_wxDropFilesEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDuplexMode swig_types[47]
2514 #define SWIGTYPE_p_wxEraseEvent swig_types[48]
2515 #define SWIGTYPE_p_wxEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvtHandler swig_types[50]
2517 #define SWIGTYPE_p_wxFSFile swig_types[51]
2518 #define SWIGTYPE_p_wxFileConfig swig_types[52]
2519 #define SWIGTYPE_p_wxFileDataObject swig_types[53]
2520 #define SWIGTYPE_p_wxFileHistory swig_types[54]
2521 #define SWIGTYPE_p_wxFileSystem swig_types[55]
2522 #define SWIGTYPE_p_wxFileType swig_types[56]
2523 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
2524 #define SWIGTYPE_p_wxFlexGridSizer swig_types[58]
2525 #define SWIGTYPE_p_wxFocusEvent swig_types[59]
2526 #define SWIGTYPE_p_wxFont swig_types[60]
2527 #define SWIGTYPE_p_wxFrame swig_types[61]
2528 #define SWIGTYPE_p_wxGBSizerItem swig_types[62]
2529 #define SWIGTYPE_p_wxGIFHandler swig_types[63]
2530 #define SWIGTYPE_p_wxGridBagSizer swig_types[64]
2531 #define SWIGTYPE_p_wxGridSizer swig_types[65]
2532 #define SWIGTYPE_p_wxICOHandler swig_types[66]
2533 #define SWIGTYPE_p_wxIcon swig_types[67]
2534 #define SWIGTYPE_p_wxIconizeEvent swig_types[68]
2535 #define SWIGTYPE_p_wxIdleEvent swig_types[69]
2536 #define SWIGTYPE_p_wxImage swig_types[70]
2537 #define SWIGTYPE_p_wxImageHandler swig_types[71]
2538 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[72]
2539 #define SWIGTYPE_p_wxInitDialogEvent swig_types[73]
2540 #define SWIGTYPE_p_wxJPEGHandler swig_types[74]
2541 #define SWIGTYPE_p_wxJoystick swig_types[75]
2542 #define SWIGTYPE_p_wxJoystickEvent swig_types[76]
2543 #define SWIGTYPE_p_wxKeyEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKillError swig_types[78]
2545 #define SWIGTYPE_p_wxLayoutConstraints swig_types[79]
2546 #define SWIGTYPE_p_wxLog swig_types[80]
2547 #define SWIGTYPE_p_wxLogBuffer swig_types[81]
2548 #define SWIGTYPE_p_wxLogChain swig_types[82]
2549 #define SWIGTYPE_p_wxLogGui swig_types[83]
2550 #define SWIGTYPE_p_wxLogNull swig_types[84]
2551 #define SWIGTYPE_p_wxLogStderr swig_types[85]
2552 #define SWIGTYPE_p_wxLogTextCtrl swig_types[86]
2553 #define SWIGTYPE_p_wxLogWindow swig_types[87]
2554 #define SWIGTYPE_p_wxMaximizeEvent swig_types[88]
2555 #define SWIGTYPE_p_wxMenu swig_types[89]
2556 #define SWIGTYPE_p_wxMenuBar swig_types[90]
2557 #define SWIGTYPE_p_wxMenuEvent swig_types[91]
2558 #define SWIGTYPE_p_wxMenuItem swig_types[92]
2559 #define SWIGTYPE_p_wxMetafile swig_types[93]
2560 #define SWIGTYPE_p_wxMetafileDataObject swig_types[94]
2561 #define SWIGTYPE_p_wxMimeTypesManager swig_types[95]
2562 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseState swig_types[99]
2566 #define SWIGTYPE_p_wxMoveEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[101]
2568 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[102]
2569 #define SWIGTYPE_p_wxNcPaintEvent swig_types[103]
2570 #define SWIGTYPE_p_wxNotifyEvent swig_types[104]
2571 #define SWIGTYPE_p_wxObject swig_types[105]
2572 #define SWIGTYPE_p_wxOutputStream swig_types[106]
2573 #define SWIGTYPE_p_wxPCXHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPNGHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNMHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPaintEvent swig_types[110]
2577 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[111]
2578 #define SWIGTYPE_p_wxPaperSize swig_types[112]
2579 #define SWIGTYPE_p_wxPlatformInfo swig_types[113]
2580 #define SWIGTYPE_p_wxPoint swig_types[114]
2581 #define SWIGTYPE_p_wxPowerEvent swig_types[115]
2582 #define SWIGTYPE_p_wxProcessEvent swig_types[116]
2583 #define SWIGTYPE_p_wxPyApp swig_types[117]
2584 #define SWIGTYPE_p_wxPyArtProvider swig_types[118]
2585 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[119]
2586 #define SWIGTYPE_p_wxPyCommandEvent swig_types[120]
2587 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[121]
2588 #define SWIGTYPE_p_wxPyDropSource swig_types[122]
2589 #define SWIGTYPE_p_wxPyDropTarget swig_types[123]
2590 #define SWIGTYPE_p_wxPyEvent swig_types[124]
2591 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[125]
2592 #define SWIGTYPE_p_wxPyImageHandler swig_types[126]
2593 #define SWIGTYPE_p_wxPyLog swig_types[127]
2594 #define SWIGTYPE_p_wxPyProcess swig_types[128]
2595 #define SWIGTYPE_p_wxPySizer swig_types[129]
2596 #define SWIGTYPE_p_wxPyTextDataObject swig_types[130]
2597 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[131]
2598 #define SWIGTYPE_p_wxPyTimer swig_types[132]
2599 #define SWIGTYPE_p_wxPyTipProvider swig_types[133]
2600 #define SWIGTYPE_p_wxPyValidator swig_types[134]
2601 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[135]
2602 #define SWIGTYPE_p_wxRect swig_types[136]
2603 #define SWIGTYPE_p_wxScrollEvent swig_types[137]
2604 #define SWIGTYPE_p_wxScrollWinEvent swig_types[138]
2605 #define SWIGTYPE_p_wxSetCursorEvent swig_types[139]
2606 #define SWIGTYPE_p_wxShowEvent swig_types[140]
2607 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[141]
2608 #define SWIGTYPE_p_wxSize swig_types[142]
2609 #define SWIGTYPE_p_wxSizeEvent swig_types[143]
2610 #define SWIGTYPE_p_wxSizer swig_types[144]
2611 #define SWIGTYPE_p_wxSizerItem swig_types[145]
2612 #define SWIGTYPE_p_wxSound swig_types[146]
2613 #define SWIGTYPE_p_wxStandardPaths swig_types[147]
2614 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[148]
2615 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[149]
2616 #define SWIGTYPE_p_wxStopWatch swig_types[150]
2617 #define SWIGTYPE_p_wxString swig_types[151]
2618 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[152]
2619 #define SWIGTYPE_p_wxSystemOptions swig_types[153]
2620 #define SWIGTYPE_p_wxSystemSettings swig_types[154]
2621 #define SWIGTYPE_p_wxTIFFHandler swig_types[155]
2622 #define SWIGTYPE_p_wxTextCtrl swig_types[156]
2623 #define SWIGTYPE_p_wxTextDataObject swig_types[157]
2624 #define SWIGTYPE_p_wxTimeSpan swig_types[158]
2625 #define SWIGTYPE_p_wxTimer swig_types[159]
2626 #define SWIGTYPE_p_wxTimerEvent swig_types[160]
2627 #define SWIGTYPE_p_wxTimerRunner swig_types[161]
2628 #define SWIGTYPE_p_wxTipProvider swig_types[162]
2629 #define SWIGTYPE_p_wxToolTip swig_types[163]
2630 #define SWIGTYPE_p_wxURLDataObject swig_types[164]
2631 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[165]
2632 #define SWIGTYPE_p_wxValidator swig_types[166]
2633 #define SWIGTYPE_p_wxVideoMode swig_types[167]
2634 #define SWIGTYPE_p_wxWindow swig_types[168]
2635 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[169]
2636 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[170]
2637 #define SWIGTYPE_p_wxWindowDisabler swig_types[171]
2638 #define SWIGTYPE_p_wxXPMHandler swig_types[172]
2639 static swig_type_info *swig_types[174];
2640 static swig_module_info swig_module = {swig_types, 173, 0, 0, 0, 0};
2641 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2642 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2643
2644 /* -------- TYPES TABLE (END) -------- */
2645
2646 #if (PY_VERSION_HEX <= 0x02000000)
2647 # if !defined(SWIG_PYTHON_CLASSIC)
2648 # error "This python version requires to use swig with the '-classic' option"
2649 # endif
2650 #endif
2651 #if (PY_VERSION_HEX <= 0x02020000)
2652 # error "This python version requires to use swig with the '-nomodern' option"
2653 #endif
2654 #if (PY_VERSION_HEX <= 0x02020000)
2655 # error "This python version requires to use swig with the '-nomodernargs' option"
2656 #endif
2657 #ifndef METH_O
2658 # error "This python version requires to use swig with the '-nofastunpack' option"
2659 #endif
2660
2661 /*-----------------------------------------------
2662 @(target):= _misc_.so
2663 ------------------------------------------------*/
2664 #define SWIG_init init_misc_
2665
2666 #define SWIG_name "_misc_"
2667
2668 #define SWIGVERSION 0x010329
2669
2670
2671 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2672 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2673
2674
2675 #include <stdexcept>
2676
2677
2678 namespace swig {
2679 class PyObject_ptr {
2680 protected:
2681 PyObject *_obj;
2682
2683 public:
2684 PyObject_ptr() :_obj(0)
2685 {
2686 }
2687
2688 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2689 {
2690 Py_XINCREF(_obj);
2691 }
2692
2693 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2694 {
2695 if (initial_ref) Py_XINCREF(_obj);
2696 }
2697
2698 PyObject_ptr & operator=(const PyObject_ptr& item)
2699 {
2700 Py_XINCREF(item._obj);
2701 Py_XDECREF(_obj);
2702 _obj = item._obj;
2703 return *this;
2704 }
2705
2706 ~PyObject_ptr()
2707 {
2708 Py_XDECREF(_obj);
2709 }
2710
2711 operator PyObject *() const
2712 {
2713 return _obj;
2714 }
2715
2716 PyObject *operator->() const
2717 {
2718 return _obj;
2719 }
2720 };
2721 }
2722
2723
2724 namespace swig {
2725 struct PyObject_var : PyObject_ptr {
2726 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2727
2728 PyObject_var & operator = (PyObject* obj)
2729 {
2730 Py_XDECREF(_obj);
2731 _obj = obj;
2732 return *this;
2733 }
2734 };
2735 }
2736
2737
2738 #include "wx/wxPython/wxPython.h"
2739 #include "wx/wxPython/pyclasses.h"
2740 #include "wx/wxPython/pyistream.h"
2741
2742 static const wxString wxPyEmptyString(wxEmptyString);
2743
2744
2745
2746 #define SWIG_From_long PyInt_FromLong
2747
2748
2749 SWIGINTERNINLINE PyObject *
2750 SWIG_From_int (int value)
2751 {
2752 return SWIG_From_long (value);
2753 }
2754
2755
2756 #include <limits.h>
2757 #ifndef LLONG_MIN
2758 # define LLONG_MIN LONG_LONG_MIN
2759 #endif
2760 #ifndef LLONG_MAX
2761 # define LLONG_MAX LONG_LONG_MAX
2762 #endif
2763 #ifndef ULLONG_MAX
2764 # define ULLONG_MAX ULONG_LONG_MAX
2765 #endif
2766
2767
2768 SWIGINTERN int
2769 SWIG_AsVal_long (PyObject* obj, long* val)
2770 {
2771 if (PyNumber_Check(obj)) {
2772 if (val) *val = PyInt_AsLong(obj);
2773 return SWIG_OK;
2774 }
2775 return SWIG_TypeError;
2776 }
2777
2778
2779 SWIGINTERN int
2780 SWIG_AsVal_int (PyObject * obj, int *val)
2781 {
2782 long v;
2783 int res = SWIG_AsVal_long (obj, &v);
2784 if (SWIG_IsOK(res)) {
2785 if ((v < INT_MIN || v > INT_MAX)) {
2786 return SWIG_OverflowError;
2787 } else {
2788 if (val) *val = static_cast< int >(v);
2789 }
2790 }
2791 return res;
2792 }
2793
2794 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2795
2796 #include <wx/stockitem.h>
2797
2798 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2799 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2800 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2801
2802 SWIGINTERN int
2803 SWIG_AsVal_bool (PyObject *obj, bool *val)
2804 {
2805 if (obj == Py_True) {
2806 if (val) *val = true;
2807 return SWIG_OK;
2808 } else if (obj == Py_False) {
2809 if (val) *val = false;
2810 return SWIG_OK;
2811 } else {
2812 long v = 0;
2813 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2814 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2815 return res;
2816 }
2817 }
2818
2819
2820 SWIGINTERN int
2821 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2822 {
2823 long v = 0;
2824 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2825 return SWIG_TypeError;
2826 }
2827 else if (val)
2828 *val = (unsigned long)v;
2829 return SWIG_OK;
2830 }
2831
2832
2833 SWIGINTERNINLINE PyObject*
2834 SWIG_From_unsigned_SS_long (unsigned long value)
2835 {
2836 return (value > LONG_MAX) ?
2837 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2838 }
2839
2840
2841 void* wxGetXDisplay()
2842 {
2843 #ifdef __WXGTK__
2844 return wxGetDisplay();
2845 #else
2846 return NULL;
2847 #endif
2848 }
2849
2850
2851 wxWindow* FindWindowAtPointer() {
2852 wxPoint unused;
2853 return wxFindWindowAtPointer(unused);
2854 }
2855
2856
2857 bool wxThread_IsMain() {
2858 #ifdef WXP_WITH_THREAD
2859 return wxThread::IsMain();
2860 #else
2861 return true;
2862 #endif
2863 }
2864
2865 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2866 delete self;
2867 }
2868
2869 #include <wx/snglinst.h>
2870
2871
2872 #ifdef __WXMSW__
2873 #include <wx/msw/private.h>
2874 #include <wx/dynload.h>
2875 #endif
2876
2877
2878
2879 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2880 #if 0
2881 , int method
2882 #endif
2883 )
2884 {
2885 #ifdef __WXMSW__
2886 #if 0
2887 switch (method)
2888 {
2889 case 1:
2890 // This one only partially works. Appears to be an undocumented
2891 // "standard" convention that not all widgets adhear to. For
2892 // example, for some widgets backgrounds or non-client areas may
2893 // not be painted.
2894 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2895 break;
2896
2897 case 2:
2898 #endif
2899 // This one works much better, nearly all widgets and their
2900 // children are captured correctly[**]. Prior to the big
2901 // background erase changes that Vadim did in 2004-2005 this
2902 // method failed badly on XP with Themes activated, most native
2903 // widgets draw only partially, if at all. Without themes it
2904 // worked just like on Win2k. After those changes this method
2905 // works very well.
2906 //
2907 // ** For example the radio buttons in a wxRadioBox are not its
2908 // children by default, but you can capture it via the panel
2909 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2910 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2911 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2912 PRF_ERASEBKGND | PRF_OWNED );
2913 return true;
2914 #if 0
2915 break;
2916
2917 case 3:
2918 // This one is only defined in the latest SDK and is only
2919 // available on XP. MSDN says it is similar to sending WM_PRINT
2920 // so I expect that it will work similar to the above. Since it
2921 // is avaialble only on XP, it can't be compiled like this and
2922 // will have to be loaded dynamically.
2923 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2924
2925 // fall through
2926
2927 case 4:
2928 // Use PrintWindow if available, or fallback to WM_PRINT
2929 // otherwise. Unfortunately using PrintWindow is even worse than
2930 // WM_PRINT. For most native widgets nothing is drawn to the dc
2931 // at all, with or without Themes.
2932 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2933 static bool s_triedToLoad = false;
2934 static PrintWindow_t pfnPrintWindow = NULL;
2935 if ( !s_triedToLoad )
2936 {
2937
2938 s_triedToLoad = true;
2939 wxDynamicLibrary dllUser32(_T("user32.dll"));
2940 if ( dllUser32.IsLoaded() )
2941 {
2942 wxLogNull nolog; // Don't report errors here
2943 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2944 }
2945 }
2946 if (pfnPrintWindow)
2947 {
2948 //printf("Using PrintWindow\n");
2949 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2950 }
2951 else
2952 {
2953 //printf("Using WM_PRINT\n");
2954 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2955 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2956 PRF_ERASEBKGND | PRF_OWNED );
2957 }
2958 }
2959 #endif // 0
2960 #else
2961 return false;
2962 #endif // __WXMSW__
2963 }
2964
2965
2966
2967 #include <wx/tipdlg.h>
2968
2969
2970 SWIGINTERNINLINE PyObject *
2971 SWIG_From_size_t (size_t value)
2972 {
2973 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2974 }
2975
2976
2977 class wxPyTipProvider : public wxTipProvider {
2978 public:
2979 wxPyTipProvider(size_t currentTip)
2980 : wxTipProvider(currentTip) {}
2981
2982 DEC_PYCALLBACK_STRING__pure(GetTip);
2983 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2984 PYPRIVATE;
2985 };
2986
2987 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2988 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2989
2990
2991 SWIGINTERNINLINE int
2992 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2993 {
2994 unsigned long v;
2995 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2996 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2997 return res;
2998 }
2999
3000
3001 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3002
3003 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3004
3005 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3006 : wxTimer(owner, id)
3007 {
3008 if (owner == NULL)
3009 SetOwner(this);
3010 }
3011
3012
3013 SWIGINTERN swig_type_info*
3014 SWIG_pchar_descriptor()
3015 {
3016 static int init = 0;
3017 static swig_type_info* info = 0;
3018 if (!init) {
3019 info = SWIG_TypeQuery("_p_char");
3020 init = 1;
3021 }
3022 return info;
3023 }
3024
3025
3026 SWIGINTERNINLINE PyObject *
3027 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3028 {
3029 if (carray) {
3030 if (size > INT_MAX) {
3031 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3032 return pchar_descriptor ?
3033 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3034 } else {
3035 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3036 }
3037 } else {
3038 return SWIG_Py_Void();
3039 }
3040 }
3041
3042
3043 SWIGINTERNINLINE PyObject *
3044 SWIG_FromCharPtr(const char *cptr)
3045 {
3046 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3047 }
3048
3049
3050 SWIGINTERN int
3051 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3052 {
3053 unsigned long v;
3054 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3055 if (SWIG_IsOK(res)) {
3056 if ((v > UINT_MAX)) {
3057 return SWIG_OverflowError;
3058 } else {
3059 if (val) *val = static_cast< unsigned int >(v);
3060 }
3061 }
3062 return res;
3063 }
3064
3065 SWIGINTERN wxString wxLog_TimeStamp(){
3066 wxString msg;
3067 wxLog::TimeStamp(&msg);
3068 return msg;
3069 }
3070 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3071 // Make some wrappers that double any % signs so they are 'escaped'
3072 void wxPyLogFatalError(const wxString& msg)
3073 {
3074 wxString m(msg);
3075 m.Replace(wxT("%"), wxT("%%"));
3076 wxLogFatalError(m);
3077 }
3078
3079 void wxPyLogError(const wxString& msg)
3080 {
3081 wxString m(msg);
3082 m.Replace(wxT("%"), wxT("%%"));
3083 wxLogError(m);
3084 }
3085
3086 void wxPyLogWarning(const wxString& msg)
3087 {
3088 wxString m(msg);
3089 m.Replace(wxT("%"), wxT("%%"));
3090 wxLogWarning(m);
3091 }
3092
3093 void wxPyLogMessage(const wxString& msg)
3094 {
3095 wxString m(msg);
3096 m.Replace(wxT("%"), wxT("%%"));
3097 wxLogMessage(m);
3098 }
3099
3100 void wxPyLogInfo(const wxString& msg)
3101 {
3102 wxString m(msg);
3103 m.Replace(wxT("%"), wxT("%%"));
3104 wxLogInfo(m);
3105 }
3106
3107 void wxPyLogDebug(const wxString& msg)
3108 {
3109 wxString m(msg);
3110 m.Replace(wxT("%"), wxT("%%"));
3111 wxLogDebug(m);
3112 }
3113
3114 void wxPyLogVerbose(const wxString& msg)
3115 {
3116 wxString m(msg);
3117 m.Replace(wxT("%"), wxT("%%"));
3118 wxLogVerbose(m);
3119 }
3120
3121 void wxPyLogStatus(const wxString& msg)
3122 {
3123 wxString m(msg);
3124 m.Replace(wxT("%"), wxT("%%"));
3125 wxLogStatus(m);
3126 }
3127
3128 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3129 {
3130 wxString m(msg);
3131 m.Replace(wxT("%"), wxT("%%"));
3132 wxLogStatus(pFrame, m);
3133 }
3134
3135 void wxPyLogSysError(const wxString& msg)
3136 {
3137 wxString m(msg);
3138 m.Replace(wxT("%"), wxT("%%"));
3139 wxLogSysError(m);
3140 }
3141
3142 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3143 {
3144 wxString m(msg);
3145 m.Replace(wxT("%"), wxT("%%"));
3146 wxLogGeneric(level, m);
3147 }
3148
3149 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3150 {
3151 wxString m(msg);
3152 m.Replace(wxT("%"), wxT("%%"));
3153 wxLogTrace(mask, m);
3154 }
3155
3156 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3157 {
3158 wxString m(msg);
3159 m.Replace(wxT("%"), wxT("%%"));
3160 wxLogTrace(mask, m);
3161 }
3162
3163
3164
3165 // A wxLog class that can be derived from in wxPython
3166 class wxPyLog : public wxLog {
3167 public:
3168 wxPyLog() : wxLog() {}
3169
3170 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3171 bool found;
3172 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3173 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3174 PyObject* s = wx2PyString(szString);
3175 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3176 Py_DECREF(s);
3177 }
3178 wxPyEndBlockThreads(blocked);
3179 if (! found)
3180 wxLog::DoLog(level, szString, t);
3181 }
3182
3183 virtual void DoLogString(const wxChar *szString, time_t t) {
3184 bool found;
3185 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3186 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3187 PyObject* s = wx2PyString(szString);
3188 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3189 Py_DECREF(s);
3190 }
3191 wxPyEndBlockThreads(blocked);
3192 if (! found)
3193 wxLog::DoLogString(szString, t);
3194 }
3195
3196 DEC_PYCALLBACK_VOID_(Flush);
3197 PYPRIVATE;
3198 };
3199 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3200
3201
3202
3203
3204 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3205
3206
3207 #include <wx/joystick.h>
3208
3209
3210 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3211 // A C++ stub class for wxJoystick for platforms that don't have it.
3212 class wxJoystick : public wxObject {
3213 public:
3214 wxJoystick(int joystick = wxJOYSTICK1) {
3215 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3216 PyErr_SetString(PyExc_NotImplementedError,
3217 "wxJoystick is not available on this platform.");
3218 wxPyEndBlockThreads(blocked);
3219 }
3220 wxPoint GetPosition() { return wxPoint(-1,-1); }
3221 int GetZPosition() { return -1; }
3222 int GetButtonState() { return -1; }
3223 int GetPOVPosition() { return -1; }
3224 int GetPOVCTSPosition() { return -1; }
3225 int GetRudderPosition() { return -1; }
3226 int GetUPosition() { return -1; }
3227 int GetVPosition() { return -1; }
3228 int GetMovementThreshold() { return -1; }
3229 void SetMovementThreshold(int threshold) {}
3230
3231 bool IsOk(void) { return false; }
3232 int GetNumberJoysticks() { return -1; }
3233 int GetManufacturerId() { return -1; }
3234 int GetProductId() { return -1; }
3235 wxString GetProductName() { return wxEmptyString; }
3236 int GetXMin() { return -1; }
3237 int GetYMin() { return -1; }
3238 int GetZMin() { return -1; }
3239 int GetXMax() { return -1; }
3240 int GetYMax() { return -1; }
3241 int GetZMax() { return -1; }
3242 int GetNumberButtons() { return -1; }
3243 int GetNumberAxes() { return -1; }
3244 int GetMaxButtons() { return -1; }
3245 int GetMaxAxes() { return -1; }
3246 int GetPollingMin() { return -1; }
3247 int GetPollingMax() { return -1; }
3248 int GetRudderMin() { return -1; }
3249 int GetRudderMax() { return -1; }
3250 int GetUMin() { return -1; }
3251 int GetUMax() { return -1; }
3252 int GetVMin() { return -1; }
3253 int GetVMax() { return -1; }
3254
3255 bool HasRudder() { return false; }
3256 bool HasZ() { return false; }
3257 bool HasU() { return false; }
3258 bool HasV() { return false; }
3259 bool HasPOV() { return false; }
3260 bool HasPOV4Dir() { return false; }
3261 bool HasPOVCTS() { return false; }
3262
3263 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3264 bool ReleaseCapture() { return false; }
3265 };
3266 #endif
3267
3268
3269 #include <wx/sound.h>
3270
3271
3272 #if !wxUSE_SOUND
3273 // A C++ stub class for wxWave for platforms that don't have it.
3274 class wxSound : public wxObject
3275 {
3276 public:
3277 wxSound() {
3278 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3279 PyErr_SetString(PyExc_NotImplementedError,
3280 "wxSound is not available on this platform.");
3281 wxPyEndBlockThreads(blocked);
3282 }
3283 wxSound(const wxString&/*, bool*/) {
3284 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3285 PyErr_SetString(PyExc_NotImplementedError,
3286 "wxSound is not available on this platform.");
3287 wxPyEndBlockThreads(blocked);
3288 }
3289 wxSound(int, const wxByte*) {
3290 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3291 PyErr_SetString(PyExc_NotImplementedError,
3292 "wxSound is not available on this platform.");
3293 wxPyEndBlockThreads(blocked);
3294 }
3295
3296 ~wxSound() {};
3297
3298 bool Create(const wxString&/*, bool*/) { return false; }
3299 bool Create(int, const wxByte*) { return false; };
3300 bool IsOk() { return false; };
3301 bool Play(unsigned) const { return false; }
3302 static bool Play(const wxString&, unsigned) { return false; }
3303 static void Stop() {}
3304 };
3305
3306 #endif
3307
3308 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3309 if (fileName.Length() == 0)
3310 return new wxSound;
3311 else
3312 return new wxSound(fileName);
3313 }
3314 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3315 unsigned char* buffer; int size;
3316 wxSound *sound = NULL;
3317
3318 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3319 if (!PyArg_Parse(data, "t#", &buffer, &size))
3320 goto done;
3321 sound = new wxSound(size, buffer);
3322 done:
3323 wxPyEndBlockThreads(blocked);
3324 return sound;
3325 }
3326 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3327 #ifndef __WXMAC__
3328 unsigned char* buffer;
3329 int size;
3330 bool rv = false;
3331
3332 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3333 if (!PyArg_Parse(data, "t#", &buffer, &size))
3334 goto done;
3335 rv = self->Create(size, buffer);
3336 done:
3337 wxPyEndBlockThreads(blocked);
3338 return rv;
3339 #else
3340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3341 PyErr_SetString(PyExc_NotImplementedError,
3342 "Create from data is not available on this platform.");
3343 wxPyEndBlockThreads(blocked);
3344 return false;
3345 #endif
3346 }
3347
3348 #include <wx/mimetype.h>
3349
3350 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3351 wxString str;
3352 if (self->GetMimeType(&str))
3353 return wx2PyString(str);
3354 else
3355 RETURN_NONE();
3356 }
3357 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3358 wxArrayString arr;
3359 if (self->GetMimeTypes(arr))
3360 return wxArrayString2PyList_helper(arr);
3361 else
3362 RETURN_NONE();
3363 }
3364 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3365 wxArrayString arr;
3366 if (self->GetExtensions(arr))
3367 return wxArrayString2PyList_helper(arr);
3368 else
3369 RETURN_NONE();
3370 }
3371 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3372 wxIconLocation loc;
3373 if (self->GetIcon(&loc))
3374 return new wxIcon(loc);
3375 else
3376 return NULL;
3377 }
3378 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3379 wxIconLocation loc;
3380 if (self->GetIcon(&loc)) {
3381 wxString iconFile = loc.GetFileName();
3382 int iconIndex = -1;
3383
3384 iconIndex = loc.GetIndex();
3385
3386 // Make a tuple and put the values in it
3387 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3388 PyObject* tuple = PyTuple_New(3);
3389 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3390 wxT("wxIcon"), true));
3391 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3392 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3393 wxPyEndBlockThreads(blocked);
3394 return tuple;
3395 }
3396 else
3397 RETURN_NONE();
3398 }
3399 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3400 wxString str;
3401 if (self->GetDescription(&str))
3402 return wx2PyString(str);
3403 else
3404 RETURN_NONE();
3405 }
3406 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3407 wxString str;
3408 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3409 return wx2PyString(str);
3410 else
3411 RETURN_NONE();
3412 }
3413 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3414 wxString str;
3415 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3416 return wx2PyString(str);
3417 else
3418 RETURN_NONE();
3419 }
3420 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3421 wxArrayString verbs;
3422 wxArrayString commands;
3423 if (self->GetAllCommands(&verbs, &commands,
3424 wxFileType::MessageParameters(filename, mimetype))) {
3425 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3426 PyObject* tuple = PyTuple_New(2);
3427 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3428 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3429 wxPyEndBlockThreads(blocked);
3430 return tuple;
3431 }
3432 else
3433 RETURN_NONE();
3434 }
3435 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3436 return wxFileType::ExpandCommand(command,
3437 wxFileType::MessageParameters(filename, mimetype));
3438 }
3439 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3440 wxArrayString arr;
3441 self->EnumAllFileTypes(arr);
3442 return wxArrayString2PyList_helper(arr);
3443 }
3444
3445 #include <wx/artprov.h>
3446
3447 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3448 static const wxString wxPyART_MENU(wxART_MENU);
3449 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3450 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3451 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3452 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3453 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3454 static const wxString wxPyART_OTHER(wxART_OTHER);
3455 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3456 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3457 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3458 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3459 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3460 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3461 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3462 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3463 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3464 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3465 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3466 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3467 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3468 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3469 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3470 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3471 static const wxString wxPyART_PRINT(wxART_PRINT);
3472 static const wxString wxPyART_HELP(wxART_HELP);
3473 static const wxString wxPyART_TIP(wxART_TIP);
3474 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3475 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3476 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3477 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3478 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3479 static const wxString wxPyART_CDROM(wxART_CDROM);
3480 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3481 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3482 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3483 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3484 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3485 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3486 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3487 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3488 static const wxString wxPyART_ERROR(wxART_ERROR);
3489 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3490 static const wxString wxPyART_WARNING(wxART_WARNING);
3491 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3492 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3493 static const wxString wxPyART_COPY(wxART_COPY);
3494 static const wxString wxPyART_CUT(wxART_CUT);
3495 static const wxString wxPyART_PASTE(wxART_PASTE);
3496 static const wxString wxPyART_DELETE(wxART_DELETE);
3497 static const wxString wxPyART_NEW(wxART_NEW);
3498 static const wxString wxPyART_UNDO(wxART_UNDO);
3499 static const wxString wxPyART_REDO(wxART_REDO);
3500 static const wxString wxPyART_QUIT(wxART_QUIT);
3501 static const wxString wxPyART_FIND(wxART_FIND);
3502 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3503 // Python aware wxArtProvider
3504 class wxPyArtProvider : public wxArtProvider {
3505 public:
3506
3507 virtual wxBitmap CreateBitmap(const wxArtID& id,
3508 const wxArtClient& client,
3509 const wxSize& size) {
3510 wxBitmap rval = wxNullBitmap;
3511 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3512 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3513 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3514 PyObject* ro;
3515 wxBitmap* ptr;
3516 PyObject* s1, *s2;
3517 s1 = wx2PyString(id);
3518 s2 = wx2PyString(client);
3519 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3520 Py_DECREF(so);
3521 Py_DECREF(s1);
3522 Py_DECREF(s2);
3523 if (ro) {
3524 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3525 rval = *ptr;
3526 Py_DECREF(ro);
3527 }
3528 }
3529 wxPyEndBlockThreads(blocked);
3530 return rval;
3531 }
3532
3533 PYPRIVATE;
3534 };
3535
3536 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3537
3538
3539
3540 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3541 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3542 PyObject* ret = PyTuple_New(3);
3543 if (ret) {
3544 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3545 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3546 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3547 }
3548 wxPyEndBlockThreads(blocked);
3549 return ret;
3550 }
3551
3552 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3553 bool cont;
3554 long index = 0;
3555 wxString value;
3556
3557 cont = self->GetFirstGroup(value, index);
3558 return __EnumerationHelper(cont, value, index);
3559 }
3560 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3561 bool cont;
3562 wxString value;
3563
3564 cont = self->GetNextGroup(value, index);
3565 return __EnumerationHelper(cont, value, index);
3566 }
3567 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3568 bool cont;
3569 long index = 0;
3570 wxString value;
3571
3572 cont = self->GetFirstEntry(value, index);
3573 return __EnumerationHelper(cont, value, index);
3574 }
3575 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3576 bool cont;
3577 wxString value;
3578
3579 cont = self->GetNextEntry(value, index);
3580 return __EnumerationHelper(cont, value, index);
3581 }
3582 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3583 long rv;
3584 self->Read(key, &rv, defaultVal);
3585 return rv;
3586 }
3587
3588 SWIGINTERN int
3589 SWIG_AsVal_double (PyObject *obj, double* val)
3590 {
3591 if (PyNumber_Check(obj)) {
3592 if (val) *val = PyFloat_AsDouble(obj);
3593 return SWIG_OK;
3594 }
3595 return SWIG_TypeError;
3596 }
3597
3598 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3599 double rv;
3600 self->Read(key, &rv, defaultVal);
3601 return rv;
3602 }
3603
3604 #define SWIG_From_double PyFloat_FromDouble
3605
3606 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3607 bool rv;
3608 self->Read(key, &rv, defaultVal);
3609 return rv;
3610 }
3611
3612 #include <wx/datetime.h>
3613
3614 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3615 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3616
3617 #define LOCAL_TZ wxDateTime::Local
3618
3619 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3620 wxString am;
3621 wxString pm;
3622 wxDateTime::GetAmPmStrings(&am, &pm);
3623 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3624 PyObject* tup = PyTuple_New(2);
3625 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3626 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3627 wxPyEndBlockThreads(blocked);
3628 return tup;
3629 }
3630
3631 SWIGINTERNINLINE PyObject *
3632 SWIG_From_unsigned_SS_int (unsigned int value)
3633 {
3634 return SWIG_From_unsigned_SS_long (value);
3635 }
3636
3637 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3638 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3639 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3640 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3641 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3642 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3643 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3644 return (*self < *other);
3645 }
3646 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3647 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3648 return (*self <= *other);
3649 }
3650 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3651 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3652 return (*self > *other);
3653 }
3654 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3655 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3656 return (*self >= *other);
3657 }
3658 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3659 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3660 return (*self == *other);
3661 }
3662 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3663 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3664 return (*self != *other);
3665 }
3666 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3667 const wxChar* rv;
3668 const wxChar* _date = date;
3669 rv = self->ParseRfc822Date(_date);
3670 if (rv == NULL) return -1;
3671 return rv - _date;
3672 }
3673 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3674 const wxChar* rv;
3675 const wxChar* _date = date;
3676 rv = self->ParseFormat(_date, format, dateDef);
3677 if (rv == NULL) return -1;
3678 return rv - _date;
3679 }
3680 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3681 const wxChar* rv;
3682 const wxChar* _datetime = datetime;
3683 rv = self->ParseDateTime(_datetime);
3684 if (rv == NULL) return -1;
3685 return rv - _datetime;
3686 }
3687 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3688 const wxChar* rv;
3689 const wxChar* _date = date;
3690 rv = self->ParseDate(_date);
3691 if (rv == NULL) return -1;
3692 return rv - _date;
3693 }
3694 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3695 const wxChar* rv;
3696 const wxChar* _time = time;
3697 rv = self->ParseTime(_time);
3698 if (rv == NULL) return -1;
3699 return rv - _time;
3700 }
3701 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3702 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3703 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3704 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3705 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3706 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3707 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3708 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3709 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3710 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3711 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3712 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3713 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3714 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3715 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3716 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3717
3718 #include <wx/dataobj.h>
3719
3720 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3721 size_t count = self->GetFormatCount(dir);
3722 wxDataFormat* formats = new wxDataFormat[count];
3723 self->GetAllFormats(formats, dir);
3724
3725 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3726 PyObject* list = PyList_New(count);
3727 for (size_t i=0; i<count; i++) {
3728 wxDataFormat* format = new wxDataFormat(formats[i]);
3729 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3730 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3731 }
3732 wxPyEndBlockThreads(blocked);
3733 delete [] formats;
3734 return list;
3735 }
3736 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3737 PyObject* rval = NULL;
3738 size_t size = self->GetDataSize(format);
3739 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3740 if (size) {
3741 char* buf = new char[size];
3742 if (self->GetDataHere(format, buf))
3743 rval = PyString_FromStringAndSize(buf, size);
3744 delete [] buf;
3745 }
3746 if (! rval) {
3747 rval = Py_None;
3748 Py_INCREF(rval);
3749 }
3750 wxPyEndBlockThreads(blocked);
3751 return rval;
3752 }
3753 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3754 bool rval;
3755 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3756 if (PyString_Check(data)) {
3757 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3758 }
3759 else {
3760 // raise a TypeError if not a string
3761 PyErr_SetString(PyExc_TypeError, "String expected.");
3762 rval = false;
3763 }
3764 wxPyEndBlockThreads(blocked);
3765 return rval;
3766 }
3767 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3768 PyObject* rval = NULL;
3769 size_t size = self->GetDataSize();
3770 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3771 if (size) {
3772 char* buf = new char[size];
3773 if (self->GetDataHere(buf))
3774 rval = PyString_FromStringAndSize(buf, size);
3775 delete [] buf;
3776 }
3777 if (! rval) {
3778 rval = Py_None;
3779 Py_INCREF(rval);
3780 }
3781 wxPyEndBlockThreads(blocked);
3782 return rval;
3783 }
3784 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3785 bool rval;
3786 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3787 if (PyString_Check(data)) {
3788 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3789 }
3790 else {
3791 // raise a TypeError if not a string
3792 PyErr_SetString(PyExc_TypeError, "String expected.");
3793 rval = false;
3794 }
3795 wxPyEndBlockThreads(blocked);
3796 return rval;
3797 }
3798 // Create a new class for wxPython to use
3799 class wxPyDataObjectSimple : public wxDataObjectSimple {
3800 public:
3801 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3802 : wxDataObjectSimple(format) {}
3803
3804 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3805 bool GetDataHere(void *buf) const;
3806 bool SetData(size_t len, const void *buf);
3807 PYPRIVATE;
3808 };
3809
3810 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3811
3812 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3813 // We need to get the data for this object and write it to buf. I think
3814 // the best way to do this for wxPython is to have the Python method
3815 // return either a string or None and then act appropriately with the
3816 // C++ version.
3817
3818 bool rval = false;
3819 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3820 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3821 PyObject* ro;
3822 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3823 if (ro) {
3824 rval = (ro != Py_None && PyString_Check(ro));
3825 if (rval)
3826 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3827 Py_DECREF(ro);
3828 }
3829 }
3830 wxPyEndBlockThreads(blocked);
3831 return rval;
3832 }
3833
3834 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3835 // For this one we simply need to make a string from buf and len
3836 // and send it to the Python method.
3837 bool rval = false;
3838 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3839 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3840 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3841 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3842 Py_DECREF(data);
3843 }
3844 wxPyEndBlockThreads(blocked);
3845 return rval;
3846 }
3847
3848 // Create a new class for wxPython to use
3849 class wxPyTextDataObject : public wxTextDataObject {
3850 public:
3851 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3852 : wxTextDataObject(text) {}
3853
3854 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3855 DEC_PYCALLBACK_STRING__const(GetText);
3856 DEC_PYCALLBACK__STRING(SetText);
3857 PYPRIVATE;
3858 };
3859
3860 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3861 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3862 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3863
3864
3865 // Create a new class for wxPython to use
3866 class wxPyBitmapDataObject : public wxBitmapDataObject {
3867 public:
3868 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3869 : wxBitmapDataObject(bitmap) {}
3870
3871 wxBitmap GetBitmap() const;
3872 void SetBitmap(const wxBitmap& bitmap);
3873 PYPRIVATE;
3874 };
3875
3876 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3877 wxBitmap* rval = &wxNullBitmap;
3878 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3879 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3880 PyObject* ro;
3881 wxBitmap* ptr;
3882 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3883 if (ro) {
3884 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3885 rval = ptr;
3886 Py_DECREF(ro);
3887 }
3888 }
3889 wxPyEndBlockThreads(blocked);
3890 return *rval;
3891 }
3892
3893 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3894 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3895 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3896 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3897 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3898 Py_DECREF(bo);
3899 }
3900 wxPyEndBlockThreads(blocked);
3901 }
3902
3903 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3904 return new wxCustomDataObject(wxDataFormat(formatName));
3905 }
3906 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3907 bool rval;
3908 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3909 if (PyString_Check(data)) {
3910 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3911 }
3912 else {
3913 // raise a TypeError if not a string
3914 PyErr_SetString(PyExc_TypeError, "String expected.");
3915 rval = false;
3916 }
3917 wxPyEndBlockThreads(blocked);
3918 return rval;
3919 }
3920 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3921 PyObject* obj;
3922 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3923 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3924 wxPyEndBlockThreads(blocked);
3925 return obj;
3926 }
3927
3928 #include <wx/metafile.h>
3929
3930
3931 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3932
3933
3934 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3935 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3936 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3937 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3938 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3939
3940
3941 class wxPyTextDropTarget : public wxTextDropTarget {
3942 public:
3943 wxPyTextDropTarget() {}
3944
3945 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3946
3947 DEC_PYCALLBACK__(OnLeave);
3948 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3949 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3950 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3951 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3952
3953 PYPRIVATE;
3954 };
3955
3956 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3957 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3958 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3959 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3960 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3961 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3962
3963
3964
3965 class wxPyFileDropTarget : public wxFileDropTarget {
3966 public:
3967 wxPyFileDropTarget() {}
3968
3969 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3970
3971 DEC_PYCALLBACK__(OnLeave);
3972 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3973 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3974 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3975 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3976
3977 PYPRIVATE;
3978 };
3979
3980 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3981 const wxArrayString& filenames) {
3982 bool rval = false;
3983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3984 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3985 PyObject* list = wxArrayString2PyList_helper(filenames);
3986 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3987 Py_DECREF(list);
3988 }
3989 wxPyEndBlockThreads(blocked);
3990 return rval;
3991 }
3992
3993
3994
3995 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3996 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3997 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3998 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
3999 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4000
4001
4002
4003
4004 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4005
4006 #include <wx/display.h>
4007
4008 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4009 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4010
4011 #if !wxUSE_DISPLAY
4012 const wxVideoMode wxDefaultVideoMode;
4013 #endif
4014
4015 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4016 #if wxUSE_DISPLAY
4017 PyObject* pyList = NULL;
4018 wxArrayVideoModes arr = self->GetModes(mode);
4019 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4020 pyList = PyList_New(0);
4021 for (size_t i=0; i < arr.GetCount(); i++)
4022 {
4023 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4024 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4025 PyList_Append(pyList, pyObj);
4026 Py_DECREF(pyObj);
4027 }
4028 wxPyEndBlockThreads(blocked);
4029 return pyList;
4030 #else
4031 wxPyRaiseNotImplemented();
4032 return NULL;
4033 #endif
4034 }
4035 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4036 #if wxUSE_DISPLAY
4037 return self->GetCurrentMode();
4038 #else
4039 wxPyRaiseNotImplemented();
4040 return wxDefaultVideoMode;
4041 #endif
4042 }
4043 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4044 #if wxUSE_DISPLAY
4045 return self->ChangeMode(mode);
4046 #else
4047 wxPyRaiseNotImplemented();
4048 return false;
4049 #endif
4050 }
4051 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4052 #if wxUSE_DISPLAY
4053 self->ResetMode();
4054 #else
4055 wxPyRaiseNotImplemented();
4056 #endif
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
4067 #ifndef wxHAS_POWER_EVENTS
4068 // Dummy class and other definitions for platforms that don't have them
4069
4070 // See wxPython_int.h for wxPowerEvent
4071
4072 enum {
4073 wxEVT_POWER_SUSPENDING,
4074 wxEVT_POWER_SUSPENDED,
4075 wxEVT_POWER_SUSPEND_CANCEL,
4076 wxEVT_POWER_RESUME,
4077 };
4078
4079 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4080 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4081
4082 #endif
4083
4084 #ifdef __cplusplus
4085 extern "C" {
4086 #endif
4087 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4088 PyObject *resultobj = 0;
4089 wxSystemColour arg1 ;
4090 wxColour result;
4091 int val1 ;
4092 int ecode1 = 0 ;
4093 PyObject * obj0 = 0 ;
4094 char * kwnames[] = {
4095 (char *) "index", NULL
4096 };
4097
4098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4099 ecode1 = SWIG_AsVal_int(obj0, &val1);
4100 if (!SWIG_IsOK(ecode1)) {
4101 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4102 }
4103 arg1 = static_cast< wxSystemColour >(val1);
4104 {
4105 if (!wxPyCheckForApp()) SWIG_fail;
4106 PyThreadState* __tstate = wxPyBeginAllowThreads();
4107 result = wxSystemSettings::GetColour(arg1);
4108 wxPyEndAllowThreads(__tstate);
4109 if (PyErr_Occurred()) SWIG_fail;
4110 }
4111 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4112 return resultobj;
4113 fail:
4114 return NULL;
4115 }
4116
4117
4118 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4119 PyObject *resultobj = 0;
4120 wxSystemFont arg1 ;
4121 wxFont result;
4122 int val1 ;
4123 int ecode1 = 0 ;
4124 PyObject * obj0 = 0 ;
4125 char * kwnames[] = {
4126 (char *) "index", NULL
4127 };
4128
4129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4130 ecode1 = SWIG_AsVal_int(obj0, &val1);
4131 if (!SWIG_IsOK(ecode1)) {
4132 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4133 }
4134 arg1 = static_cast< wxSystemFont >(val1);
4135 {
4136 if (!wxPyCheckForApp()) SWIG_fail;
4137 PyThreadState* __tstate = wxPyBeginAllowThreads();
4138 result = wxSystemSettings::GetFont(arg1);
4139 wxPyEndAllowThreads(__tstate);
4140 if (PyErr_Occurred()) SWIG_fail;
4141 }
4142 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4143 return resultobj;
4144 fail:
4145 return NULL;
4146 }
4147
4148
4149 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4150 PyObject *resultobj = 0;
4151 wxSystemMetric arg1 ;
4152 wxWindow *arg2 = (wxWindow *) NULL ;
4153 int result;
4154 int val1 ;
4155 int ecode1 = 0 ;
4156 void *argp2 = 0 ;
4157 int res2 = 0 ;
4158 PyObject * obj0 = 0 ;
4159 PyObject * obj1 = 0 ;
4160 char * kwnames[] = {
4161 (char *) "index",(char *) "win", NULL
4162 };
4163
4164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4165 ecode1 = SWIG_AsVal_int(obj0, &val1);
4166 if (!SWIG_IsOK(ecode1)) {
4167 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4168 }
4169 arg1 = static_cast< wxSystemMetric >(val1);
4170 if (obj1) {
4171 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4172 if (!SWIG_IsOK(res2)) {
4173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4174 }
4175 arg2 = reinterpret_cast< wxWindow * >(argp2);
4176 }
4177 {
4178 if (!wxPyCheckForApp()) SWIG_fail;
4179 PyThreadState* __tstate = wxPyBeginAllowThreads();
4180 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4181 wxPyEndAllowThreads(__tstate);
4182 if (PyErr_Occurred()) SWIG_fail;
4183 }
4184 resultobj = SWIG_From_int(static_cast< int >(result));
4185 return resultobj;
4186 fail:
4187 return NULL;
4188 }
4189
4190
4191 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4192 PyObject *resultobj = 0;
4193 wxSystemFeature arg1 ;
4194 bool result;
4195 int val1 ;
4196 int ecode1 = 0 ;
4197 PyObject * obj0 = 0 ;
4198 char * kwnames[] = {
4199 (char *) "index", NULL
4200 };
4201
4202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4203 ecode1 = SWIG_AsVal_int(obj0, &val1);
4204 if (!SWIG_IsOK(ecode1)) {
4205 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4206 }
4207 arg1 = static_cast< wxSystemFeature >(val1);
4208 {
4209 if (!wxPyCheckForApp()) SWIG_fail;
4210 PyThreadState* __tstate = wxPyBeginAllowThreads();
4211 result = (bool)wxSystemSettings::HasFeature(arg1);
4212 wxPyEndAllowThreads(__tstate);
4213 if (PyErr_Occurred()) SWIG_fail;
4214 }
4215 {
4216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4217 }
4218 return resultobj;
4219 fail:
4220 return NULL;
4221 }
4222
4223
4224 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4225 PyObject *resultobj = 0;
4226 wxSystemScreenType result;
4227
4228 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4229 {
4230 if (!wxPyCheckForApp()) SWIG_fail;
4231 PyThreadState* __tstate = wxPyBeginAllowThreads();
4232 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4233 wxPyEndAllowThreads(__tstate);
4234 if (PyErr_Occurred()) SWIG_fail;
4235 }
4236 resultobj = SWIG_From_int(static_cast< int >(result));
4237 return resultobj;
4238 fail:
4239 return NULL;
4240 }
4241
4242
4243 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4244 PyObject *resultobj = 0;
4245 wxSystemScreenType arg1 ;
4246 int val1 ;
4247 int ecode1 = 0 ;
4248 PyObject * obj0 = 0 ;
4249 char * kwnames[] = {
4250 (char *) "screen", NULL
4251 };
4252
4253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4254 ecode1 = SWIG_AsVal_int(obj0, &val1);
4255 if (!SWIG_IsOK(ecode1)) {
4256 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4257 }
4258 arg1 = static_cast< wxSystemScreenType >(val1);
4259 {
4260 if (!wxPyCheckForApp()) SWIG_fail;
4261 PyThreadState* __tstate = wxPyBeginAllowThreads();
4262 wxSystemSettings::SetScreenType(arg1);
4263 wxPyEndAllowThreads(__tstate);
4264 if (PyErr_Occurred()) SWIG_fail;
4265 }
4266 resultobj = SWIG_Py_Void();
4267 return resultobj;
4268 fail:
4269 return NULL;
4270 }
4271
4272
4273 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4274 PyObject *obj;
4275 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4276 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4277 return SWIG_Py_Void();
4278 }
4279
4280 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4281 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4282 return 1;
4283 }
4284
4285
4286 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4287 PyObject *pyobj = 0;
4288
4289 {
4290 #if wxUSE_UNICODE
4291 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4292 #else
4293 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4294 #endif
4295 }
4296 return pyobj;
4297 }
4298
4299
4300 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4301 PyObject *resultobj = 0;
4302 wxSystemOptions *result = 0 ;
4303
4304 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4305 {
4306 PyThreadState* __tstate = wxPyBeginAllowThreads();
4307 result = (wxSystemOptions *)new wxSystemOptions();
4308 wxPyEndAllowThreads(__tstate);
4309 if (PyErr_Occurred()) SWIG_fail;
4310 }
4311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4312 return resultobj;
4313 fail:
4314 return NULL;
4315 }
4316
4317
4318 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4319 PyObject *resultobj = 0;
4320 wxString *arg1 = 0 ;
4321 wxString *arg2 = 0 ;
4322 bool temp1 = false ;
4323 bool temp2 = false ;
4324 PyObject * obj0 = 0 ;
4325 PyObject * obj1 = 0 ;
4326 char * kwnames[] = {
4327 (char *) "name",(char *) "value", NULL
4328 };
4329
4330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4331 {
4332 arg1 = wxString_in_helper(obj0);
4333 if (arg1 == NULL) SWIG_fail;
4334 temp1 = true;
4335 }
4336 {
4337 arg2 = wxString_in_helper(obj1);
4338 if (arg2 == NULL) SWIG_fail;
4339 temp2 = true;
4340 }
4341 {
4342 PyThreadState* __tstate = wxPyBeginAllowThreads();
4343 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4344 wxPyEndAllowThreads(__tstate);
4345 if (PyErr_Occurred()) SWIG_fail;
4346 }
4347 resultobj = SWIG_Py_Void();
4348 {
4349 if (temp1)
4350 delete arg1;
4351 }
4352 {
4353 if (temp2)
4354 delete arg2;
4355 }
4356 return resultobj;
4357 fail:
4358 {
4359 if (temp1)
4360 delete arg1;
4361 }
4362 {
4363 if (temp2)
4364 delete arg2;
4365 }
4366 return NULL;
4367 }
4368
4369
4370 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4371 PyObject *resultobj = 0;
4372 wxString *arg1 = 0 ;
4373 int arg2 ;
4374 bool temp1 = false ;
4375 int val2 ;
4376 int ecode2 = 0 ;
4377 PyObject * obj0 = 0 ;
4378 PyObject * obj1 = 0 ;
4379 char * kwnames[] = {
4380 (char *) "name",(char *) "value", NULL
4381 };
4382
4383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4384 {
4385 arg1 = wxString_in_helper(obj0);
4386 if (arg1 == NULL) SWIG_fail;
4387 temp1 = true;
4388 }
4389 ecode2 = SWIG_AsVal_int(obj1, &val2);
4390 if (!SWIG_IsOK(ecode2)) {
4391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4392 }
4393 arg2 = static_cast< int >(val2);
4394 {
4395 PyThreadState* __tstate = wxPyBeginAllowThreads();
4396 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4397 wxPyEndAllowThreads(__tstate);
4398 if (PyErr_Occurred()) SWIG_fail;
4399 }
4400 resultobj = SWIG_Py_Void();
4401 {
4402 if (temp1)
4403 delete arg1;
4404 }
4405 return resultobj;
4406 fail:
4407 {
4408 if (temp1)
4409 delete arg1;
4410 }
4411 return NULL;
4412 }
4413
4414
4415 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4416 PyObject *resultobj = 0;
4417 wxString *arg1 = 0 ;
4418 wxString result;
4419 bool temp1 = false ;
4420 PyObject * obj0 = 0 ;
4421 char * kwnames[] = {
4422 (char *) "name", NULL
4423 };
4424
4425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4426 {
4427 arg1 = wxString_in_helper(obj0);
4428 if (arg1 == NULL) SWIG_fail;
4429 temp1 = true;
4430 }
4431 {
4432 PyThreadState* __tstate = wxPyBeginAllowThreads();
4433 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4434 wxPyEndAllowThreads(__tstate);
4435 if (PyErr_Occurred()) SWIG_fail;
4436 }
4437 {
4438 #if wxUSE_UNICODE
4439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4440 #else
4441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4442 #endif
4443 }
4444 {
4445 if (temp1)
4446 delete arg1;
4447 }
4448 return resultobj;
4449 fail:
4450 {
4451 if (temp1)
4452 delete arg1;
4453 }
4454 return NULL;
4455 }
4456
4457
4458 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4459 PyObject *resultobj = 0;
4460 wxString *arg1 = 0 ;
4461 int result;
4462 bool temp1 = false ;
4463 PyObject * obj0 = 0 ;
4464 char * kwnames[] = {
4465 (char *) "name", NULL
4466 };
4467
4468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4469 {
4470 arg1 = wxString_in_helper(obj0);
4471 if (arg1 == NULL) SWIG_fail;
4472 temp1 = true;
4473 }
4474 {
4475 PyThreadState* __tstate = wxPyBeginAllowThreads();
4476 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4477 wxPyEndAllowThreads(__tstate);
4478 if (PyErr_Occurred()) SWIG_fail;
4479 }
4480 resultobj = SWIG_From_int(static_cast< int >(result));
4481 {
4482 if (temp1)
4483 delete arg1;
4484 }
4485 return resultobj;
4486 fail:
4487 {
4488 if (temp1)
4489 delete arg1;
4490 }
4491 return NULL;
4492 }
4493
4494
4495 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4496 PyObject *resultobj = 0;
4497 wxString *arg1 = 0 ;
4498 bool result;
4499 bool temp1 = false ;
4500 PyObject * obj0 = 0 ;
4501 char * kwnames[] = {
4502 (char *) "name", NULL
4503 };
4504
4505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4506 {
4507 arg1 = wxString_in_helper(obj0);
4508 if (arg1 == NULL) SWIG_fail;
4509 temp1 = true;
4510 }
4511 {
4512 PyThreadState* __tstate = wxPyBeginAllowThreads();
4513 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4514 wxPyEndAllowThreads(__tstate);
4515 if (PyErr_Occurred()) SWIG_fail;
4516 }
4517 {
4518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4519 }
4520 {
4521 if (temp1)
4522 delete arg1;
4523 }
4524 return resultobj;
4525 fail:
4526 {
4527 if (temp1)
4528 delete arg1;
4529 }
4530 return NULL;
4531 }
4532
4533
4534 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4535 PyObject *resultobj = 0;
4536 wxString *arg1 = 0 ;
4537 bool result;
4538 bool temp1 = false ;
4539 PyObject * obj0 = 0 ;
4540 char * kwnames[] = {
4541 (char *) "name", NULL
4542 };
4543
4544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4545 {
4546 arg1 = wxString_in_helper(obj0);
4547 if (arg1 == NULL) SWIG_fail;
4548 temp1 = true;
4549 }
4550 {
4551 PyThreadState* __tstate = wxPyBeginAllowThreads();
4552 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4553 wxPyEndAllowThreads(__tstate);
4554 if (PyErr_Occurred()) SWIG_fail;
4555 }
4556 {
4557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4558 }
4559 {
4560 if (temp1)
4561 delete arg1;
4562 }
4563 return resultobj;
4564 fail:
4565 {
4566 if (temp1)
4567 delete arg1;
4568 }
4569 return NULL;
4570 }
4571
4572
4573 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4574 PyObject *obj;
4575 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4576 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4577 return SWIG_Py_Void();
4578 }
4579
4580 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4581 return SWIG_Python_InitShadowInstance(args);
4582 }
4583
4584 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4585 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4586 return 1;
4587 }
4588
4589
4590 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4591 PyObject *pyobj = 0;
4592
4593 {
4594 #if wxUSE_UNICODE
4595 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4596 #else
4597 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4598 #endif
4599 }
4600 return pyobj;
4601 }
4602
4603
4604 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4605 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4606 return 1;
4607 }
4608
4609
4610 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4611 PyObject *pyobj = 0;
4612
4613 {
4614 #if wxUSE_UNICODE
4615 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4616 #else
4617 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4618 #endif
4619 }
4620 return pyobj;
4621 }
4622
4623
4624 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4625 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4626 return 1;
4627 }
4628
4629
4630 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4631 PyObject *pyobj = 0;
4632
4633 {
4634 #if wxUSE_UNICODE
4635 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4636 #else
4637 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4638 #endif
4639 }
4640 return pyobj;
4641 }
4642
4643
4644 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4645 PyObject *resultobj = 0;
4646 long result;
4647
4648 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4649 {
4650 PyThreadState* __tstate = wxPyBeginAllowThreads();
4651 result = (long)wxNewId();
4652 wxPyEndAllowThreads(__tstate);
4653 if (PyErr_Occurred()) SWIG_fail;
4654 }
4655 resultobj = SWIG_From_long(static_cast< long >(result));
4656 return resultobj;
4657 fail:
4658 return NULL;
4659 }
4660
4661
4662 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4663 PyObject *resultobj = 0;
4664 long arg1 ;
4665 long val1 ;
4666 int ecode1 = 0 ;
4667 PyObject * obj0 = 0 ;
4668 char * kwnames[] = {
4669 (char *) "id", NULL
4670 };
4671
4672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4673 ecode1 = SWIG_AsVal_long(obj0, &val1);
4674 if (!SWIG_IsOK(ecode1)) {
4675 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4676 }
4677 arg1 = static_cast< long >(val1);
4678 {
4679 PyThreadState* __tstate = wxPyBeginAllowThreads();
4680 wxRegisterId(arg1);
4681 wxPyEndAllowThreads(__tstate);
4682 if (PyErr_Occurred()) SWIG_fail;
4683 }
4684 resultobj = SWIG_Py_Void();
4685 return resultobj;
4686 fail:
4687 return NULL;
4688 }
4689
4690
4691 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4692 PyObject *resultobj = 0;
4693 long result;
4694
4695 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4696 {
4697 PyThreadState* __tstate = wxPyBeginAllowThreads();
4698 result = (long)wxGetCurrentId();
4699 wxPyEndAllowThreads(__tstate);
4700 if (PyErr_Occurred()) SWIG_fail;
4701 }
4702 resultobj = SWIG_From_long(static_cast< long >(result));
4703 return resultobj;
4704 fail:
4705 return NULL;
4706 }
4707
4708
4709 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4710 PyObject *resultobj = 0;
4711 int arg1 ;
4712 bool result;
4713 int val1 ;
4714 int ecode1 = 0 ;
4715 PyObject * obj0 = 0 ;
4716 char * kwnames[] = {
4717 (char *) "id", NULL
4718 };
4719
4720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4721 ecode1 = SWIG_AsVal_int(obj0, &val1);
4722 if (!SWIG_IsOK(ecode1)) {
4723 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4724 }
4725 arg1 = static_cast< int >(val1);
4726 {
4727 PyThreadState* __tstate = wxPyBeginAllowThreads();
4728 result = (bool)wxIsStockID(arg1);
4729 wxPyEndAllowThreads(__tstate);
4730 if (PyErr_Occurred()) SWIG_fail;
4731 }
4732 {
4733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4734 }
4735 return resultobj;
4736 fail:
4737 return NULL;
4738 }
4739
4740
4741 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4742 PyObject *resultobj = 0;
4743 int arg1 ;
4744 wxString *arg2 = 0 ;
4745 bool result;
4746 int val1 ;
4747 int ecode1 = 0 ;
4748 bool temp2 = false ;
4749 PyObject * obj0 = 0 ;
4750 PyObject * obj1 = 0 ;
4751 char * kwnames[] = {
4752 (char *) "id",(char *) "label", NULL
4753 };
4754
4755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4756 ecode1 = SWIG_AsVal_int(obj0, &val1);
4757 if (!SWIG_IsOK(ecode1)) {
4758 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4759 }
4760 arg1 = static_cast< int >(val1);
4761 {
4762 arg2 = wxString_in_helper(obj1);
4763 if (arg2 == NULL) SWIG_fail;
4764 temp2 = true;
4765 }
4766 {
4767 PyThreadState* __tstate = wxPyBeginAllowThreads();
4768 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4769 wxPyEndAllowThreads(__tstate);
4770 if (PyErr_Occurred()) SWIG_fail;
4771 }
4772 {
4773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4774 }
4775 {
4776 if (temp2)
4777 delete arg2;
4778 }
4779 return resultobj;
4780 fail:
4781 {
4782 if (temp2)
4783 delete arg2;
4784 }
4785 return NULL;
4786 }
4787
4788
4789 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4790 PyObject *resultobj = 0;
4791 int arg1 ;
4792 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4793 wxString result;
4794 int val1 ;
4795 int ecode1 = 0 ;
4796 long val2 ;
4797 int ecode2 = 0 ;
4798 PyObject * obj0 = 0 ;
4799 PyObject * obj1 = 0 ;
4800 char * kwnames[] = {
4801 (char *) "id",(char *) "flags", NULL
4802 };
4803
4804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4805 ecode1 = SWIG_AsVal_int(obj0, &val1);
4806 if (!SWIG_IsOK(ecode1)) {
4807 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4808 }
4809 arg1 = static_cast< int >(val1);
4810 if (obj1) {
4811 ecode2 = SWIG_AsVal_long(obj1, &val2);
4812 if (!SWIG_IsOK(ecode2)) {
4813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4814 }
4815 arg2 = static_cast< long >(val2);
4816 }
4817 {
4818 PyThreadState* __tstate = wxPyBeginAllowThreads();
4819 result = wxGetStockLabel(arg1,arg2);
4820 wxPyEndAllowThreads(__tstate);
4821 if (PyErr_Occurred()) SWIG_fail;
4822 }
4823 {
4824 #if wxUSE_UNICODE
4825 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4826 #else
4827 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4828 #endif
4829 }
4830 return resultobj;
4831 fail:
4832 return NULL;
4833 }
4834
4835
4836 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4837 PyObject *resultobj = 0;
4838 int arg1 ;
4839 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4840 wxString result;
4841 int val1 ;
4842 int ecode1 = 0 ;
4843 int val2 ;
4844 int ecode2 = 0 ;
4845 PyObject * obj0 = 0 ;
4846 PyObject * obj1 = 0 ;
4847 char * kwnames[] = {
4848 (char *) "id",(char *) "client", NULL
4849 };
4850
4851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4852 ecode1 = SWIG_AsVal_int(obj0, &val1);
4853 if (!SWIG_IsOK(ecode1)) {
4854 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4855 }
4856 arg1 = static_cast< int >(val1);
4857 if (obj1) {
4858 ecode2 = SWIG_AsVal_int(obj1, &val2);
4859 if (!SWIG_IsOK(ecode2)) {
4860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4861 }
4862 arg2 = static_cast< wxStockHelpStringClient >(val2);
4863 }
4864 {
4865 PyThreadState* __tstate = wxPyBeginAllowThreads();
4866 result = wxGetStockHelpString(arg1,arg2);
4867 wxPyEndAllowThreads(__tstate);
4868 if (PyErr_Occurred()) SWIG_fail;
4869 }
4870 {
4871 #if wxUSE_UNICODE
4872 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4873 #else
4874 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4875 #endif
4876 }
4877 return resultobj;
4878 fail:
4879 return NULL;
4880 }
4881
4882
4883 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4884 PyObject *resultobj = 0;
4885
4886 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4887 {
4888 if (!wxPyCheckForApp()) SWIG_fail;
4889 PyThreadState* __tstate = wxPyBeginAllowThreads();
4890 wxBell();
4891 wxPyEndAllowThreads(__tstate);
4892 if (PyErr_Occurred()) SWIG_fail;
4893 }
4894 resultobj = SWIG_Py_Void();
4895 return resultobj;
4896 fail:
4897 return NULL;
4898 }
4899
4900
4901 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4902 PyObject *resultobj = 0;
4903
4904 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4905 {
4906 if (!wxPyCheckForApp()) SWIG_fail;
4907 PyThreadState* __tstate = wxPyBeginAllowThreads();
4908 wxEndBusyCursor();
4909 wxPyEndAllowThreads(__tstate);
4910 if (PyErr_Occurred()) SWIG_fail;
4911 }
4912 resultobj = SWIG_Py_Void();
4913 return resultobj;
4914 fail:
4915 return NULL;
4916 }
4917
4918
4919 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4920 PyObject *resultobj = 0;
4921 bool arg1 = (bool) true ;
4922 long result;
4923 bool val1 ;
4924 int ecode1 = 0 ;
4925 PyObject * obj0 = 0 ;
4926 char * kwnames[] = {
4927 (char *) "resetTimer", NULL
4928 };
4929
4930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4931 if (obj0) {
4932 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4933 if (!SWIG_IsOK(ecode1)) {
4934 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4935 }
4936 arg1 = static_cast< bool >(val1);
4937 }
4938 {
4939 PyThreadState* __tstate = wxPyBeginAllowThreads();
4940 result = (long)wxGetElapsedTime(arg1);
4941 wxPyEndAllowThreads(__tstate);
4942 if (PyErr_Occurred()) SWIG_fail;
4943 }
4944 resultobj = SWIG_From_long(static_cast< long >(result));
4945 return resultobj;
4946 fail:
4947 return NULL;
4948 }
4949
4950
4951 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4952 PyObject *resultobj = 0;
4953 bool result;
4954
4955 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4956 {
4957 PyThreadState* __tstate = wxPyBeginAllowThreads();
4958 result = (bool)wxIsBusy();
4959 wxPyEndAllowThreads(__tstate);
4960 if (PyErr_Occurred()) SWIG_fail;
4961 }
4962 {
4963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4964 }
4965 return resultobj;
4966 fail:
4967 return NULL;
4968 }
4969
4970
4971 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4972 PyObject *resultobj = 0;
4973 wxString result;
4974
4975 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4976 {
4977 PyThreadState* __tstate = wxPyBeginAllowThreads();
4978 result = wxNow();
4979 wxPyEndAllowThreads(__tstate);
4980 if (PyErr_Occurred()) SWIG_fail;
4981 }
4982 {
4983 #if wxUSE_UNICODE
4984 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4985 #else
4986 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4987 #endif
4988 }
4989 return resultobj;
4990 fail:
4991 return NULL;
4992 }
4993
4994
4995 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4996 PyObject *resultobj = 0;
4997 wxString const &arg1_defvalue = wxPyEmptyString ;
4998 wxString *arg1 = (wxString *) &arg1_defvalue ;
4999 bool result;
5000 bool temp1 = false ;
5001 PyObject * obj0 = 0 ;
5002 char * kwnames[] = {
5003 (char *) "command", NULL
5004 };
5005
5006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5007 if (obj0) {
5008 {
5009 arg1 = wxString_in_helper(obj0);
5010 if (arg1 == NULL) SWIG_fail;
5011 temp1 = true;
5012 }
5013 }
5014 {
5015 PyThreadState* __tstate = wxPyBeginAllowThreads();
5016 result = (bool)wxShell((wxString const &)*arg1);
5017 wxPyEndAllowThreads(__tstate);
5018 if (PyErr_Occurred()) SWIG_fail;
5019 }
5020 {
5021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5022 }
5023 {
5024 if (temp1)
5025 delete arg1;
5026 }
5027 return resultobj;
5028 fail:
5029 {
5030 if (temp1)
5031 delete arg1;
5032 }
5033 return NULL;
5034 }
5035
5036
5037 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5038 PyObject *resultobj = 0;
5039
5040 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5041 {
5042 PyThreadState* __tstate = wxPyBeginAllowThreads();
5043 wxStartTimer();
5044 wxPyEndAllowThreads(__tstate);
5045 if (PyErr_Occurred()) SWIG_fail;
5046 }
5047 resultobj = SWIG_Py_Void();
5048 return resultobj;
5049 fail:
5050 return NULL;
5051 }
5052
5053
5054 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5055 PyObject *resultobj = 0;
5056 int *arg1 = (int *) 0 ;
5057 int *arg2 = (int *) 0 ;
5058 int result;
5059 int temp1 ;
5060 int res1 = SWIG_TMPOBJ ;
5061 int temp2 ;
5062 int res2 = SWIG_TMPOBJ ;
5063
5064 arg1 = &temp1;
5065 arg2 = &temp2;
5066 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5067 {
5068 PyThreadState* __tstate = wxPyBeginAllowThreads();
5069 result = (int)wxGetOsVersion(arg1,arg2);
5070 wxPyEndAllowThreads(__tstate);
5071 if (PyErr_Occurred()) SWIG_fail;
5072 }
5073 resultobj = SWIG_From_int(static_cast< int >(result));
5074 if (SWIG_IsTmpObj(res1)) {
5075 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5076 } else {
5077 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5078 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5079 }
5080 if (SWIG_IsTmpObj(res2)) {
5081 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5082 } else {
5083 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5084 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5085 }
5086 return resultobj;
5087 fail:
5088 return NULL;
5089 }
5090
5091
5092 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5093 PyObject *resultobj = 0;
5094 wxString result;
5095
5096 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5097 {
5098 PyThreadState* __tstate = wxPyBeginAllowThreads();
5099 result = wxGetOsDescription();
5100 wxPyEndAllowThreads(__tstate);
5101 if (PyErr_Occurred()) SWIG_fail;
5102 }
5103 {
5104 #if wxUSE_UNICODE
5105 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5106 #else
5107 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5108 #endif
5109 }
5110 return resultobj;
5111 fail:
5112 return NULL;
5113 }
5114
5115
5116 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5117 PyObject *resultobj = 0;
5118 bool result;
5119
5120 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5121 {
5122 PyThreadState* __tstate = wxPyBeginAllowThreads();
5123 result = (bool)wxIsPlatformLittleEndian();
5124 wxPyEndAllowThreads(__tstate);
5125 if (PyErr_Occurred()) SWIG_fail;
5126 }
5127 {
5128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5129 }
5130 return resultobj;
5131 fail:
5132 return NULL;
5133 }
5134
5135
5136 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5137 PyObject *resultobj = 0;
5138 bool result;
5139
5140 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5141 {
5142 PyThreadState* __tstate = wxPyBeginAllowThreads();
5143 result = (bool)wxIsPlatform64Bit();
5144 wxPyEndAllowThreads(__tstate);
5145 if (PyErr_Occurred()) SWIG_fail;
5146 }
5147 {
5148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5149 }
5150 return resultobj;
5151 fail:
5152 return NULL;
5153 }
5154
5155
5156 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5157 PyObject *resultobj = 0;
5158 wxMemorySize result;
5159
5160 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5161 {
5162 PyThreadState* __tstate = wxPyBeginAllowThreads();
5163 result = wxGetFreeMemory();
5164 wxPyEndAllowThreads(__tstate);
5165 if (PyErr_Occurred()) SWIG_fail;
5166 }
5167 {
5168 #if wxUSE_LONGLONG
5169 resultobj = PyLong_FromLongLong((&result)->GetValue());
5170 #else
5171 resultobj = PyInt_FromLong(result);
5172 #endif
5173 }
5174 return resultobj;
5175 fail:
5176 return NULL;
5177 }
5178
5179
5180 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5181 PyObject *resultobj = 0;
5182 wxShutdownFlags arg1 ;
5183 bool result;
5184 int val1 ;
5185 int ecode1 = 0 ;
5186 PyObject * obj0 = 0 ;
5187 char * kwnames[] = {
5188 (char *) "wFlags", NULL
5189 };
5190
5191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5192 ecode1 = SWIG_AsVal_int(obj0, &val1);
5193 if (!SWIG_IsOK(ecode1)) {
5194 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5195 }
5196 arg1 = static_cast< wxShutdownFlags >(val1);
5197 {
5198 if (!wxPyCheckForApp()) SWIG_fail;
5199 PyThreadState* __tstate = wxPyBeginAllowThreads();
5200 result = (bool)wxShutdown(arg1);
5201 wxPyEndAllowThreads(__tstate);
5202 if (PyErr_Occurred()) SWIG_fail;
5203 }
5204 {
5205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5206 }
5207 return resultobj;
5208 fail:
5209 return NULL;
5210 }
5211
5212
5213 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5214 PyObject *resultobj = 0;
5215 int arg1 ;
5216 int val1 ;
5217 int ecode1 = 0 ;
5218 PyObject * obj0 = 0 ;
5219 char * kwnames[] = {
5220 (char *) "secs", NULL
5221 };
5222
5223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5224 ecode1 = SWIG_AsVal_int(obj0, &val1);
5225 if (!SWIG_IsOK(ecode1)) {
5226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5227 }
5228 arg1 = static_cast< int >(val1);
5229 {
5230 PyThreadState* __tstate = wxPyBeginAllowThreads();
5231 wxSleep(arg1);
5232 wxPyEndAllowThreads(__tstate);
5233 if (PyErr_Occurred()) SWIG_fail;
5234 }
5235 resultobj = SWIG_Py_Void();
5236 return resultobj;
5237 fail:
5238 return NULL;
5239 }
5240
5241
5242 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5243 PyObject *resultobj = 0;
5244 unsigned long arg1 ;
5245 unsigned long val1 ;
5246 int ecode1 = 0 ;
5247 PyObject * obj0 = 0 ;
5248 char * kwnames[] = {
5249 (char *) "milliseconds", NULL
5250 };
5251
5252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5253 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5254 if (!SWIG_IsOK(ecode1)) {
5255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5256 }
5257 arg1 = static_cast< unsigned long >(val1);
5258 {
5259 PyThreadState* __tstate = wxPyBeginAllowThreads();
5260 wxMilliSleep(arg1);
5261 wxPyEndAllowThreads(__tstate);
5262 if (PyErr_Occurred()) SWIG_fail;
5263 }
5264 resultobj = SWIG_Py_Void();
5265 return resultobj;
5266 fail:
5267 return NULL;
5268 }
5269
5270
5271 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5272 PyObject *resultobj = 0;
5273 unsigned long arg1 ;
5274 unsigned long val1 ;
5275 int ecode1 = 0 ;
5276 PyObject * obj0 = 0 ;
5277 char * kwnames[] = {
5278 (char *) "microseconds", NULL
5279 };
5280
5281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5282 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5283 if (!SWIG_IsOK(ecode1)) {
5284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5285 }
5286 arg1 = static_cast< unsigned long >(val1);
5287 {
5288 PyThreadState* __tstate = wxPyBeginAllowThreads();
5289 wxMicroSleep(arg1);
5290 wxPyEndAllowThreads(__tstate);
5291 if (PyErr_Occurred()) SWIG_fail;
5292 }
5293 resultobj = SWIG_Py_Void();
5294 return resultobj;
5295 fail:
5296 return NULL;
5297 }
5298
5299
5300 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5301 PyObject *resultobj = 0;
5302 bool arg1 ;
5303 bool val1 ;
5304 int ecode1 = 0 ;
5305 PyObject * obj0 = 0 ;
5306 char * kwnames[] = {
5307 (char *) "enable", NULL
5308 };
5309
5310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5311 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5312 if (!SWIG_IsOK(ecode1)) {
5313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5314 }
5315 arg1 = static_cast< bool >(val1);
5316 {
5317 PyThreadState* __tstate = wxPyBeginAllowThreads();
5318 wxEnableTopLevelWindows(arg1);
5319 wxPyEndAllowThreads(__tstate);
5320 if (PyErr_Occurred()) SWIG_fail;
5321 }
5322 resultobj = SWIG_Py_Void();
5323 return resultobj;
5324 fail:
5325 return NULL;
5326 }
5327
5328
5329 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5330 PyObject *resultobj = 0;
5331 wxString *arg1 = 0 ;
5332 wxString result;
5333 bool temp1 = false ;
5334 PyObject * obj0 = 0 ;
5335 char * kwnames[] = {
5336 (char *) "in", NULL
5337 };
5338
5339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5340 {
5341 arg1 = wxString_in_helper(obj0);
5342 if (arg1 == NULL) SWIG_fail;
5343 temp1 = true;
5344 }
5345 {
5346 PyThreadState* __tstate = wxPyBeginAllowThreads();
5347 result = wxStripMenuCodes((wxString const &)*arg1);
5348 wxPyEndAllowThreads(__tstate);
5349 if (PyErr_Occurred()) SWIG_fail;
5350 }
5351 {
5352 #if wxUSE_UNICODE
5353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5354 #else
5355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5356 #endif
5357 }
5358 {
5359 if (temp1)
5360 delete arg1;
5361 }
5362 return resultobj;
5363 fail:
5364 {
5365 if (temp1)
5366 delete arg1;
5367 }
5368 return NULL;
5369 }
5370
5371
5372 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5373 PyObject *resultobj = 0;
5374 wxString result;
5375
5376 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5377 {
5378 PyThreadState* __tstate = wxPyBeginAllowThreads();
5379 result = wxGetEmailAddress();
5380 wxPyEndAllowThreads(__tstate);
5381 if (PyErr_Occurred()) SWIG_fail;
5382 }
5383 {
5384 #if wxUSE_UNICODE
5385 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5386 #else
5387 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5388 #endif
5389 }
5390 return resultobj;
5391 fail:
5392 return NULL;
5393 }
5394
5395
5396 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5397 PyObject *resultobj = 0;
5398 wxString result;
5399
5400 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5401 {
5402 PyThreadState* __tstate = wxPyBeginAllowThreads();
5403 result = wxGetHostName();
5404 wxPyEndAllowThreads(__tstate);
5405 if (PyErr_Occurred()) SWIG_fail;
5406 }
5407 {
5408 #if wxUSE_UNICODE
5409 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5410 #else
5411 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5412 #endif
5413 }
5414 return resultobj;
5415 fail:
5416 return NULL;
5417 }
5418
5419
5420 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5421 PyObject *resultobj = 0;
5422 wxString result;
5423
5424 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5425 {
5426 PyThreadState* __tstate = wxPyBeginAllowThreads();
5427 result = wxGetFullHostName();
5428 wxPyEndAllowThreads(__tstate);
5429 if (PyErr_Occurred()) SWIG_fail;
5430 }
5431 {
5432 #if wxUSE_UNICODE
5433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5434 #else
5435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5436 #endif
5437 }
5438 return resultobj;
5439 fail:
5440 return NULL;
5441 }
5442
5443
5444 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5445 PyObject *resultobj = 0;
5446 wxString result;
5447
5448 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5449 {
5450 PyThreadState* __tstate = wxPyBeginAllowThreads();
5451 result = wxGetUserId();
5452 wxPyEndAllowThreads(__tstate);
5453 if (PyErr_Occurred()) SWIG_fail;
5454 }
5455 {
5456 #if wxUSE_UNICODE
5457 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5458 #else
5459 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5460 #endif
5461 }
5462 return resultobj;
5463 fail:
5464 return NULL;
5465 }
5466
5467
5468 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5469 PyObject *resultobj = 0;
5470 wxString result;
5471
5472 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5473 {
5474 PyThreadState* __tstate = wxPyBeginAllowThreads();
5475 result = wxGetUserName();
5476 wxPyEndAllowThreads(__tstate);
5477 if (PyErr_Occurred()) SWIG_fail;
5478 }
5479 {
5480 #if wxUSE_UNICODE
5481 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5482 #else
5483 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5484 #endif
5485 }
5486 return resultobj;
5487 fail:
5488 return NULL;
5489 }
5490
5491
5492 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5493 PyObject *resultobj = 0;
5494 wxString result;
5495
5496 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5497 {
5498 PyThreadState* __tstate = wxPyBeginAllowThreads();
5499 result = wxGetHomeDir();
5500 wxPyEndAllowThreads(__tstate);
5501 if (PyErr_Occurred()) SWIG_fail;
5502 }
5503 {
5504 #if wxUSE_UNICODE
5505 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5506 #else
5507 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5508 #endif
5509 }
5510 return resultobj;
5511 fail:
5512 return NULL;
5513 }
5514
5515
5516 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5517 PyObject *resultobj = 0;
5518 wxString const &arg1_defvalue = wxPyEmptyString ;
5519 wxString *arg1 = (wxString *) &arg1_defvalue ;
5520 wxString result;
5521 bool temp1 = false ;
5522 PyObject * obj0 = 0 ;
5523 char * kwnames[] = {
5524 (char *) "user", NULL
5525 };
5526
5527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5528 if (obj0) {
5529 {
5530 arg1 = wxString_in_helper(obj0);
5531 if (arg1 == NULL) SWIG_fail;
5532 temp1 = true;
5533 }
5534 }
5535 {
5536 PyThreadState* __tstate = wxPyBeginAllowThreads();
5537 result = wxGetUserHome((wxString const &)*arg1);
5538 wxPyEndAllowThreads(__tstate);
5539 if (PyErr_Occurred()) SWIG_fail;
5540 }
5541 {
5542 #if wxUSE_UNICODE
5543 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5544 #else
5545 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5546 #endif
5547 }
5548 {
5549 if (temp1)
5550 delete arg1;
5551 }
5552 return resultobj;
5553 fail:
5554 {
5555 if (temp1)
5556 delete arg1;
5557 }
5558 return NULL;
5559 }
5560
5561
5562 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5563 PyObject *resultobj = 0;
5564 unsigned long result;
5565
5566 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5567 {
5568 PyThreadState* __tstate = wxPyBeginAllowThreads();
5569 result = (unsigned long)wxGetProcessId();
5570 wxPyEndAllowThreads(__tstate);
5571 if (PyErr_Occurred()) SWIG_fail;
5572 }
5573 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5574 return resultobj;
5575 fail:
5576 return NULL;
5577 }
5578
5579
5580 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5581 PyObject *resultobj = 0;
5582
5583 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5584 {
5585 PyThreadState* __tstate = wxPyBeginAllowThreads();
5586 wxTrap();
5587 wxPyEndAllowThreads(__tstate);
5588 if (PyErr_Occurred()) SWIG_fail;
5589 }
5590 resultobj = SWIG_Py_Void();
5591 return resultobj;
5592 fail:
5593 return NULL;
5594 }
5595
5596
5597 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5598 PyObject *resultobj = 0;
5599 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5600 wxString *arg1 = (wxString *) &arg1_defvalue ;
5601 wxString const &arg2_defvalue = wxPyEmptyString ;
5602 wxString *arg2 = (wxString *) &arg2_defvalue ;
5603 wxString const &arg3_defvalue = wxPyEmptyString ;
5604 wxString *arg3 = (wxString *) &arg3_defvalue ;
5605 wxString const &arg4_defvalue = wxPyEmptyString ;
5606 wxString *arg4 = (wxString *) &arg4_defvalue ;
5607 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5608 wxString *arg5 = (wxString *) &arg5_defvalue ;
5609 int arg6 = (int) 0 ;
5610 wxWindow *arg7 = (wxWindow *) NULL ;
5611 int arg8 = (int) -1 ;
5612 int arg9 = (int) -1 ;
5613 wxString result;
5614 bool temp1 = false ;
5615 bool temp2 = false ;
5616 bool temp3 = false ;
5617 bool temp4 = false ;
5618 bool temp5 = false ;
5619 int val6 ;
5620 int ecode6 = 0 ;
5621 void *argp7 = 0 ;
5622 int res7 = 0 ;
5623 int val8 ;
5624 int ecode8 = 0 ;
5625 int val9 ;
5626 int ecode9 = 0 ;
5627 PyObject * obj0 = 0 ;
5628 PyObject * obj1 = 0 ;
5629 PyObject * obj2 = 0 ;
5630 PyObject * obj3 = 0 ;
5631 PyObject * obj4 = 0 ;
5632 PyObject * obj5 = 0 ;
5633 PyObject * obj6 = 0 ;
5634 PyObject * obj7 = 0 ;
5635 PyObject * obj8 = 0 ;
5636 char * kwnames[] = {
5637 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5638 };
5639
5640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5641 if (obj0) {
5642 {
5643 arg1 = wxString_in_helper(obj0);
5644 if (arg1 == NULL) SWIG_fail;
5645 temp1 = true;
5646 }
5647 }
5648 if (obj1) {
5649 {
5650 arg2 = wxString_in_helper(obj1);
5651 if (arg2 == NULL) SWIG_fail;
5652 temp2 = true;
5653 }
5654 }
5655 if (obj2) {
5656 {
5657 arg3 = wxString_in_helper(obj2);
5658 if (arg3 == NULL) SWIG_fail;
5659 temp3 = true;
5660 }
5661 }
5662 if (obj3) {
5663 {
5664 arg4 = wxString_in_helper(obj3);
5665 if (arg4 == NULL) SWIG_fail;
5666 temp4 = true;
5667 }
5668 }
5669 if (obj4) {
5670 {
5671 arg5 = wxString_in_helper(obj4);
5672 if (arg5 == NULL) SWIG_fail;
5673 temp5 = true;
5674 }
5675 }
5676 if (obj5) {
5677 ecode6 = SWIG_AsVal_int(obj5, &val6);
5678 if (!SWIG_IsOK(ecode6)) {
5679 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5680 }
5681 arg6 = static_cast< int >(val6);
5682 }
5683 if (obj6) {
5684 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5685 if (!SWIG_IsOK(res7)) {
5686 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5687 }
5688 arg7 = reinterpret_cast< wxWindow * >(argp7);
5689 }
5690 if (obj7) {
5691 ecode8 = SWIG_AsVal_int(obj7, &val8);
5692 if (!SWIG_IsOK(ecode8)) {
5693 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5694 }
5695 arg8 = static_cast< int >(val8);
5696 }
5697 if (obj8) {
5698 ecode9 = SWIG_AsVal_int(obj8, &val9);
5699 if (!SWIG_IsOK(ecode9)) {
5700 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5701 }
5702 arg9 = static_cast< int >(val9);
5703 }
5704 {
5705 if (!wxPyCheckForApp()) SWIG_fail;
5706 PyThreadState* __tstate = wxPyBeginAllowThreads();
5707 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5708 wxPyEndAllowThreads(__tstate);
5709 if (PyErr_Occurred()) SWIG_fail;
5710 }
5711 {
5712 #if wxUSE_UNICODE
5713 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5714 #else
5715 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5716 #endif
5717 }
5718 {
5719 if (temp1)
5720 delete arg1;
5721 }
5722 {
5723 if (temp2)
5724 delete arg2;
5725 }
5726 {
5727 if (temp3)
5728 delete arg3;
5729 }
5730 {
5731 if (temp4)
5732 delete arg4;
5733 }
5734 {
5735 if (temp5)
5736 delete arg5;
5737 }
5738 return resultobj;
5739 fail:
5740 {
5741 if (temp1)
5742 delete arg1;
5743 }
5744 {
5745 if (temp2)
5746 delete arg2;
5747 }
5748 {
5749 if (temp3)
5750 delete arg3;
5751 }
5752 {
5753 if (temp4)
5754 delete arg4;
5755 }
5756 {
5757 if (temp5)
5758 delete arg5;
5759 }
5760 return NULL;
5761 }
5762
5763
5764 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5765 PyObject *resultobj = 0;
5766 wxString *arg1 = 0 ;
5767 wxString *arg2 = 0 ;
5768 wxString const &arg3_defvalue = wxPyEmptyString ;
5769 wxString *arg3 = (wxString *) &arg3_defvalue ;
5770 wxWindow *arg4 = (wxWindow *) NULL ;
5771 wxString result;
5772 bool temp1 = false ;
5773 bool temp2 = false ;
5774 bool temp3 = false ;
5775 void *argp4 = 0 ;
5776 int res4 = 0 ;
5777 PyObject * obj0 = 0 ;
5778 PyObject * obj1 = 0 ;
5779 PyObject * obj2 = 0 ;
5780 PyObject * obj3 = 0 ;
5781 char * kwnames[] = {
5782 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5783 };
5784
5785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5786 {
5787 arg1 = wxString_in_helper(obj0);
5788 if (arg1 == NULL) SWIG_fail;
5789 temp1 = true;
5790 }
5791 {
5792 arg2 = wxString_in_helper(obj1);
5793 if (arg2 == NULL) SWIG_fail;
5794 temp2 = true;
5795 }
5796 if (obj2) {
5797 {
5798 arg3 = wxString_in_helper(obj2);
5799 if (arg3 == NULL) SWIG_fail;
5800 temp3 = true;
5801 }
5802 }
5803 if (obj3) {
5804 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5805 if (!SWIG_IsOK(res4)) {
5806 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5807 }
5808 arg4 = reinterpret_cast< wxWindow * >(argp4);
5809 }
5810 {
5811 if (!wxPyCheckForApp()) SWIG_fail;
5812 PyThreadState* __tstate = wxPyBeginAllowThreads();
5813 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5814 wxPyEndAllowThreads(__tstate);
5815 if (PyErr_Occurred()) SWIG_fail;
5816 }
5817 {
5818 #if wxUSE_UNICODE
5819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5820 #else
5821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5822 #endif
5823 }
5824 {
5825 if (temp1)
5826 delete arg1;
5827 }
5828 {
5829 if (temp2)
5830 delete arg2;
5831 }
5832 {
5833 if (temp3)
5834 delete arg3;
5835 }
5836 return resultobj;
5837 fail:
5838 {
5839 if (temp1)
5840 delete arg1;
5841 }
5842 {
5843 if (temp2)
5844 delete arg2;
5845 }
5846 {
5847 if (temp3)
5848 delete arg3;
5849 }
5850 return NULL;
5851 }
5852
5853
5854 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5855 PyObject *resultobj = 0;
5856 wxString *arg1 = 0 ;
5857 wxString *arg2 = 0 ;
5858 wxString const &arg3_defvalue = wxPyEmptyString ;
5859 wxString *arg3 = (wxString *) &arg3_defvalue ;
5860 wxWindow *arg4 = (wxWindow *) NULL ;
5861 wxString result;
5862 bool temp1 = false ;
5863 bool temp2 = false ;
5864 bool temp3 = false ;
5865 void *argp4 = 0 ;
5866 int res4 = 0 ;
5867 PyObject * obj0 = 0 ;
5868 PyObject * obj1 = 0 ;
5869 PyObject * obj2 = 0 ;
5870 PyObject * obj3 = 0 ;
5871 char * kwnames[] = {
5872 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5873 };
5874
5875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5876 {
5877 arg1 = wxString_in_helper(obj0);
5878 if (arg1 == NULL) SWIG_fail;
5879 temp1 = true;
5880 }
5881 {
5882 arg2 = wxString_in_helper(obj1);
5883 if (arg2 == NULL) SWIG_fail;
5884 temp2 = true;
5885 }
5886 if (obj2) {
5887 {
5888 arg3 = wxString_in_helper(obj2);
5889 if (arg3 == NULL) SWIG_fail;
5890 temp3 = true;
5891 }
5892 }
5893 if (obj3) {
5894 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5895 if (!SWIG_IsOK(res4)) {
5896 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5897 }
5898 arg4 = reinterpret_cast< wxWindow * >(argp4);
5899 }
5900 {
5901 if (!wxPyCheckForApp()) SWIG_fail;
5902 PyThreadState* __tstate = wxPyBeginAllowThreads();
5903 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5904 wxPyEndAllowThreads(__tstate);
5905 if (PyErr_Occurred()) SWIG_fail;
5906 }
5907 {
5908 #if wxUSE_UNICODE
5909 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5910 #else
5911 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5912 #endif
5913 }
5914 {
5915 if (temp1)
5916 delete arg1;
5917 }
5918 {
5919 if (temp2)
5920 delete arg2;
5921 }
5922 {
5923 if (temp3)
5924 delete arg3;
5925 }
5926 return resultobj;
5927 fail:
5928 {
5929 if (temp1)
5930 delete arg1;
5931 }
5932 {
5933 if (temp2)
5934 delete arg2;
5935 }
5936 {
5937 if (temp3)
5938 delete arg3;
5939 }
5940 return NULL;
5941 }
5942
5943
5944 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5945 PyObject *resultobj = 0;
5946 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5947 wxString *arg1 = (wxString *) &arg1_defvalue ;
5948 wxString const &arg2_defvalue = wxPyEmptyString ;
5949 wxString *arg2 = (wxString *) &arg2_defvalue ;
5950 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5951 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5952 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5953 wxWindow *arg5 = (wxWindow *) NULL ;
5954 wxString result;
5955 bool temp1 = false ;
5956 bool temp2 = false ;
5957 long val3 ;
5958 int ecode3 = 0 ;
5959 wxPoint temp4 ;
5960 void *argp5 = 0 ;
5961 int res5 = 0 ;
5962 PyObject * obj0 = 0 ;
5963 PyObject * obj1 = 0 ;
5964 PyObject * obj2 = 0 ;
5965 PyObject * obj3 = 0 ;
5966 PyObject * obj4 = 0 ;
5967 char * kwnames[] = {
5968 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5969 };
5970
5971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5972 if (obj0) {
5973 {
5974 arg1 = wxString_in_helper(obj0);
5975 if (arg1 == NULL) SWIG_fail;
5976 temp1 = true;
5977 }
5978 }
5979 if (obj1) {
5980 {
5981 arg2 = wxString_in_helper(obj1);
5982 if (arg2 == NULL) SWIG_fail;
5983 temp2 = true;
5984 }
5985 }
5986 if (obj2) {
5987 ecode3 = SWIG_AsVal_long(obj2, &val3);
5988 if (!SWIG_IsOK(ecode3)) {
5989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5990 }
5991 arg3 = static_cast< long >(val3);
5992 }
5993 if (obj3) {
5994 {
5995 arg4 = &temp4;
5996 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5997 }
5998 }
5999 if (obj4) {
6000 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6001 if (!SWIG_IsOK(res5)) {
6002 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6003 }
6004 arg5 = reinterpret_cast< wxWindow * >(argp5);
6005 }
6006 {
6007 if (!wxPyCheckForApp()) SWIG_fail;
6008 PyThreadState* __tstate = wxPyBeginAllowThreads();
6009 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6010 wxPyEndAllowThreads(__tstate);
6011 if (PyErr_Occurred()) SWIG_fail;
6012 }
6013 {
6014 #if wxUSE_UNICODE
6015 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6016 #else
6017 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6018 #endif
6019 }
6020 {
6021 if (temp1)
6022 delete arg1;
6023 }
6024 {
6025 if (temp2)
6026 delete arg2;
6027 }
6028 return resultobj;
6029 fail:
6030 {
6031 if (temp1)
6032 delete arg1;
6033 }
6034 {
6035 if (temp2)
6036 delete arg2;
6037 }
6038 return NULL;
6039 }
6040
6041
6042 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6043 PyObject *resultobj = 0;
6044 wxString *arg1 = 0 ;
6045 wxString const &arg2_defvalue = wxPyEmptyString ;
6046 wxString *arg2 = (wxString *) &arg2_defvalue ;
6047 wxString const &arg3_defvalue = wxPyEmptyString ;
6048 wxString *arg3 = (wxString *) &arg3_defvalue ;
6049 wxWindow *arg4 = (wxWindow *) NULL ;
6050 int arg5 = (int) -1 ;
6051 int arg6 = (int) -1 ;
6052 bool arg7 = (bool) true ;
6053 wxString result;
6054 bool temp1 = false ;
6055 bool temp2 = false ;
6056 bool temp3 = false ;
6057 void *argp4 = 0 ;
6058 int res4 = 0 ;
6059 int val5 ;
6060 int ecode5 = 0 ;
6061 int val6 ;
6062 int ecode6 = 0 ;
6063 bool val7 ;
6064 int ecode7 = 0 ;
6065 PyObject * obj0 = 0 ;
6066 PyObject * obj1 = 0 ;
6067 PyObject * obj2 = 0 ;
6068 PyObject * obj3 = 0 ;
6069 PyObject * obj4 = 0 ;
6070 PyObject * obj5 = 0 ;
6071 PyObject * obj6 = 0 ;
6072 char * kwnames[] = {
6073 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6074 };
6075
6076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6077 {
6078 arg1 = wxString_in_helper(obj0);
6079 if (arg1 == NULL) SWIG_fail;
6080 temp1 = true;
6081 }
6082 if (obj1) {
6083 {
6084 arg2 = wxString_in_helper(obj1);
6085 if (arg2 == NULL) SWIG_fail;
6086 temp2 = true;
6087 }
6088 }
6089 if (obj2) {
6090 {
6091 arg3 = wxString_in_helper(obj2);
6092 if (arg3 == NULL) SWIG_fail;
6093 temp3 = true;
6094 }
6095 }
6096 if (obj3) {
6097 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6098 if (!SWIG_IsOK(res4)) {
6099 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6100 }
6101 arg4 = reinterpret_cast< wxWindow * >(argp4);
6102 }
6103 if (obj4) {
6104 ecode5 = SWIG_AsVal_int(obj4, &val5);
6105 if (!SWIG_IsOK(ecode5)) {
6106 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6107 }
6108 arg5 = static_cast< int >(val5);
6109 }
6110 if (obj5) {
6111 ecode6 = SWIG_AsVal_int(obj5, &val6);
6112 if (!SWIG_IsOK(ecode6)) {
6113 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6114 }
6115 arg6 = static_cast< int >(val6);
6116 }
6117 if (obj6) {
6118 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6119 if (!SWIG_IsOK(ecode7)) {
6120 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6121 }
6122 arg7 = static_cast< bool >(val7);
6123 }
6124 {
6125 if (!wxPyCheckForApp()) SWIG_fail;
6126 PyThreadState* __tstate = wxPyBeginAllowThreads();
6127 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6128 wxPyEndAllowThreads(__tstate);
6129 if (PyErr_Occurred()) SWIG_fail;
6130 }
6131 {
6132 #if wxUSE_UNICODE
6133 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6134 #else
6135 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6136 #endif
6137 }
6138 {
6139 if (temp1)
6140 delete arg1;
6141 }
6142 {
6143 if (temp2)
6144 delete arg2;
6145 }
6146 {
6147 if (temp3)
6148 delete arg3;
6149 }
6150 return resultobj;
6151 fail:
6152 {
6153 if (temp1)
6154 delete arg1;
6155 }
6156 {
6157 if (temp2)
6158 delete arg2;
6159 }
6160 {
6161 if (temp3)
6162 delete arg3;
6163 }
6164 return NULL;
6165 }
6166
6167
6168 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6169 PyObject *resultobj = 0;
6170 wxString *arg1 = 0 ;
6171 wxString const &arg2_defvalue = wxPyEmptyString ;
6172 wxString *arg2 = (wxString *) &arg2_defvalue ;
6173 wxString const &arg3_defvalue = wxPyEmptyString ;
6174 wxString *arg3 = (wxString *) &arg3_defvalue ;
6175 wxWindow *arg4 = (wxWindow *) NULL ;
6176 wxString result;
6177 bool temp1 = false ;
6178 bool temp2 = false ;
6179 bool temp3 = false ;
6180 void *argp4 = 0 ;
6181 int res4 = 0 ;
6182 PyObject * obj0 = 0 ;
6183 PyObject * obj1 = 0 ;
6184 PyObject * obj2 = 0 ;
6185 PyObject * obj3 = 0 ;
6186 char * kwnames[] = {
6187 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6188 };
6189
6190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6191 {
6192 arg1 = wxString_in_helper(obj0);
6193 if (arg1 == NULL) SWIG_fail;
6194 temp1 = true;
6195 }
6196 if (obj1) {
6197 {
6198 arg2 = wxString_in_helper(obj1);
6199 if (arg2 == NULL) SWIG_fail;
6200 temp2 = true;
6201 }
6202 }
6203 if (obj2) {
6204 {
6205 arg3 = wxString_in_helper(obj2);
6206 if (arg3 == NULL) SWIG_fail;
6207 temp3 = true;
6208 }
6209 }
6210 if (obj3) {
6211 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6212 if (!SWIG_IsOK(res4)) {
6213 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6214 }
6215 arg4 = reinterpret_cast< wxWindow * >(argp4);
6216 }
6217 {
6218 if (!wxPyCheckForApp()) SWIG_fail;
6219 PyThreadState* __tstate = wxPyBeginAllowThreads();
6220 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6221 wxPyEndAllowThreads(__tstate);
6222 if (PyErr_Occurred()) SWIG_fail;
6223 }
6224 {
6225 #if wxUSE_UNICODE
6226 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6227 #else
6228 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6229 #endif
6230 }
6231 {
6232 if (temp1)
6233 delete arg1;
6234 }
6235 {
6236 if (temp2)
6237 delete arg2;
6238 }
6239 {
6240 if (temp3)
6241 delete arg3;
6242 }
6243 return resultobj;
6244 fail:
6245 {
6246 if (temp1)
6247 delete arg1;
6248 }
6249 {
6250 if (temp2)
6251 delete arg2;
6252 }
6253 {
6254 if (temp3)
6255 delete arg3;
6256 }
6257 return NULL;
6258 }
6259
6260
6261 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6262 PyObject *resultobj = 0;
6263 wxString *arg1 = 0 ;
6264 wxString *arg2 = 0 ;
6265 int arg3 ;
6266 wxString *arg4 = (wxString *) 0 ;
6267 wxWindow *arg5 = (wxWindow *) NULL ;
6268 int arg6 = (int) -1 ;
6269 int arg7 = (int) -1 ;
6270 bool arg8 = (bool) true ;
6271 int arg9 = (int) 150 ;
6272 int arg10 = (int) 200 ;
6273 wxString result;
6274 bool temp1 = false ;
6275 bool temp2 = false ;
6276 void *argp5 = 0 ;
6277 int res5 = 0 ;
6278 int val6 ;
6279 int ecode6 = 0 ;
6280 int val7 ;
6281 int ecode7 = 0 ;
6282 bool val8 ;
6283 int ecode8 = 0 ;
6284 int val9 ;
6285 int ecode9 = 0 ;
6286 int val10 ;
6287 int ecode10 = 0 ;
6288 PyObject * obj0 = 0 ;
6289 PyObject * obj1 = 0 ;
6290 PyObject * obj2 = 0 ;
6291 PyObject * obj3 = 0 ;
6292 PyObject * obj4 = 0 ;
6293 PyObject * obj5 = 0 ;
6294 PyObject * obj6 = 0 ;
6295 PyObject * obj7 = 0 ;
6296 PyObject * obj8 = 0 ;
6297 char * kwnames[] = {
6298 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6299 };
6300
6301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6302 {
6303 arg1 = wxString_in_helper(obj0);
6304 if (arg1 == NULL) SWIG_fail;
6305 temp1 = true;
6306 }
6307 {
6308 arg2 = wxString_in_helper(obj1);
6309 if (arg2 == NULL) SWIG_fail;
6310 temp2 = true;
6311 }
6312 {
6313 arg3 = PyList_Size(obj2);
6314 arg4 = wxString_LIST_helper(obj2);
6315 if (arg4 == NULL) SWIG_fail;
6316 }
6317 if (obj3) {
6318 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6319 if (!SWIG_IsOK(res5)) {
6320 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6321 }
6322 arg5 = reinterpret_cast< wxWindow * >(argp5);
6323 }
6324 if (obj4) {
6325 ecode6 = SWIG_AsVal_int(obj4, &val6);
6326 if (!SWIG_IsOK(ecode6)) {
6327 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6328 }
6329 arg6 = static_cast< int >(val6);
6330 }
6331 if (obj5) {
6332 ecode7 = SWIG_AsVal_int(obj5, &val7);
6333 if (!SWIG_IsOK(ecode7)) {
6334 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6335 }
6336 arg7 = static_cast< int >(val7);
6337 }
6338 if (obj6) {
6339 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6340 if (!SWIG_IsOK(ecode8)) {
6341 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6342 }
6343 arg8 = static_cast< bool >(val8);
6344 }
6345 if (obj7) {
6346 ecode9 = SWIG_AsVal_int(obj7, &val9);
6347 if (!SWIG_IsOK(ecode9)) {
6348 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6349 }
6350 arg9 = static_cast< int >(val9);
6351 }
6352 if (obj8) {
6353 ecode10 = SWIG_AsVal_int(obj8, &val10);
6354 if (!SWIG_IsOK(ecode10)) {
6355 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6356 }
6357 arg10 = static_cast< int >(val10);
6358 }
6359 {
6360 if (!wxPyCheckForApp()) SWIG_fail;
6361 PyThreadState* __tstate = wxPyBeginAllowThreads();
6362 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6363 wxPyEndAllowThreads(__tstate);
6364 if (PyErr_Occurred()) SWIG_fail;
6365 }
6366 {
6367 #if wxUSE_UNICODE
6368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6369 #else
6370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6371 #endif
6372 }
6373 {
6374 if (temp1)
6375 delete arg1;
6376 }
6377 {
6378 if (temp2)
6379 delete arg2;
6380 }
6381 {
6382 if (arg4) delete [] arg4;
6383 }
6384 return resultobj;
6385 fail:
6386 {
6387 if (temp1)
6388 delete arg1;
6389 }
6390 {
6391 if (temp2)
6392 delete arg2;
6393 }
6394 {
6395 if (arg4) delete [] arg4;
6396 }
6397 return NULL;
6398 }
6399
6400
6401 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6402 PyObject *resultobj = 0;
6403 wxString *arg1 = 0 ;
6404 wxString *arg2 = 0 ;
6405 int arg3 ;
6406 wxString *arg4 = (wxString *) 0 ;
6407 wxWindow *arg5 = (wxWindow *) NULL ;
6408 int arg6 = (int) -1 ;
6409 int arg7 = (int) -1 ;
6410 bool arg8 = (bool) true ;
6411 int arg9 = (int) 150 ;
6412 int arg10 = (int) 200 ;
6413 int result;
6414 bool temp1 = false ;
6415 bool temp2 = false ;
6416 void *argp5 = 0 ;
6417 int res5 = 0 ;
6418 int val6 ;
6419 int ecode6 = 0 ;
6420 int val7 ;
6421 int ecode7 = 0 ;
6422 bool val8 ;
6423 int ecode8 = 0 ;
6424 int val9 ;
6425 int ecode9 = 0 ;
6426 int val10 ;
6427 int ecode10 = 0 ;
6428 PyObject * obj0 = 0 ;
6429 PyObject * obj1 = 0 ;
6430 PyObject * obj2 = 0 ;
6431 PyObject * obj3 = 0 ;
6432 PyObject * obj4 = 0 ;
6433 PyObject * obj5 = 0 ;
6434 PyObject * obj6 = 0 ;
6435 PyObject * obj7 = 0 ;
6436 PyObject * obj8 = 0 ;
6437 char * kwnames[] = {
6438 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6439 };
6440
6441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6442 {
6443 arg1 = wxString_in_helper(obj0);
6444 if (arg1 == NULL) SWIG_fail;
6445 temp1 = true;
6446 }
6447 {
6448 arg2 = wxString_in_helper(obj1);
6449 if (arg2 == NULL) SWIG_fail;
6450 temp2 = true;
6451 }
6452 {
6453 arg3 = PyList_Size(obj2);
6454 arg4 = wxString_LIST_helper(obj2);
6455 if (arg4 == NULL) SWIG_fail;
6456 }
6457 if (obj3) {
6458 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6459 if (!SWIG_IsOK(res5)) {
6460 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6461 }
6462 arg5 = reinterpret_cast< wxWindow * >(argp5);
6463 }
6464 if (obj4) {
6465 ecode6 = SWIG_AsVal_int(obj4, &val6);
6466 if (!SWIG_IsOK(ecode6)) {
6467 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6468 }
6469 arg6 = static_cast< int >(val6);
6470 }
6471 if (obj5) {
6472 ecode7 = SWIG_AsVal_int(obj5, &val7);
6473 if (!SWIG_IsOK(ecode7)) {
6474 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6475 }
6476 arg7 = static_cast< int >(val7);
6477 }
6478 if (obj6) {
6479 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6480 if (!SWIG_IsOK(ecode8)) {
6481 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6482 }
6483 arg8 = static_cast< bool >(val8);
6484 }
6485 if (obj7) {
6486 ecode9 = SWIG_AsVal_int(obj7, &val9);
6487 if (!SWIG_IsOK(ecode9)) {
6488 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6489 }
6490 arg9 = static_cast< int >(val9);
6491 }
6492 if (obj8) {
6493 ecode10 = SWIG_AsVal_int(obj8, &val10);
6494 if (!SWIG_IsOK(ecode10)) {
6495 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6496 }
6497 arg10 = static_cast< int >(val10);
6498 }
6499 {
6500 if (!wxPyCheckForApp()) SWIG_fail;
6501 PyThreadState* __tstate = wxPyBeginAllowThreads();
6502 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6503 wxPyEndAllowThreads(__tstate);
6504 if (PyErr_Occurred()) SWIG_fail;
6505 }
6506 resultobj = SWIG_From_int(static_cast< int >(result));
6507 {
6508 if (temp1)
6509 delete arg1;
6510 }
6511 {
6512 if (temp2)
6513 delete arg2;
6514 }
6515 {
6516 if (arg4) delete [] arg4;
6517 }
6518 return resultobj;
6519 fail:
6520 {
6521 if (temp1)
6522 delete arg1;
6523 }
6524 {
6525 if (temp2)
6526 delete arg2;
6527 }
6528 {
6529 if (arg4) delete [] arg4;
6530 }
6531 return NULL;
6532 }
6533
6534
6535 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6536 PyObject *resultobj = 0;
6537 wxString *arg1 = 0 ;
6538 wxString const &arg2_defvalue = wxPyEmptyString ;
6539 wxString *arg2 = (wxString *) &arg2_defvalue ;
6540 int arg3 = (int) wxOK|wxCENTRE ;
6541 wxWindow *arg4 = (wxWindow *) NULL ;
6542 int arg5 = (int) -1 ;
6543 int arg6 = (int) -1 ;
6544 int result;
6545 bool temp1 = false ;
6546 bool temp2 = false ;
6547 int val3 ;
6548 int ecode3 = 0 ;
6549 void *argp4 = 0 ;
6550 int res4 = 0 ;
6551 int val5 ;
6552 int ecode5 = 0 ;
6553 int val6 ;
6554 int ecode6 = 0 ;
6555 PyObject * obj0 = 0 ;
6556 PyObject * obj1 = 0 ;
6557 PyObject * obj2 = 0 ;
6558 PyObject * obj3 = 0 ;
6559 PyObject * obj4 = 0 ;
6560 PyObject * obj5 = 0 ;
6561 char * kwnames[] = {
6562 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6563 };
6564
6565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6566 {
6567 arg1 = wxString_in_helper(obj0);
6568 if (arg1 == NULL) SWIG_fail;
6569 temp1 = true;
6570 }
6571 if (obj1) {
6572 {
6573 arg2 = wxString_in_helper(obj1);
6574 if (arg2 == NULL) SWIG_fail;
6575 temp2 = true;
6576 }
6577 }
6578 if (obj2) {
6579 ecode3 = SWIG_AsVal_int(obj2, &val3);
6580 if (!SWIG_IsOK(ecode3)) {
6581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6582 }
6583 arg3 = static_cast< int >(val3);
6584 }
6585 if (obj3) {
6586 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6587 if (!SWIG_IsOK(res4)) {
6588 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6589 }
6590 arg4 = reinterpret_cast< wxWindow * >(argp4);
6591 }
6592 if (obj4) {
6593 ecode5 = SWIG_AsVal_int(obj4, &val5);
6594 if (!SWIG_IsOK(ecode5)) {
6595 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6596 }
6597 arg5 = static_cast< int >(val5);
6598 }
6599 if (obj5) {
6600 ecode6 = SWIG_AsVal_int(obj5, &val6);
6601 if (!SWIG_IsOK(ecode6)) {
6602 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6603 }
6604 arg6 = static_cast< int >(val6);
6605 }
6606 {
6607 if (!wxPyCheckForApp()) SWIG_fail;
6608 PyThreadState* __tstate = wxPyBeginAllowThreads();
6609 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6610 wxPyEndAllowThreads(__tstate);
6611 if (PyErr_Occurred()) SWIG_fail;
6612 }
6613 resultobj = SWIG_From_int(static_cast< int >(result));
6614 {
6615 if (temp1)
6616 delete arg1;
6617 }
6618 {
6619 if (temp2)
6620 delete arg2;
6621 }
6622 return resultobj;
6623 fail:
6624 {
6625 if (temp1)
6626 delete arg1;
6627 }
6628 {
6629 if (temp2)
6630 delete arg2;
6631 }
6632 return NULL;
6633 }
6634
6635
6636 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6637 PyObject *resultobj = 0;
6638 wxString *arg1 = 0 ;
6639 wxString *arg2 = 0 ;
6640 wxString *arg3 = 0 ;
6641 long arg4 ;
6642 long arg5 = (long) 0 ;
6643 long arg6 = (long) 100 ;
6644 wxWindow *arg7 = (wxWindow *) NULL ;
6645 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6646 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6647 long result;
6648 bool temp1 = false ;
6649 bool temp2 = false ;
6650 bool temp3 = false ;
6651 long val4 ;
6652 int ecode4 = 0 ;
6653 long val5 ;
6654 int ecode5 = 0 ;
6655 long val6 ;
6656 int ecode6 = 0 ;
6657 void *argp7 = 0 ;
6658 int res7 = 0 ;
6659 wxPoint temp8 ;
6660 PyObject * obj0 = 0 ;
6661 PyObject * obj1 = 0 ;
6662 PyObject * obj2 = 0 ;
6663 PyObject * obj3 = 0 ;
6664 PyObject * obj4 = 0 ;
6665 PyObject * obj5 = 0 ;
6666 PyObject * obj6 = 0 ;
6667 PyObject * obj7 = 0 ;
6668 char * kwnames[] = {
6669 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6670 };
6671
6672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6673 {
6674 arg1 = wxString_in_helper(obj0);
6675 if (arg1 == NULL) SWIG_fail;
6676 temp1 = true;
6677 }
6678 {
6679 arg2 = wxString_in_helper(obj1);
6680 if (arg2 == NULL) SWIG_fail;
6681 temp2 = true;
6682 }
6683 {
6684 arg3 = wxString_in_helper(obj2);
6685 if (arg3 == NULL) SWIG_fail;
6686 temp3 = true;
6687 }
6688 ecode4 = SWIG_AsVal_long(obj3, &val4);
6689 if (!SWIG_IsOK(ecode4)) {
6690 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6691 }
6692 arg4 = static_cast< long >(val4);
6693 if (obj4) {
6694 ecode5 = SWIG_AsVal_long(obj4, &val5);
6695 if (!SWIG_IsOK(ecode5)) {
6696 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6697 }
6698 arg5 = static_cast< long >(val5);
6699 }
6700 if (obj5) {
6701 ecode6 = SWIG_AsVal_long(obj5, &val6);
6702 if (!SWIG_IsOK(ecode6)) {
6703 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6704 }
6705 arg6 = static_cast< long >(val6);
6706 }
6707 if (obj6) {
6708 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6709 if (!SWIG_IsOK(res7)) {
6710 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6711 }
6712 arg7 = reinterpret_cast< wxWindow * >(argp7);
6713 }
6714 if (obj7) {
6715 {
6716 arg8 = &temp8;
6717 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6718 }
6719 }
6720 {
6721 if (!wxPyCheckForApp()) SWIG_fail;
6722 PyThreadState* __tstate = wxPyBeginAllowThreads();
6723 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6724 wxPyEndAllowThreads(__tstate);
6725 if (PyErr_Occurred()) SWIG_fail;
6726 }
6727 resultobj = SWIG_From_long(static_cast< long >(result));
6728 {
6729 if (temp1)
6730 delete arg1;
6731 }
6732 {
6733 if (temp2)
6734 delete arg2;
6735 }
6736 {
6737 if (temp3)
6738 delete arg3;
6739 }
6740 return resultobj;
6741 fail:
6742 {
6743 if (temp1)
6744 delete arg1;
6745 }
6746 {
6747 if (temp2)
6748 delete arg2;
6749 }
6750 {
6751 if (temp3)
6752 delete arg3;
6753 }
6754 return NULL;
6755 }
6756
6757
6758 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6759 PyObject *resultobj = 0;
6760 bool result;
6761
6762 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6763 {
6764 if (!wxPyCheckForApp()) SWIG_fail;
6765 PyThreadState* __tstate = wxPyBeginAllowThreads();
6766 result = (bool)wxColourDisplay();
6767 wxPyEndAllowThreads(__tstate);
6768 if (PyErr_Occurred()) SWIG_fail;
6769 }
6770 {
6771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6772 }
6773 return resultobj;
6774 fail:
6775 return NULL;
6776 }
6777
6778
6779 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6780 PyObject *resultobj = 0;
6781 int result;
6782
6783 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6784 {
6785 if (!wxPyCheckForApp()) SWIG_fail;
6786 PyThreadState* __tstate = wxPyBeginAllowThreads();
6787 result = (int)wxDisplayDepth();
6788 wxPyEndAllowThreads(__tstate);
6789 if (PyErr_Occurred()) SWIG_fail;
6790 }
6791 resultobj = SWIG_From_int(static_cast< int >(result));
6792 return resultobj;
6793 fail:
6794 return NULL;
6795 }
6796
6797
6798 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6799 PyObject *resultobj = 0;
6800 int result;
6801
6802 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6803 {
6804 if (!wxPyCheckForApp()) SWIG_fail;
6805 PyThreadState* __tstate = wxPyBeginAllowThreads();
6806 result = (int)wxGetDisplayDepth();
6807 wxPyEndAllowThreads(__tstate);
6808 if (PyErr_Occurred()) SWIG_fail;
6809 }
6810 resultobj = SWIG_From_int(static_cast< int >(result));
6811 return resultobj;
6812 fail:
6813 return NULL;
6814 }
6815
6816
6817 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6818 PyObject *resultobj = 0;
6819 int *arg1 = (int *) 0 ;
6820 int *arg2 = (int *) 0 ;
6821 int temp1 ;
6822 int res1 = SWIG_TMPOBJ ;
6823 int temp2 ;
6824 int res2 = SWIG_TMPOBJ ;
6825
6826 arg1 = &temp1;
6827 arg2 = &temp2;
6828 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6829 {
6830 if (!wxPyCheckForApp()) SWIG_fail;
6831 PyThreadState* __tstate = wxPyBeginAllowThreads();
6832 wxDisplaySize(arg1,arg2);
6833 wxPyEndAllowThreads(__tstate);
6834 if (PyErr_Occurred()) SWIG_fail;
6835 }
6836 resultobj = SWIG_Py_Void();
6837 if (SWIG_IsTmpObj(res1)) {
6838 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6839 } else {
6840 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6841 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6842 }
6843 if (SWIG_IsTmpObj(res2)) {
6844 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6845 } else {
6846 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6847 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6848 }
6849 return resultobj;
6850 fail:
6851 return NULL;
6852 }
6853
6854
6855 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6856 PyObject *resultobj = 0;
6857 wxSize result;
6858
6859 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6860 {
6861 if (!wxPyCheckForApp()) SWIG_fail;
6862 PyThreadState* __tstate = wxPyBeginAllowThreads();
6863 result = wxGetDisplaySize();
6864 wxPyEndAllowThreads(__tstate);
6865 if (PyErr_Occurred()) SWIG_fail;
6866 }
6867 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6868 return resultobj;
6869 fail:
6870 return NULL;
6871 }
6872
6873
6874 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6875 PyObject *resultobj = 0;
6876 int *arg1 = (int *) 0 ;
6877 int *arg2 = (int *) 0 ;
6878 int temp1 ;
6879 int res1 = SWIG_TMPOBJ ;
6880 int temp2 ;
6881 int res2 = SWIG_TMPOBJ ;
6882
6883 arg1 = &temp1;
6884 arg2 = &temp2;
6885 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6886 {
6887 if (!wxPyCheckForApp()) SWIG_fail;
6888 PyThreadState* __tstate = wxPyBeginAllowThreads();
6889 wxDisplaySizeMM(arg1,arg2);
6890 wxPyEndAllowThreads(__tstate);
6891 if (PyErr_Occurred()) SWIG_fail;
6892 }
6893 resultobj = SWIG_Py_Void();
6894 if (SWIG_IsTmpObj(res1)) {
6895 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6896 } else {
6897 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6898 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6899 }
6900 if (SWIG_IsTmpObj(res2)) {
6901 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6902 } else {
6903 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6904 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6905 }
6906 return resultobj;
6907 fail:
6908 return NULL;
6909 }
6910
6911
6912 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6913 PyObject *resultobj = 0;
6914 wxSize result;
6915
6916 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6917 {
6918 if (!wxPyCheckForApp()) SWIG_fail;
6919 PyThreadState* __tstate = wxPyBeginAllowThreads();
6920 result = wxGetDisplaySizeMM();
6921 wxPyEndAllowThreads(__tstate);
6922 if (PyErr_Occurred()) SWIG_fail;
6923 }
6924 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6925 return resultobj;
6926 fail:
6927 return NULL;
6928 }
6929
6930
6931 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6932 PyObject *resultobj = 0;
6933 int *arg1 = (int *) 0 ;
6934 int *arg2 = (int *) 0 ;
6935 int *arg3 = (int *) 0 ;
6936 int *arg4 = (int *) 0 ;
6937 int temp1 ;
6938 int res1 = SWIG_TMPOBJ ;
6939 int temp2 ;
6940 int res2 = SWIG_TMPOBJ ;
6941 int temp3 ;
6942 int res3 = SWIG_TMPOBJ ;
6943 int temp4 ;
6944 int res4 = SWIG_TMPOBJ ;
6945
6946 arg1 = &temp1;
6947 arg2 = &temp2;
6948 arg3 = &temp3;
6949 arg4 = &temp4;
6950 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6951 {
6952 if (!wxPyCheckForApp()) SWIG_fail;
6953 PyThreadState* __tstate = wxPyBeginAllowThreads();
6954 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6955 wxPyEndAllowThreads(__tstate);
6956 if (PyErr_Occurred()) SWIG_fail;
6957 }
6958 resultobj = SWIG_Py_Void();
6959 if (SWIG_IsTmpObj(res1)) {
6960 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6961 } else {
6962 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6963 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6964 }
6965 if (SWIG_IsTmpObj(res2)) {
6966 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6967 } else {
6968 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6969 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6970 }
6971 if (SWIG_IsTmpObj(res3)) {
6972 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6973 } else {
6974 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6975 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6976 }
6977 if (SWIG_IsTmpObj(res4)) {
6978 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6979 } else {
6980 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6981 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6982 }
6983 return resultobj;
6984 fail:
6985 return NULL;
6986 }
6987
6988
6989 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6990 PyObject *resultobj = 0;
6991 wxRect result;
6992
6993 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6994 {
6995 if (!wxPyCheckForApp()) SWIG_fail;
6996 PyThreadState* __tstate = wxPyBeginAllowThreads();
6997 result = wxGetClientDisplayRect();
6998 wxPyEndAllowThreads(__tstate);
6999 if (PyErr_Occurred()) SWIG_fail;
7000 }
7001 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7002 return resultobj;
7003 fail:
7004 return NULL;
7005 }
7006
7007
7008 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7009 PyObject *resultobj = 0;
7010 wxCursor *arg1 = 0 ;
7011 void *argp1 = 0 ;
7012 int res1 = 0 ;
7013 PyObject * obj0 = 0 ;
7014 char * kwnames[] = {
7015 (char *) "cursor", NULL
7016 };
7017
7018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7019 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7020 if (!SWIG_IsOK(res1)) {
7021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7022 }
7023 if (!argp1) {
7024 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7025 }
7026 arg1 = reinterpret_cast< wxCursor * >(argp1);
7027 {
7028 if (!wxPyCheckForApp()) SWIG_fail;
7029 PyThreadState* __tstate = wxPyBeginAllowThreads();
7030 wxSetCursor(*arg1);
7031 wxPyEndAllowThreads(__tstate);
7032 if (PyErr_Occurred()) SWIG_fail;
7033 }
7034 resultobj = SWIG_Py_Void();
7035 return resultobj;
7036 fail:
7037 return NULL;
7038 }
7039
7040
7041 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7042 PyObject *resultobj = 0;
7043 void *result = 0 ;
7044
7045 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7046 {
7047 if (!wxPyCheckForApp()) SWIG_fail;
7048 PyThreadState* __tstate = wxPyBeginAllowThreads();
7049 result = (void *)wxGetXDisplay();
7050 wxPyEndAllowThreads(__tstate);
7051 if (PyErr_Occurred()) SWIG_fail;
7052 }
7053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7054 return resultobj;
7055 fail:
7056 return NULL;
7057 }
7058
7059
7060 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7061 PyObject *resultobj = 0;
7062 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7063 void *argp1 = 0 ;
7064 int res1 = 0 ;
7065 PyObject * obj0 = 0 ;
7066 char * kwnames[] = {
7067 (char *) "cursor", NULL
7068 };
7069
7070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7071 if (obj0) {
7072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7073 if (!SWIG_IsOK(res1)) {
7074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7075 }
7076 arg1 = reinterpret_cast< wxCursor * >(argp1);
7077 }
7078 {
7079 if (!wxPyCheckForApp()) SWIG_fail;
7080 PyThreadState* __tstate = wxPyBeginAllowThreads();
7081 wxBeginBusyCursor(arg1);
7082 wxPyEndAllowThreads(__tstate);
7083 if (PyErr_Occurred()) SWIG_fail;
7084 }
7085 resultobj = SWIG_Py_Void();
7086 return resultobj;
7087 fail:
7088 return NULL;
7089 }
7090
7091
7092 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7093 PyObject *resultobj = 0;
7094 wxPoint result;
7095
7096 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7097 {
7098 if (!wxPyCheckForApp()) SWIG_fail;
7099 PyThreadState* __tstate = wxPyBeginAllowThreads();
7100 result = wxGetMousePosition();
7101 wxPyEndAllowThreads(__tstate);
7102 if (PyErr_Occurred()) SWIG_fail;
7103 }
7104 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7105 return resultobj;
7106 fail:
7107 return NULL;
7108 }
7109
7110
7111 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7112 PyObject *resultobj = 0;
7113 wxWindow *result = 0 ;
7114
7115 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7116 {
7117 if (!wxPyCheckForApp()) SWIG_fail;
7118 PyThreadState* __tstate = wxPyBeginAllowThreads();
7119 result = (wxWindow *)FindWindowAtPointer();
7120 wxPyEndAllowThreads(__tstate);
7121 if (PyErr_Occurred()) SWIG_fail;
7122 }
7123 {
7124 resultobj = wxPyMake_wxObject(result, 0);
7125 }
7126 return resultobj;
7127 fail:
7128 return NULL;
7129 }
7130
7131
7132 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7133 PyObject *resultobj = 0;
7134 wxWindow *result = 0 ;
7135
7136 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7137 {
7138 if (!wxPyCheckForApp()) SWIG_fail;
7139 PyThreadState* __tstate = wxPyBeginAllowThreads();
7140 result = (wxWindow *)wxGetActiveWindow();
7141 wxPyEndAllowThreads(__tstate);
7142 if (PyErr_Occurred()) SWIG_fail;
7143 }
7144 {
7145 resultobj = wxPyMake_wxObject(result, 0);
7146 }
7147 return resultobj;
7148 fail:
7149 return NULL;
7150 }
7151
7152
7153 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7154 PyObject *resultobj = 0;
7155 wxPoint *arg1 = 0 ;
7156 wxWindow *result = 0 ;
7157 wxPoint temp1 ;
7158 PyObject * obj0 = 0 ;
7159 char * kwnames[] = {
7160 (char *) "pt", NULL
7161 };
7162
7163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7164 {
7165 arg1 = &temp1;
7166 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7167 }
7168 {
7169 if (!wxPyCheckForApp()) SWIG_fail;
7170 PyThreadState* __tstate = wxPyBeginAllowThreads();
7171 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7172 wxPyEndAllowThreads(__tstate);
7173 if (PyErr_Occurred()) SWIG_fail;
7174 }
7175 {
7176 resultobj = wxPyMake_wxObject(result, 0);
7177 }
7178 return resultobj;
7179 fail:
7180 return NULL;
7181 }
7182
7183
7184 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7185 PyObject *resultobj = 0;
7186 wxPoint *arg1 = 0 ;
7187 wxWindow *result = 0 ;
7188 wxPoint temp1 ;
7189 PyObject * obj0 = 0 ;
7190 char * kwnames[] = {
7191 (char *) "pt", NULL
7192 };
7193
7194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7195 {
7196 arg1 = &temp1;
7197 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7198 }
7199 {
7200 if (!wxPyCheckForApp()) SWIG_fail;
7201 PyThreadState* __tstate = wxPyBeginAllowThreads();
7202 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7203 wxPyEndAllowThreads(__tstate);
7204 if (PyErr_Occurred()) SWIG_fail;
7205 }
7206 {
7207 resultobj = wxPyMake_wxObject(result, 0);
7208 }
7209 return resultobj;
7210 fail:
7211 return NULL;
7212 }
7213
7214
7215 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7216 PyObject *resultobj = 0;
7217 wxWindow *arg1 = (wxWindow *) 0 ;
7218 wxWindow *result = 0 ;
7219 void *argp1 = 0 ;
7220 int res1 = 0 ;
7221 PyObject * obj0 = 0 ;
7222 char * kwnames[] = {
7223 (char *) "win", NULL
7224 };
7225
7226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7228 if (!SWIG_IsOK(res1)) {
7229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7230 }
7231 arg1 = reinterpret_cast< wxWindow * >(argp1);
7232 {
7233 if (!wxPyCheckForApp()) SWIG_fail;
7234 PyThreadState* __tstate = wxPyBeginAllowThreads();
7235 result = (wxWindow *)wxGetTopLevelParent(arg1);
7236 wxPyEndAllowThreads(__tstate);
7237 if (PyErr_Occurred()) SWIG_fail;
7238 }
7239 {
7240 resultobj = wxPyMake_wxObject(result, 0);
7241 }
7242 return resultobj;
7243 fail:
7244 return NULL;
7245 }
7246
7247
7248 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7249 PyObject *resultobj = 0;
7250 wxString *arg1 = 0 ;
7251 bool result;
7252 bool temp1 = false ;
7253 PyObject * obj0 = 0 ;
7254 char * kwnames[] = {
7255 (char *) "url", NULL
7256 };
7257
7258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7259 {
7260 arg1 = wxString_in_helper(obj0);
7261 if (arg1 == NULL) SWIG_fail;
7262 temp1 = true;
7263 }
7264 {
7265 PyThreadState* __tstate = wxPyBeginAllowThreads();
7266 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7267 wxPyEndAllowThreads(__tstate);
7268 if (PyErr_Occurred()) SWIG_fail;
7269 }
7270 {
7271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7272 }
7273 {
7274 if (temp1)
7275 delete arg1;
7276 }
7277 return resultobj;
7278 fail:
7279 {
7280 if (temp1)
7281 delete arg1;
7282 }
7283 return NULL;
7284 }
7285
7286
7287 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7288 PyObject *resultobj = 0;
7289 wxKeyCode arg1 ;
7290 bool result;
7291 int val1 ;
7292 int ecode1 = 0 ;
7293 PyObject * obj0 = 0 ;
7294 char * kwnames[] = {
7295 (char *) "key", NULL
7296 };
7297
7298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7299 ecode1 = SWIG_AsVal_int(obj0, &val1);
7300 if (!SWIG_IsOK(ecode1)) {
7301 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7302 }
7303 arg1 = static_cast< wxKeyCode >(val1);
7304 {
7305 if (!wxPyCheckForApp()) SWIG_fail;
7306 PyThreadState* __tstate = wxPyBeginAllowThreads();
7307 result = (bool)wxGetKeyState(arg1);
7308 wxPyEndAllowThreads(__tstate);
7309 if (PyErr_Occurred()) SWIG_fail;
7310 }
7311 {
7312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7313 }
7314 return resultobj;
7315 fail:
7316 return NULL;
7317 }
7318
7319
7320 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7321 PyObject *resultobj = 0;
7322 wxMouseState *result = 0 ;
7323
7324 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7325 {
7326 PyThreadState* __tstate = wxPyBeginAllowThreads();
7327 result = (wxMouseState *)new wxMouseState();
7328 wxPyEndAllowThreads(__tstate);
7329 if (PyErr_Occurred()) SWIG_fail;
7330 }
7331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7332 return resultobj;
7333 fail:
7334 return NULL;
7335 }
7336
7337
7338 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7339 PyObject *resultobj = 0;
7340 wxMouseState *arg1 = (wxMouseState *) 0 ;
7341 void *argp1 = 0 ;
7342 int res1 = 0 ;
7343 PyObject *swig_obj[1] ;
7344
7345 if (!args) SWIG_fail;
7346 swig_obj[0] = args;
7347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7348 if (!SWIG_IsOK(res1)) {
7349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7350 }
7351 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7352 {
7353 PyThreadState* __tstate = wxPyBeginAllowThreads();
7354 delete arg1;
7355
7356 wxPyEndAllowThreads(__tstate);
7357 if (PyErr_Occurred()) SWIG_fail;
7358 }
7359 resultobj = SWIG_Py_Void();
7360 return resultobj;
7361 fail:
7362 return NULL;
7363 }
7364
7365
7366 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7367 PyObject *resultobj = 0;
7368 wxMouseState *arg1 = (wxMouseState *) 0 ;
7369 int result;
7370 void *argp1 = 0 ;
7371 int res1 = 0 ;
7372 PyObject *swig_obj[1] ;
7373
7374 if (!args) SWIG_fail;
7375 swig_obj[0] = args;
7376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7377 if (!SWIG_IsOK(res1)) {
7378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7379 }
7380 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7381 {
7382 PyThreadState* __tstate = wxPyBeginAllowThreads();
7383 result = (int)(arg1)->GetX();
7384 wxPyEndAllowThreads(__tstate);
7385 if (PyErr_Occurred()) SWIG_fail;
7386 }
7387 resultobj = SWIG_From_int(static_cast< int >(result));
7388 return resultobj;
7389 fail:
7390 return NULL;
7391 }
7392
7393
7394 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7395 PyObject *resultobj = 0;
7396 wxMouseState *arg1 = (wxMouseState *) 0 ;
7397 int result;
7398 void *argp1 = 0 ;
7399 int res1 = 0 ;
7400 PyObject *swig_obj[1] ;
7401
7402 if (!args) SWIG_fail;
7403 swig_obj[0] = args;
7404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7405 if (!SWIG_IsOK(res1)) {
7406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7407 }
7408 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7409 {
7410 PyThreadState* __tstate = wxPyBeginAllowThreads();
7411 result = (int)(arg1)->GetY();
7412 wxPyEndAllowThreads(__tstate);
7413 if (PyErr_Occurred()) SWIG_fail;
7414 }
7415 resultobj = SWIG_From_int(static_cast< int >(result));
7416 return resultobj;
7417 fail:
7418 return NULL;
7419 }
7420
7421
7422 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7423 PyObject *resultobj = 0;
7424 wxMouseState *arg1 = (wxMouseState *) 0 ;
7425 bool result;
7426 void *argp1 = 0 ;
7427 int res1 = 0 ;
7428 PyObject *swig_obj[1] ;
7429
7430 if (!args) SWIG_fail;
7431 swig_obj[0] = args;
7432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7433 if (!SWIG_IsOK(res1)) {
7434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7435 }
7436 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7437 {
7438 PyThreadState* __tstate = wxPyBeginAllowThreads();
7439 result = (bool)(arg1)->LeftDown();
7440 wxPyEndAllowThreads(__tstate);
7441 if (PyErr_Occurred()) SWIG_fail;
7442 }
7443 {
7444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7445 }
7446 return resultobj;
7447 fail:
7448 return NULL;
7449 }
7450
7451
7452 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7453 PyObject *resultobj = 0;
7454 wxMouseState *arg1 = (wxMouseState *) 0 ;
7455 bool result;
7456 void *argp1 = 0 ;
7457 int res1 = 0 ;
7458 PyObject *swig_obj[1] ;
7459
7460 if (!args) SWIG_fail;
7461 swig_obj[0] = args;
7462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7463 if (!SWIG_IsOK(res1)) {
7464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7465 }
7466 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7467 {
7468 PyThreadState* __tstate = wxPyBeginAllowThreads();
7469 result = (bool)(arg1)->MiddleDown();
7470 wxPyEndAllowThreads(__tstate);
7471 if (PyErr_Occurred()) SWIG_fail;
7472 }
7473 {
7474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7475 }
7476 return resultobj;
7477 fail:
7478 return NULL;
7479 }
7480
7481
7482 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7483 PyObject *resultobj = 0;
7484 wxMouseState *arg1 = (wxMouseState *) 0 ;
7485 bool result;
7486 void *argp1 = 0 ;
7487 int res1 = 0 ;
7488 PyObject *swig_obj[1] ;
7489
7490 if (!args) SWIG_fail;
7491 swig_obj[0] = args;
7492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7493 if (!SWIG_IsOK(res1)) {
7494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7495 }
7496 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7497 {
7498 PyThreadState* __tstate = wxPyBeginAllowThreads();
7499 result = (bool)(arg1)->RightDown();
7500 wxPyEndAllowThreads(__tstate);
7501 if (PyErr_Occurred()) SWIG_fail;
7502 }
7503 {
7504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7505 }
7506 return resultobj;
7507 fail:
7508 return NULL;
7509 }
7510
7511
7512 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7513 PyObject *resultobj = 0;
7514 wxMouseState *arg1 = (wxMouseState *) 0 ;
7515 bool result;
7516 void *argp1 = 0 ;
7517 int res1 = 0 ;
7518 PyObject *swig_obj[1] ;
7519
7520 if (!args) SWIG_fail;
7521 swig_obj[0] = args;
7522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7523 if (!SWIG_IsOK(res1)) {
7524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7525 }
7526 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7527 {
7528 PyThreadState* __tstate = wxPyBeginAllowThreads();
7529 result = (bool)(arg1)->ControlDown();
7530 wxPyEndAllowThreads(__tstate);
7531 if (PyErr_Occurred()) SWIG_fail;
7532 }
7533 {
7534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7535 }
7536 return resultobj;
7537 fail:
7538 return NULL;
7539 }
7540
7541
7542 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7543 PyObject *resultobj = 0;
7544 wxMouseState *arg1 = (wxMouseState *) 0 ;
7545 bool result;
7546 void *argp1 = 0 ;
7547 int res1 = 0 ;
7548 PyObject *swig_obj[1] ;
7549
7550 if (!args) SWIG_fail;
7551 swig_obj[0] = args;
7552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7553 if (!SWIG_IsOK(res1)) {
7554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7555 }
7556 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7557 {
7558 PyThreadState* __tstate = wxPyBeginAllowThreads();
7559 result = (bool)(arg1)->ShiftDown();
7560 wxPyEndAllowThreads(__tstate);
7561 if (PyErr_Occurred()) SWIG_fail;
7562 }
7563 {
7564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7565 }
7566 return resultobj;
7567 fail:
7568 return NULL;
7569 }
7570
7571
7572 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7573 PyObject *resultobj = 0;
7574 wxMouseState *arg1 = (wxMouseState *) 0 ;
7575 bool result;
7576 void *argp1 = 0 ;
7577 int res1 = 0 ;
7578 PyObject *swig_obj[1] ;
7579
7580 if (!args) SWIG_fail;
7581 swig_obj[0] = args;
7582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7583 if (!SWIG_IsOK(res1)) {
7584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7585 }
7586 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7587 {
7588 PyThreadState* __tstate = wxPyBeginAllowThreads();
7589 result = (bool)(arg1)->AltDown();
7590 wxPyEndAllowThreads(__tstate);
7591 if (PyErr_Occurred()) SWIG_fail;
7592 }
7593 {
7594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7595 }
7596 return resultobj;
7597 fail:
7598 return NULL;
7599 }
7600
7601
7602 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7603 PyObject *resultobj = 0;
7604 wxMouseState *arg1 = (wxMouseState *) 0 ;
7605 bool result;
7606 void *argp1 = 0 ;
7607 int res1 = 0 ;
7608 PyObject *swig_obj[1] ;
7609
7610 if (!args) SWIG_fail;
7611 swig_obj[0] = args;
7612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7613 if (!SWIG_IsOK(res1)) {
7614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7615 }
7616 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7617 {
7618 PyThreadState* __tstate = wxPyBeginAllowThreads();
7619 result = (bool)(arg1)->MetaDown();
7620 wxPyEndAllowThreads(__tstate);
7621 if (PyErr_Occurred()) SWIG_fail;
7622 }
7623 {
7624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7625 }
7626 return resultobj;
7627 fail:
7628 return NULL;
7629 }
7630
7631
7632 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7633 PyObject *resultobj = 0;
7634 wxMouseState *arg1 = (wxMouseState *) 0 ;
7635 bool result;
7636 void *argp1 = 0 ;
7637 int res1 = 0 ;
7638 PyObject *swig_obj[1] ;
7639
7640 if (!args) SWIG_fail;
7641 swig_obj[0] = args;
7642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7643 if (!SWIG_IsOK(res1)) {
7644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7645 }
7646 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7647 {
7648 PyThreadState* __tstate = wxPyBeginAllowThreads();
7649 result = (bool)(arg1)->CmdDown();
7650 wxPyEndAllowThreads(__tstate);
7651 if (PyErr_Occurred()) SWIG_fail;
7652 }
7653 {
7654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7655 }
7656 return resultobj;
7657 fail:
7658 return NULL;
7659 }
7660
7661
7662 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7663 PyObject *resultobj = 0;
7664 wxMouseState *arg1 = (wxMouseState *) 0 ;
7665 int arg2 ;
7666 void *argp1 = 0 ;
7667 int res1 = 0 ;
7668 int val2 ;
7669 int ecode2 = 0 ;
7670 PyObject * obj0 = 0 ;
7671 PyObject * obj1 = 0 ;
7672 char * kwnames[] = {
7673 (char *) "self",(char *) "x", NULL
7674 };
7675
7676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7678 if (!SWIG_IsOK(res1)) {
7679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7680 }
7681 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7682 ecode2 = SWIG_AsVal_int(obj1, &val2);
7683 if (!SWIG_IsOK(ecode2)) {
7684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7685 }
7686 arg2 = static_cast< int >(val2);
7687 {
7688 PyThreadState* __tstate = wxPyBeginAllowThreads();
7689 (arg1)->SetX(arg2);
7690 wxPyEndAllowThreads(__tstate);
7691 if (PyErr_Occurred()) SWIG_fail;
7692 }
7693 resultobj = SWIG_Py_Void();
7694 return resultobj;
7695 fail:
7696 return NULL;
7697 }
7698
7699
7700 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7701 PyObject *resultobj = 0;
7702 wxMouseState *arg1 = (wxMouseState *) 0 ;
7703 int arg2 ;
7704 void *argp1 = 0 ;
7705 int res1 = 0 ;
7706 int val2 ;
7707 int ecode2 = 0 ;
7708 PyObject * obj0 = 0 ;
7709 PyObject * obj1 = 0 ;
7710 char * kwnames[] = {
7711 (char *) "self",(char *) "y", NULL
7712 };
7713
7714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7716 if (!SWIG_IsOK(res1)) {
7717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7718 }
7719 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7720 ecode2 = SWIG_AsVal_int(obj1, &val2);
7721 if (!SWIG_IsOK(ecode2)) {
7722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7723 }
7724 arg2 = static_cast< int >(val2);
7725 {
7726 PyThreadState* __tstate = wxPyBeginAllowThreads();
7727 (arg1)->SetY(arg2);
7728 wxPyEndAllowThreads(__tstate);
7729 if (PyErr_Occurred()) SWIG_fail;
7730 }
7731 resultobj = SWIG_Py_Void();
7732 return resultobj;
7733 fail:
7734 return NULL;
7735 }
7736
7737
7738 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7739 PyObject *resultobj = 0;
7740 wxMouseState *arg1 = (wxMouseState *) 0 ;
7741 bool arg2 ;
7742 void *argp1 = 0 ;
7743 int res1 = 0 ;
7744 bool val2 ;
7745 int ecode2 = 0 ;
7746 PyObject * obj0 = 0 ;
7747 PyObject * obj1 = 0 ;
7748 char * kwnames[] = {
7749 (char *) "self",(char *) "down", NULL
7750 };
7751
7752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7754 if (!SWIG_IsOK(res1)) {
7755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7756 }
7757 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7758 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7759 if (!SWIG_IsOK(ecode2)) {
7760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7761 }
7762 arg2 = static_cast< bool >(val2);
7763 {
7764 PyThreadState* __tstate = wxPyBeginAllowThreads();
7765 (arg1)->SetLeftDown(arg2);
7766 wxPyEndAllowThreads(__tstate);
7767 if (PyErr_Occurred()) SWIG_fail;
7768 }
7769 resultobj = SWIG_Py_Void();
7770 return resultobj;
7771 fail:
7772 return NULL;
7773 }
7774
7775
7776 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7777 PyObject *resultobj = 0;
7778 wxMouseState *arg1 = (wxMouseState *) 0 ;
7779 bool arg2 ;
7780 void *argp1 = 0 ;
7781 int res1 = 0 ;
7782 bool val2 ;
7783 int ecode2 = 0 ;
7784 PyObject * obj0 = 0 ;
7785 PyObject * obj1 = 0 ;
7786 char * kwnames[] = {
7787 (char *) "self",(char *) "down", NULL
7788 };
7789
7790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7792 if (!SWIG_IsOK(res1)) {
7793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7794 }
7795 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7796 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7797 if (!SWIG_IsOK(ecode2)) {
7798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7799 }
7800 arg2 = static_cast< bool >(val2);
7801 {
7802 PyThreadState* __tstate = wxPyBeginAllowThreads();
7803 (arg1)->SetMiddleDown(arg2);
7804 wxPyEndAllowThreads(__tstate);
7805 if (PyErr_Occurred()) SWIG_fail;
7806 }
7807 resultobj = SWIG_Py_Void();
7808 return resultobj;
7809 fail:
7810 return NULL;
7811 }
7812
7813
7814 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7815 PyObject *resultobj = 0;
7816 wxMouseState *arg1 = (wxMouseState *) 0 ;
7817 bool arg2 ;
7818 void *argp1 = 0 ;
7819 int res1 = 0 ;
7820 bool val2 ;
7821 int ecode2 = 0 ;
7822 PyObject * obj0 = 0 ;
7823 PyObject * obj1 = 0 ;
7824 char * kwnames[] = {
7825 (char *) "self",(char *) "down", NULL
7826 };
7827
7828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7830 if (!SWIG_IsOK(res1)) {
7831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7832 }
7833 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7834 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7835 if (!SWIG_IsOK(ecode2)) {
7836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7837 }
7838 arg2 = static_cast< bool >(val2);
7839 {
7840 PyThreadState* __tstate = wxPyBeginAllowThreads();
7841 (arg1)->SetRightDown(arg2);
7842 wxPyEndAllowThreads(__tstate);
7843 if (PyErr_Occurred()) SWIG_fail;
7844 }
7845 resultobj = SWIG_Py_Void();
7846 return resultobj;
7847 fail:
7848 return NULL;
7849 }
7850
7851
7852 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7853 PyObject *resultobj = 0;
7854 wxMouseState *arg1 = (wxMouseState *) 0 ;
7855 bool arg2 ;
7856 void *argp1 = 0 ;
7857 int res1 = 0 ;
7858 bool val2 ;
7859 int ecode2 = 0 ;
7860 PyObject * obj0 = 0 ;
7861 PyObject * obj1 = 0 ;
7862 char * kwnames[] = {
7863 (char *) "self",(char *) "down", NULL
7864 };
7865
7866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7868 if (!SWIG_IsOK(res1)) {
7869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7870 }
7871 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7872 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7873 if (!SWIG_IsOK(ecode2)) {
7874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7875 }
7876 arg2 = static_cast< bool >(val2);
7877 {
7878 PyThreadState* __tstate = wxPyBeginAllowThreads();
7879 (arg1)->SetControlDown(arg2);
7880 wxPyEndAllowThreads(__tstate);
7881 if (PyErr_Occurred()) SWIG_fail;
7882 }
7883 resultobj = SWIG_Py_Void();
7884 return resultobj;
7885 fail:
7886 return NULL;
7887 }
7888
7889
7890 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7891 PyObject *resultobj = 0;
7892 wxMouseState *arg1 = (wxMouseState *) 0 ;
7893 bool arg2 ;
7894 void *argp1 = 0 ;
7895 int res1 = 0 ;
7896 bool val2 ;
7897 int ecode2 = 0 ;
7898 PyObject * obj0 = 0 ;
7899 PyObject * obj1 = 0 ;
7900 char * kwnames[] = {
7901 (char *) "self",(char *) "down", NULL
7902 };
7903
7904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7906 if (!SWIG_IsOK(res1)) {
7907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7908 }
7909 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7910 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7911 if (!SWIG_IsOK(ecode2)) {
7912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7913 }
7914 arg2 = static_cast< bool >(val2);
7915 {
7916 PyThreadState* __tstate = wxPyBeginAllowThreads();
7917 (arg1)->SetShiftDown(arg2);
7918 wxPyEndAllowThreads(__tstate);
7919 if (PyErr_Occurred()) SWIG_fail;
7920 }
7921 resultobj = SWIG_Py_Void();
7922 return resultobj;
7923 fail:
7924 return NULL;
7925 }
7926
7927
7928 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7929 PyObject *resultobj = 0;
7930 wxMouseState *arg1 = (wxMouseState *) 0 ;
7931 bool arg2 ;
7932 void *argp1 = 0 ;
7933 int res1 = 0 ;
7934 bool val2 ;
7935 int ecode2 = 0 ;
7936 PyObject * obj0 = 0 ;
7937 PyObject * obj1 = 0 ;
7938 char * kwnames[] = {
7939 (char *) "self",(char *) "down", NULL
7940 };
7941
7942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7944 if (!SWIG_IsOK(res1)) {
7945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7946 }
7947 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7948 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7949 if (!SWIG_IsOK(ecode2)) {
7950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7951 }
7952 arg2 = static_cast< bool >(val2);
7953 {
7954 PyThreadState* __tstate = wxPyBeginAllowThreads();
7955 (arg1)->SetAltDown(arg2);
7956 wxPyEndAllowThreads(__tstate);
7957 if (PyErr_Occurred()) SWIG_fail;
7958 }
7959 resultobj = SWIG_Py_Void();
7960 return resultobj;
7961 fail:
7962 return NULL;
7963 }
7964
7965
7966 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7967 PyObject *resultobj = 0;
7968 wxMouseState *arg1 = (wxMouseState *) 0 ;
7969 bool arg2 ;
7970 void *argp1 = 0 ;
7971 int res1 = 0 ;
7972 bool val2 ;
7973 int ecode2 = 0 ;
7974 PyObject * obj0 = 0 ;
7975 PyObject * obj1 = 0 ;
7976 char * kwnames[] = {
7977 (char *) "self",(char *) "down", NULL
7978 };
7979
7980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7982 if (!SWIG_IsOK(res1)) {
7983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7984 }
7985 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7986 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7987 if (!SWIG_IsOK(ecode2)) {
7988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7989 }
7990 arg2 = static_cast< bool >(val2);
7991 {
7992 PyThreadState* __tstate = wxPyBeginAllowThreads();
7993 (arg1)->SetMetaDown(arg2);
7994 wxPyEndAllowThreads(__tstate);
7995 if (PyErr_Occurred()) SWIG_fail;
7996 }
7997 resultobj = SWIG_Py_Void();
7998 return resultobj;
7999 fail:
8000 return NULL;
8001 }
8002
8003
8004 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8005 PyObject *obj;
8006 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8007 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8008 return SWIG_Py_Void();
8009 }
8010
8011 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8012 return SWIG_Python_InitShadowInstance(args);
8013 }
8014
8015 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8016 PyObject *resultobj = 0;
8017 wxMouseState result;
8018
8019 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8020 {
8021 PyThreadState* __tstate = wxPyBeginAllowThreads();
8022 result = wxGetMouseState();
8023 wxPyEndAllowThreads(__tstate);
8024 if (PyErr_Occurred()) SWIG_fail;
8025 }
8026 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8027 return resultobj;
8028 fail:
8029 return NULL;
8030 }
8031
8032
8033 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8034 PyObject *resultobj = 0;
8035
8036 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8037 {
8038 if (!wxPyCheckForApp()) SWIG_fail;
8039 PyThreadState* __tstate = wxPyBeginAllowThreads();
8040 wxWakeUpMainThread();
8041 wxPyEndAllowThreads(__tstate);
8042 if (PyErr_Occurred()) SWIG_fail;
8043 }
8044 resultobj = SWIG_Py_Void();
8045 return resultobj;
8046 fail:
8047 return NULL;
8048 }
8049
8050
8051 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8052 PyObject *resultobj = 0;
8053
8054 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8055 {
8056 if (!wxPyCheckForApp()) SWIG_fail;
8057 PyThreadState* __tstate = wxPyBeginAllowThreads();
8058 wxMutexGuiEnter();
8059 wxPyEndAllowThreads(__tstate);
8060 if (PyErr_Occurred()) SWIG_fail;
8061 }
8062 resultobj = SWIG_Py_Void();
8063 return resultobj;
8064 fail:
8065 return NULL;
8066 }
8067
8068
8069 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8070 PyObject *resultobj = 0;
8071
8072 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8073 {
8074 if (!wxPyCheckForApp()) SWIG_fail;
8075 PyThreadState* __tstate = wxPyBeginAllowThreads();
8076 wxMutexGuiLeave();
8077 wxPyEndAllowThreads(__tstate);
8078 if (PyErr_Occurred()) SWIG_fail;
8079 }
8080 resultobj = SWIG_Py_Void();
8081 return resultobj;
8082 fail:
8083 return NULL;
8084 }
8085
8086
8087 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8088 PyObject *resultobj = 0;
8089 wxMutexGuiLocker *result = 0 ;
8090
8091 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8092 {
8093 if (!wxPyCheckForApp()) SWIG_fail;
8094 PyThreadState* __tstate = wxPyBeginAllowThreads();
8095 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8096 wxPyEndAllowThreads(__tstate);
8097 if (PyErr_Occurred()) SWIG_fail;
8098 }
8099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8100 return resultobj;
8101 fail:
8102 return NULL;
8103 }
8104
8105
8106 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8107 PyObject *resultobj = 0;
8108 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8109 void *argp1 = 0 ;
8110 int res1 = 0 ;
8111 PyObject *swig_obj[1] ;
8112
8113 if (!args) SWIG_fail;
8114 swig_obj[0] = args;
8115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8116 if (!SWIG_IsOK(res1)) {
8117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8118 }
8119 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8120 {
8121 PyThreadState* __tstate = wxPyBeginAllowThreads();
8122 delete arg1;
8123
8124 wxPyEndAllowThreads(__tstate);
8125 if (PyErr_Occurred()) SWIG_fail;
8126 }
8127 resultobj = SWIG_Py_Void();
8128 return resultobj;
8129 fail:
8130 return NULL;
8131 }
8132
8133
8134 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8135 PyObject *obj;
8136 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8137 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8138 return SWIG_Py_Void();
8139 }
8140
8141 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8142 return SWIG_Python_InitShadowInstance(args);
8143 }
8144
8145 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8146 PyObject *resultobj = 0;
8147 bool result;
8148
8149 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8150 {
8151 PyThreadState* __tstate = wxPyBeginAllowThreads();
8152 result = (bool)wxThread_IsMain();
8153 wxPyEndAllowThreads(__tstate);
8154 if (PyErr_Occurred()) SWIG_fail;
8155 }
8156 {
8157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8158 }
8159 return resultobj;
8160 fail:
8161 return NULL;
8162 }
8163
8164
8165 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8166 PyObject *resultobj = 0;
8167 wxString *arg1 = 0 ;
8168 wxToolTip *result = 0 ;
8169 bool temp1 = false ;
8170 PyObject * obj0 = 0 ;
8171 char * kwnames[] = {
8172 (char *) "tip", NULL
8173 };
8174
8175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8176 {
8177 arg1 = wxString_in_helper(obj0);
8178 if (arg1 == NULL) SWIG_fail;
8179 temp1 = true;
8180 }
8181 {
8182 if (!wxPyCheckForApp()) SWIG_fail;
8183 PyThreadState* __tstate = wxPyBeginAllowThreads();
8184 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8185 wxPyEndAllowThreads(__tstate);
8186 if (PyErr_Occurred()) SWIG_fail;
8187 }
8188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8189 {
8190 if (temp1)
8191 delete arg1;
8192 }
8193 return resultobj;
8194 fail:
8195 {
8196 if (temp1)
8197 delete arg1;
8198 }
8199 return NULL;
8200 }
8201
8202
8203 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8204 PyObject *resultobj = 0;
8205 wxToolTip *arg1 = (wxToolTip *) 0 ;
8206 void *argp1 = 0 ;
8207 int res1 = 0 ;
8208 PyObject *swig_obj[1] ;
8209
8210 if (!args) SWIG_fail;
8211 swig_obj[0] = args;
8212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8213 if (!SWIG_IsOK(res1)) {
8214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8215 }
8216 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8217 {
8218 PyThreadState* __tstate = wxPyBeginAllowThreads();
8219 delete arg1;
8220
8221 wxPyEndAllowThreads(__tstate);
8222 if (PyErr_Occurred()) SWIG_fail;
8223 }
8224 resultobj = SWIG_Py_Void();
8225 return resultobj;
8226 fail:
8227 return NULL;
8228 }
8229
8230
8231 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8232 PyObject *resultobj = 0;
8233 wxToolTip *arg1 = (wxToolTip *) 0 ;
8234 wxString *arg2 = 0 ;
8235 void *argp1 = 0 ;
8236 int res1 = 0 ;
8237 bool temp2 = false ;
8238 PyObject * obj0 = 0 ;
8239 PyObject * obj1 = 0 ;
8240 char * kwnames[] = {
8241 (char *) "self",(char *) "tip", NULL
8242 };
8243
8244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8246 if (!SWIG_IsOK(res1)) {
8247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8248 }
8249 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8250 {
8251 arg2 = wxString_in_helper(obj1);
8252 if (arg2 == NULL) SWIG_fail;
8253 temp2 = true;
8254 }
8255 {
8256 PyThreadState* __tstate = wxPyBeginAllowThreads();
8257 (arg1)->SetTip((wxString const &)*arg2);
8258 wxPyEndAllowThreads(__tstate);
8259 if (PyErr_Occurred()) SWIG_fail;
8260 }
8261 resultobj = SWIG_Py_Void();
8262 {
8263 if (temp2)
8264 delete arg2;
8265 }
8266 return resultobj;
8267 fail:
8268 {
8269 if (temp2)
8270 delete arg2;
8271 }
8272 return NULL;
8273 }
8274
8275
8276 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8277 PyObject *resultobj = 0;
8278 wxToolTip *arg1 = (wxToolTip *) 0 ;
8279 wxString result;
8280 void *argp1 = 0 ;
8281 int res1 = 0 ;
8282 PyObject *swig_obj[1] ;
8283
8284 if (!args) SWIG_fail;
8285 swig_obj[0] = args;
8286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8287 if (!SWIG_IsOK(res1)) {
8288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8289 }
8290 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8291 {
8292 PyThreadState* __tstate = wxPyBeginAllowThreads();
8293 result = (arg1)->GetTip();
8294 wxPyEndAllowThreads(__tstate);
8295 if (PyErr_Occurred()) SWIG_fail;
8296 }
8297 {
8298 #if wxUSE_UNICODE
8299 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8300 #else
8301 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8302 #endif
8303 }
8304 return resultobj;
8305 fail:
8306 return NULL;
8307 }
8308
8309
8310 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8311 PyObject *resultobj = 0;
8312 wxToolTip *arg1 = (wxToolTip *) 0 ;
8313 wxWindow *result = 0 ;
8314 void *argp1 = 0 ;
8315 int res1 = 0 ;
8316 PyObject *swig_obj[1] ;
8317
8318 if (!args) SWIG_fail;
8319 swig_obj[0] = args;
8320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8321 if (!SWIG_IsOK(res1)) {
8322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8323 }
8324 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8325 {
8326 PyThreadState* __tstate = wxPyBeginAllowThreads();
8327 result = (wxWindow *)(arg1)->GetWindow();
8328 wxPyEndAllowThreads(__tstate);
8329 if (PyErr_Occurred()) SWIG_fail;
8330 }
8331 {
8332 resultobj = wxPyMake_wxObject(result, 0);
8333 }
8334 return resultobj;
8335 fail:
8336 return NULL;
8337 }
8338
8339
8340 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8341 PyObject *resultobj = 0;
8342 bool arg1 ;
8343 bool val1 ;
8344 int ecode1 = 0 ;
8345 PyObject * obj0 = 0 ;
8346 char * kwnames[] = {
8347 (char *) "flag", NULL
8348 };
8349
8350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8351 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8352 if (!SWIG_IsOK(ecode1)) {
8353 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8354 }
8355 arg1 = static_cast< bool >(val1);
8356 {
8357 PyThreadState* __tstate = wxPyBeginAllowThreads();
8358 wxToolTip::Enable(arg1);
8359 wxPyEndAllowThreads(__tstate);
8360 if (PyErr_Occurred()) SWIG_fail;
8361 }
8362 resultobj = SWIG_Py_Void();
8363 return resultobj;
8364 fail:
8365 return NULL;
8366 }
8367
8368
8369 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8370 PyObject *resultobj = 0;
8371 long arg1 ;
8372 long val1 ;
8373 int ecode1 = 0 ;
8374 PyObject * obj0 = 0 ;
8375 char * kwnames[] = {
8376 (char *) "milliseconds", NULL
8377 };
8378
8379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8380 ecode1 = SWIG_AsVal_long(obj0, &val1);
8381 if (!SWIG_IsOK(ecode1)) {
8382 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8383 }
8384 arg1 = static_cast< long >(val1);
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 wxToolTip::SetDelay(arg1);
8388 wxPyEndAllowThreads(__tstate);
8389 if (PyErr_Occurred()) SWIG_fail;
8390 }
8391 resultobj = SWIG_Py_Void();
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8399 PyObject *obj;
8400 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8401 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8402 return SWIG_Py_Void();
8403 }
8404
8405 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8406 return SWIG_Python_InitShadowInstance(args);
8407 }
8408
8409 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8410 PyObject *resultobj = 0;
8411 wxWindow *arg1 = (wxWindow *) 0 ;
8412 wxSize *arg2 = 0 ;
8413 wxCaret *result = 0 ;
8414 void *argp1 = 0 ;
8415 int res1 = 0 ;
8416 wxSize temp2 ;
8417 PyObject * obj0 = 0 ;
8418 PyObject * obj1 = 0 ;
8419 char * kwnames[] = {
8420 (char *) "window",(char *) "size", NULL
8421 };
8422
8423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8425 if (!SWIG_IsOK(res1)) {
8426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8427 }
8428 arg1 = reinterpret_cast< wxWindow * >(argp1);
8429 {
8430 arg2 = &temp2;
8431 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8432 }
8433 {
8434 if (!wxPyCheckForApp()) SWIG_fail;
8435 PyThreadState* __tstate = wxPyBeginAllowThreads();
8436 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8437 wxPyEndAllowThreads(__tstate);
8438 if (PyErr_Occurred()) SWIG_fail;
8439 }
8440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8441 return resultobj;
8442 fail:
8443 return NULL;
8444 }
8445
8446
8447 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8448 PyObject *resultobj = 0;
8449 wxCaret *arg1 = (wxCaret *) 0 ;
8450 void *argp1 = 0 ;
8451 int res1 = 0 ;
8452 PyObject *swig_obj[1] ;
8453
8454 if (!args) SWIG_fail;
8455 swig_obj[0] = args;
8456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8457 if (!SWIG_IsOK(res1)) {
8458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8459 }
8460 arg1 = reinterpret_cast< wxCaret * >(argp1);
8461 {
8462 PyThreadState* __tstate = wxPyBeginAllowThreads();
8463 delete arg1;
8464
8465 wxPyEndAllowThreads(__tstate);
8466 if (PyErr_Occurred()) SWIG_fail;
8467 }
8468 resultobj = SWIG_Py_Void();
8469 return resultobj;
8470 fail:
8471 return NULL;
8472 }
8473
8474
8475 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8476 PyObject *resultobj = 0;
8477 wxCaret *arg1 = (wxCaret *) 0 ;
8478 void *argp1 = 0 ;
8479 int res1 = 0 ;
8480 PyObject *swig_obj[1] ;
8481
8482 if (!args) SWIG_fail;
8483 swig_obj[0] = args;
8484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8485 if (!SWIG_IsOK(res1)) {
8486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8487 }
8488 arg1 = reinterpret_cast< wxCaret * >(argp1);
8489 {
8490 PyThreadState* __tstate = wxPyBeginAllowThreads();
8491 wxCaret_Destroy(arg1);
8492 wxPyEndAllowThreads(__tstate);
8493 if (PyErr_Occurred()) SWIG_fail;
8494 }
8495 resultobj = SWIG_Py_Void();
8496 return resultobj;
8497 fail:
8498 return NULL;
8499 }
8500
8501
8502 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8503 PyObject *resultobj = 0;
8504 wxCaret *arg1 = (wxCaret *) 0 ;
8505 bool result;
8506 void *argp1 = 0 ;
8507 int res1 = 0 ;
8508 PyObject *swig_obj[1] ;
8509
8510 if (!args) SWIG_fail;
8511 swig_obj[0] = args;
8512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8513 if (!SWIG_IsOK(res1)) {
8514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8515 }
8516 arg1 = reinterpret_cast< wxCaret * >(argp1);
8517 {
8518 PyThreadState* __tstate = wxPyBeginAllowThreads();
8519 result = (bool)(arg1)->IsOk();
8520 wxPyEndAllowThreads(__tstate);
8521 if (PyErr_Occurred()) SWIG_fail;
8522 }
8523 {
8524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8525 }
8526 return resultobj;
8527 fail:
8528 return NULL;
8529 }
8530
8531
8532 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8533 PyObject *resultobj = 0;
8534 wxCaret *arg1 = (wxCaret *) 0 ;
8535 bool result;
8536 void *argp1 = 0 ;
8537 int res1 = 0 ;
8538 PyObject *swig_obj[1] ;
8539
8540 if (!args) SWIG_fail;
8541 swig_obj[0] = args;
8542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8543 if (!SWIG_IsOK(res1)) {
8544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8545 }
8546 arg1 = reinterpret_cast< wxCaret * >(argp1);
8547 {
8548 PyThreadState* __tstate = wxPyBeginAllowThreads();
8549 result = (bool)(arg1)->IsVisible();
8550 wxPyEndAllowThreads(__tstate);
8551 if (PyErr_Occurred()) SWIG_fail;
8552 }
8553 {
8554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8555 }
8556 return resultobj;
8557 fail:
8558 return NULL;
8559 }
8560
8561
8562 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8563 PyObject *resultobj = 0;
8564 wxCaret *arg1 = (wxCaret *) 0 ;
8565 wxPoint result;
8566 void *argp1 = 0 ;
8567 int res1 = 0 ;
8568 PyObject *swig_obj[1] ;
8569
8570 if (!args) SWIG_fail;
8571 swig_obj[0] = args;
8572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8573 if (!SWIG_IsOK(res1)) {
8574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8575 }
8576 arg1 = reinterpret_cast< wxCaret * >(argp1);
8577 {
8578 PyThreadState* __tstate = wxPyBeginAllowThreads();
8579 result = (arg1)->GetPosition();
8580 wxPyEndAllowThreads(__tstate);
8581 if (PyErr_Occurred()) SWIG_fail;
8582 }
8583 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8584 return resultobj;
8585 fail:
8586 return NULL;
8587 }
8588
8589
8590 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8591 PyObject *resultobj = 0;
8592 wxCaret *arg1 = (wxCaret *) 0 ;
8593 int *arg2 = (int *) 0 ;
8594 int *arg3 = (int *) 0 ;
8595 void *argp1 = 0 ;
8596 int res1 = 0 ;
8597 int temp2 ;
8598 int res2 = SWIG_TMPOBJ ;
8599 int temp3 ;
8600 int res3 = SWIG_TMPOBJ ;
8601 PyObject *swig_obj[1] ;
8602
8603 arg2 = &temp2;
8604 arg3 = &temp3;
8605 if (!args) SWIG_fail;
8606 swig_obj[0] = args;
8607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8608 if (!SWIG_IsOK(res1)) {
8609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8610 }
8611 arg1 = reinterpret_cast< wxCaret * >(argp1);
8612 {
8613 PyThreadState* __tstate = wxPyBeginAllowThreads();
8614 (arg1)->GetPosition(arg2,arg3);
8615 wxPyEndAllowThreads(__tstate);
8616 if (PyErr_Occurred()) SWIG_fail;
8617 }
8618 resultobj = SWIG_Py_Void();
8619 if (SWIG_IsTmpObj(res2)) {
8620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8621 } else {
8622 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8623 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8624 }
8625 if (SWIG_IsTmpObj(res3)) {
8626 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8627 } else {
8628 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8629 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8630 }
8631 return resultobj;
8632 fail:
8633 return NULL;
8634 }
8635
8636
8637 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8638 PyObject *resultobj = 0;
8639 wxCaret *arg1 = (wxCaret *) 0 ;
8640 wxSize result;
8641 void *argp1 = 0 ;
8642 int res1 = 0 ;
8643 PyObject *swig_obj[1] ;
8644
8645 if (!args) SWIG_fail;
8646 swig_obj[0] = args;
8647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8648 if (!SWIG_IsOK(res1)) {
8649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8650 }
8651 arg1 = reinterpret_cast< wxCaret * >(argp1);
8652 {
8653 PyThreadState* __tstate = wxPyBeginAllowThreads();
8654 result = (arg1)->GetSize();
8655 wxPyEndAllowThreads(__tstate);
8656 if (PyErr_Occurred()) SWIG_fail;
8657 }
8658 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8659 return resultobj;
8660 fail:
8661 return NULL;
8662 }
8663
8664
8665 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8666 PyObject *resultobj = 0;
8667 wxCaret *arg1 = (wxCaret *) 0 ;
8668 int *arg2 = (int *) 0 ;
8669 int *arg3 = (int *) 0 ;
8670 void *argp1 = 0 ;
8671 int res1 = 0 ;
8672 int temp2 ;
8673 int res2 = SWIG_TMPOBJ ;
8674 int temp3 ;
8675 int res3 = SWIG_TMPOBJ ;
8676 PyObject *swig_obj[1] ;
8677
8678 arg2 = &temp2;
8679 arg3 = &temp3;
8680 if (!args) SWIG_fail;
8681 swig_obj[0] = args;
8682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8683 if (!SWIG_IsOK(res1)) {
8684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8685 }
8686 arg1 = reinterpret_cast< wxCaret * >(argp1);
8687 {
8688 PyThreadState* __tstate = wxPyBeginAllowThreads();
8689 (arg1)->GetSize(arg2,arg3);
8690 wxPyEndAllowThreads(__tstate);
8691 if (PyErr_Occurred()) SWIG_fail;
8692 }
8693 resultobj = SWIG_Py_Void();
8694 if (SWIG_IsTmpObj(res2)) {
8695 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8696 } else {
8697 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8699 }
8700 if (SWIG_IsTmpObj(res3)) {
8701 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8702 } else {
8703 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8704 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8705 }
8706 return resultobj;
8707 fail:
8708 return NULL;
8709 }
8710
8711
8712 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8713 PyObject *resultobj = 0;
8714 wxCaret *arg1 = (wxCaret *) 0 ;
8715 wxWindow *result = 0 ;
8716 void *argp1 = 0 ;
8717 int res1 = 0 ;
8718 PyObject *swig_obj[1] ;
8719
8720 if (!args) SWIG_fail;
8721 swig_obj[0] = args;
8722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8723 if (!SWIG_IsOK(res1)) {
8724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8725 }
8726 arg1 = reinterpret_cast< wxCaret * >(argp1);
8727 {
8728 PyThreadState* __tstate = wxPyBeginAllowThreads();
8729 result = (wxWindow *)(arg1)->GetWindow();
8730 wxPyEndAllowThreads(__tstate);
8731 if (PyErr_Occurred()) SWIG_fail;
8732 }
8733 {
8734 resultobj = wxPyMake_wxObject(result, 0);
8735 }
8736 return resultobj;
8737 fail:
8738 return NULL;
8739 }
8740
8741
8742 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8743 PyObject *resultobj = 0;
8744 wxCaret *arg1 = (wxCaret *) 0 ;
8745 int arg2 ;
8746 int arg3 ;
8747 void *argp1 = 0 ;
8748 int res1 = 0 ;
8749 int val2 ;
8750 int ecode2 = 0 ;
8751 int val3 ;
8752 int ecode3 = 0 ;
8753 PyObject * obj0 = 0 ;
8754 PyObject * obj1 = 0 ;
8755 PyObject * obj2 = 0 ;
8756 char * kwnames[] = {
8757 (char *) "self",(char *) "x",(char *) "y", NULL
8758 };
8759
8760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8762 if (!SWIG_IsOK(res1)) {
8763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8764 }
8765 arg1 = reinterpret_cast< wxCaret * >(argp1);
8766 ecode2 = SWIG_AsVal_int(obj1, &val2);
8767 if (!SWIG_IsOK(ecode2)) {
8768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8769 }
8770 arg2 = static_cast< int >(val2);
8771 ecode3 = SWIG_AsVal_int(obj2, &val3);
8772 if (!SWIG_IsOK(ecode3)) {
8773 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8774 }
8775 arg3 = static_cast< int >(val3);
8776 {
8777 PyThreadState* __tstate = wxPyBeginAllowThreads();
8778 (arg1)->Move(arg2,arg3);
8779 wxPyEndAllowThreads(__tstate);
8780 if (PyErr_Occurred()) SWIG_fail;
8781 }
8782 resultobj = SWIG_Py_Void();
8783 return resultobj;
8784 fail:
8785 return NULL;
8786 }
8787
8788
8789 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8790 PyObject *resultobj = 0;
8791 wxCaret *arg1 = (wxCaret *) 0 ;
8792 wxPoint *arg2 = 0 ;
8793 void *argp1 = 0 ;
8794 int res1 = 0 ;
8795 wxPoint temp2 ;
8796 PyObject * obj0 = 0 ;
8797 PyObject * obj1 = 0 ;
8798 char * kwnames[] = {
8799 (char *) "self",(char *) "pt", NULL
8800 };
8801
8802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8804 if (!SWIG_IsOK(res1)) {
8805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8806 }
8807 arg1 = reinterpret_cast< wxCaret * >(argp1);
8808 {
8809 arg2 = &temp2;
8810 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8811 }
8812 {
8813 PyThreadState* __tstate = wxPyBeginAllowThreads();
8814 (arg1)->Move((wxPoint const &)*arg2);
8815 wxPyEndAllowThreads(__tstate);
8816 if (PyErr_Occurred()) SWIG_fail;
8817 }
8818 resultobj = SWIG_Py_Void();
8819 return resultobj;
8820 fail:
8821 return NULL;
8822 }
8823
8824
8825 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8826 PyObject *resultobj = 0;
8827 wxCaret *arg1 = (wxCaret *) 0 ;
8828 int arg2 ;
8829 int arg3 ;
8830 void *argp1 = 0 ;
8831 int res1 = 0 ;
8832 int val2 ;
8833 int ecode2 = 0 ;
8834 int val3 ;
8835 int ecode3 = 0 ;
8836 PyObject * obj0 = 0 ;
8837 PyObject * obj1 = 0 ;
8838 PyObject * obj2 = 0 ;
8839 char * kwnames[] = {
8840 (char *) "self",(char *) "width",(char *) "height", NULL
8841 };
8842
8843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8845 if (!SWIG_IsOK(res1)) {
8846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8847 }
8848 arg1 = reinterpret_cast< wxCaret * >(argp1);
8849 ecode2 = SWIG_AsVal_int(obj1, &val2);
8850 if (!SWIG_IsOK(ecode2)) {
8851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8852 }
8853 arg2 = static_cast< int >(val2);
8854 ecode3 = SWIG_AsVal_int(obj2, &val3);
8855 if (!SWIG_IsOK(ecode3)) {
8856 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8857 }
8858 arg3 = static_cast< int >(val3);
8859 {
8860 PyThreadState* __tstate = wxPyBeginAllowThreads();
8861 (arg1)->SetSize(arg2,arg3);
8862 wxPyEndAllowThreads(__tstate);
8863 if (PyErr_Occurred()) SWIG_fail;
8864 }
8865 resultobj = SWIG_Py_Void();
8866 return resultobj;
8867 fail:
8868 return NULL;
8869 }
8870
8871
8872 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8873 PyObject *resultobj = 0;
8874 wxCaret *arg1 = (wxCaret *) 0 ;
8875 wxSize *arg2 = 0 ;
8876 void *argp1 = 0 ;
8877 int res1 = 0 ;
8878 wxSize temp2 ;
8879 PyObject * obj0 = 0 ;
8880 PyObject * obj1 = 0 ;
8881 char * kwnames[] = {
8882 (char *) "self",(char *) "size", NULL
8883 };
8884
8885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8887 if (!SWIG_IsOK(res1)) {
8888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8889 }
8890 arg1 = reinterpret_cast< wxCaret * >(argp1);
8891 {
8892 arg2 = &temp2;
8893 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8894 }
8895 {
8896 PyThreadState* __tstate = wxPyBeginAllowThreads();
8897 (arg1)->SetSize((wxSize const &)*arg2);
8898 wxPyEndAllowThreads(__tstate);
8899 if (PyErr_Occurred()) SWIG_fail;
8900 }
8901 resultobj = SWIG_Py_Void();
8902 return resultobj;
8903 fail:
8904 return NULL;
8905 }
8906
8907
8908 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8909 PyObject *resultobj = 0;
8910 wxCaret *arg1 = (wxCaret *) 0 ;
8911 int arg2 = (int) true ;
8912 void *argp1 = 0 ;
8913 int res1 = 0 ;
8914 int val2 ;
8915 int ecode2 = 0 ;
8916 PyObject * obj0 = 0 ;
8917 PyObject * obj1 = 0 ;
8918 char * kwnames[] = {
8919 (char *) "self",(char *) "show", NULL
8920 };
8921
8922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8924 if (!SWIG_IsOK(res1)) {
8925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8926 }
8927 arg1 = reinterpret_cast< wxCaret * >(argp1);
8928 if (obj1) {
8929 ecode2 = SWIG_AsVal_int(obj1, &val2);
8930 if (!SWIG_IsOK(ecode2)) {
8931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8932 }
8933 arg2 = static_cast< int >(val2);
8934 }
8935 {
8936 PyThreadState* __tstate = wxPyBeginAllowThreads();
8937 (arg1)->Show(arg2);
8938 wxPyEndAllowThreads(__tstate);
8939 if (PyErr_Occurred()) SWIG_fail;
8940 }
8941 resultobj = SWIG_Py_Void();
8942 return resultobj;
8943 fail:
8944 return NULL;
8945 }
8946
8947
8948 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8949 PyObject *resultobj = 0;
8950 wxCaret *arg1 = (wxCaret *) 0 ;
8951 void *argp1 = 0 ;
8952 int res1 = 0 ;
8953 PyObject *swig_obj[1] ;
8954
8955 if (!args) SWIG_fail;
8956 swig_obj[0] = args;
8957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8958 if (!SWIG_IsOK(res1)) {
8959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8960 }
8961 arg1 = reinterpret_cast< wxCaret * >(argp1);
8962 {
8963 PyThreadState* __tstate = wxPyBeginAllowThreads();
8964 (arg1)->Hide();
8965 wxPyEndAllowThreads(__tstate);
8966 if (PyErr_Occurred()) SWIG_fail;
8967 }
8968 resultobj = SWIG_Py_Void();
8969 return resultobj;
8970 fail:
8971 return NULL;
8972 }
8973
8974
8975 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8976 PyObject *resultobj = 0;
8977 int result;
8978
8979 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8980 {
8981 PyThreadState* __tstate = wxPyBeginAllowThreads();
8982 result = (int)wxCaret::GetBlinkTime();
8983 wxPyEndAllowThreads(__tstate);
8984 if (PyErr_Occurred()) SWIG_fail;
8985 }
8986 resultobj = SWIG_From_int(static_cast< int >(result));
8987 return resultobj;
8988 fail:
8989 return NULL;
8990 }
8991
8992
8993 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8994 PyObject *resultobj = 0;
8995 int arg1 ;
8996 int val1 ;
8997 int ecode1 = 0 ;
8998 PyObject * obj0 = 0 ;
8999 char * kwnames[] = {
9000 (char *) "milliseconds", NULL
9001 };
9002
9003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9004 ecode1 = SWIG_AsVal_int(obj0, &val1);
9005 if (!SWIG_IsOK(ecode1)) {
9006 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9007 }
9008 arg1 = static_cast< int >(val1);
9009 {
9010 PyThreadState* __tstate = wxPyBeginAllowThreads();
9011 wxCaret::SetBlinkTime(arg1);
9012 wxPyEndAllowThreads(__tstate);
9013 if (PyErr_Occurred()) SWIG_fail;
9014 }
9015 resultobj = SWIG_Py_Void();
9016 return resultobj;
9017 fail:
9018 return NULL;
9019 }
9020
9021
9022 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9023 PyObject *obj;
9024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9025 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9026 return SWIG_Py_Void();
9027 }
9028
9029 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9030 return SWIG_Python_InitShadowInstance(args);
9031 }
9032
9033 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9034 PyObject *resultobj = 0;
9035 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9036 wxBusyCursor *result = 0 ;
9037 void *argp1 = 0 ;
9038 int res1 = 0 ;
9039 PyObject * obj0 = 0 ;
9040 char * kwnames[] = {
9041 (char *) "cursor", NULL
9042 };
9043
9044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9045 if (obj0) {
9046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9047 if (!SWIG_IsOK(res1)) {
9048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9049 }
9050 arg1 = reinterpret_cast< wxCursor * >(argp1);
9051 }
9052 {
9053 if (!wxPyCheckForApp()) SWIG_fail;
9054 PyThreadState* __tstate = wxPyBeginAllowThreads();
9055 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9056 wxPyEndAllowThreads(__tstate);
9057 if (PyErr_Occurred()) SWIG_fail;
9058 }
9059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9060 return resultobj;
9061 fail:
9062 return NULL;
9063 }
9064
9065
9066 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9067 PyObject *resultobj = 0;
9068 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9069 void *argp1 = 0 ;
9070 int res1 = 0 ;
9071 PyObject *swig_obj[1] ;
9072
9073 if (!args) SWIG_fail;
9074 swig_obj[0] = args;
9075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9076 if (!SWIG_IsOK(res1)) {
9077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9078 }
9079 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9080 {
9081 PyThreadState* __tstate = wxPyBeginAllowThreads();
9082 delete arg1;
9083
9084 wxPyEndAllowThreads(__tstate);
9085 if (PyErr_Occurred()) SWIG_fail;
9086 }
9087 resultobj = SWIG_Py_Void();
9088 return resultobj;
9089 fail:
9090 return NULL;
9091 }
9092
9093
9094 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9095 PyObject *obj;
9096 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9097 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9098 return SWIG_Py_Void();
9099 }
9100
9101 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9102 return SWIG_Python_InitShadowInstance(args);
9103 }
9104
9105 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9106 PyObject *resultobj = 0;
9107 wxWindow *arg1 = (wxWindow *) NULL ;
9108 wxWindowDisabler *result = 0 ;
9109 void *argp1 = 0 ;
9110 int res1 = 0 ;
9111 PyObject * obj0 = 0 ;
9112 char * kwnames[] = {
9113 (char *) "winToSkip", NULL
9114 };
9115
9116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9117 if (obj0) {
9118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9119 if (!SWIG_IsOK(res1)) {
9120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9121 }
9122 arg1 = reinterpret_cast< wxWindow * >(argp1);
9123 }
9124 {
9125 if (!wxPyCheckForApp()) SWIG_fail;
9126 PyThreadState* __tstate = wxPyBeginAllowThreads();
9127 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9128 wxPyEndAllowThreads(__tstate);
9129 if (PyErr_Occurred()) SWIG_fail;
9130 }
9131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9132 return resultobj;
9133 fail:
9134 return NULL;
9135 }
9136
9137
9138 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9139 PyObject *resultobj = 0;
9140 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9141 void *argp1 = 0 ;
9142 int res1 = 0 ;
9143 PyObject *swig_obj[1] ;
9144
9145 if (!args) SWIG_fail;
9146 swig_obj[0] = args;
9147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9148 if (!SWIG_IsOK(res1)) {
9149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9150 }
9151 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9152 {
9153 PyThreadState* __tstate = wxPyBeginAllowThreads();
9154 delete arg1;
9155
9156 wxPyEndAllowThreads(__tstate);
9157 if (PyErr_Occurred()) SWIG_fail;
9158 }
9159 resultobj = SWIG_Py_Void();
9160 return resultobj;
9161 fail:
9162 return NULL;
9163 }
9164
9165
9166 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9167 PyObject *obj;
9168 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9169 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9170 return SWIG_Py_Void();
9171 }
9172
9173 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9174 return SWIG_Python_InitShadowInstance(args);
9175 }
9176
9177 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9178 PyObject *resultobj = 0;
9179 wxString *arg1 = 0 ;
9180 wxBusyInfo *result = 0 ;
9181 bool temp1 = false ;
9182 PyObject * obj0 = 0 ;
9183 char * kwnames[] = {
9184 (char *) "message", NULL
9185 };
9186
9187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9188 {
9189 arg1 = wxString_in_helper(obj0);
9190 if (arg1 == NULL) SWIG_fail;
9191 temp1 = true;
9192 }
9193 {
9194 if (!wxPyCheckForApp()) SWIG_fail;
9195 PyThreadState* __tstate = wxPyBeginAllowThreads();
9196 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9197 wxPyEndAllowThreads(__tstate);
9198 if (PyErr_Occurred()) SWIG_fail;
9199 }
9200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9201 {
9202 if (temp1)
9203 delete arg1;
9204 }
9205 return resultobj;
9206 fail:
9207 {
9208 if (temp1)
9209 delete arg1;
9210 }
9211 return NULL;
9212 }
9213
9214
9215 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9216 PyObject *resultobj = 0;
9217 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9218 void *argp1 = 0 ;
9219 int res1 = 0 ;
9220 PyObject *swig_obj[1] ;
9221
9222 if (!args) SWIG_fail;
9223 swig_obj[0] = args;
9224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9225 if (!SWIG_IsOK(res1)) {
9226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9227 }
9228 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9229 {
9230 PyThreadState* __tstate = wxPyBeginAllowThreads();
9231 delete arg1;
9232
9233 wxPyEndAllowThreads(__tstate);
9234 if (PyErr_Occurred()) SWIG_fail;
9235 }
9236 resultobj = SWIG_Py_Void();
9237 return resultobj;
9238 fail:
9239 return NULL;
9240 }
9241
9242
9243 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9244 PyObject *obj;
9245 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9246 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9247 return SWIG_Py_Void();
9248 }
9249
9250 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9251 return SWIG_Python_InitShadowInstance(args);
9252 }
9253
9254 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9255 PyObject *resultobj = 0;
9256 wxStopWatch *result = 0 ;
9257
9258 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9259 {
9260 PyThreadState* __tstate = wxPyBeginAllowThreads();
9261 result = (wxStopWatch *)new wxStopWatch();
9262 wxPyEndAllowThreads(__tstate);
9263 if (PyErr_Occurred()) SWIG_fail;
9264 }
9265 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9266 return resultobj;
9267 fail:
9268 return NULL;
9269 }
9270
9271
9272 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9273 PyObject *resultobj = 0;
9274 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9275 long arg2 = (long) 0 ;
9276 void *argp1 = 0 ;
9277 int res1 = 0 ;
9278 long val2 ;
9279 int ecode2 = 0 ;
9280 PyObject * obj0 = 0 ;
9281 PyObject * obj1 = 0 ;
9282 char * kwnames[] = {
9283 (char *) "self",(char *) "t0", NULL
9284 };
9285
9286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9288 if (!SWIG_IsOK(res1)) {
9289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9290 }
9291 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9292 if (obj1) {
9293 ecode2 = SWIG_AsVal_long(obj1, &val2);
9294 if (!SWIG_IsOK(ecode2)) {
9295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9296 }
9297 arg2 = static_cast< long >(val2);
9298 }
9299 {
9300 PyThreadState* __tstate = wxPyBeginAllowThreads();
9301 (arg1)->Start(arg2);
9302 wxPyEndAllowThreads(__tstate);
9303 if (PyErr_Occurred()) SWIG_fail;
9304 }
9305 resultobj = SWIG_Py_Void();
9306 return resultobj;
9307 fail:
9308 return NULL;
9309 }
9310
9311
9312 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9313 PyObject *resultobj = 0;
9314 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9315 void *argp1 = 0 ;
9316 int res1 = 0 ;
9317 PyObject *swig_obj[1] ;
9318
9319 if (!args) SWIG_fail;
9320 swig_obj[0] = args;
9321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9322 if (!SWIG_IsOK(res1)) {
9323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9324 }
9325 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9326 {
9327 PyThreadState* __tstate = wxPyBeginAllowThreads();
9328 (arg1)->Pause();
9329 wxPyEndAllowThreads(__tstate);
9330 if (PyErr_Occurred()) SWIG_fail;
9331 }
9332 resultobj = SWIG_Py_Void();
9333 return resultobj;
9334 fail:
9335 return NULL;
9336 }
9337
9338
9339 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9340 PyObject *resultobj = 0;
9341 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9342 void *argp1 = 0 ;
9343 int res1 = 0 ;
9344 PyObject *swig_obj[1] ;
9345
9346 if (!args) SWIG_fail;
9347 swig_obj[0] = args;
9348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9349 if (!SWIG_IsOK(res1)) {
9350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9351 }
9352 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9353 {
9354 PyThreadState* __tstate = wxPyBeginAllowThreads();
9355 (arg1)->Resume();
9356 wxPyEndAllowThreads(__tstate);
9357 if (PyErr_Occurred()) SWIG_fail;
9358 }
9359 resultobj = SWIG_Py_Void();
9360 return resultobj;
9361 fail:
9362 return NULL;
9363 }
9364
9365
9366 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9367 PyObject *resultobj = 0;
9368 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9369 long result;
9370 void *argp1 = 0 ;
9371 int res1 = 0 ;
9372 PyObject *swig_obj[1] ;
9373
9374 if (!args) SWIG_fail;
9375 swig_obj[0] = args;
9376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9377 if (!SWIG_IsOK(res1)) {
9378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9379 }
9380 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9381 {
9382 PyThreadState* __tstate = wxPyBeginAllowThreads();
9383 result = (long)((wxStopWatch const *)arg1)->Time();
9384 wxPyEndAllowThreads(__tstate);
9385 if (PyErr_Occurred()) SWIG_fail;
9386 }
9387 resultobj = SWIG_From_long(static_cast< long >(result));
9388 return resultobj;
9389 fail:
9390 return NULL;
9391 }
9392
9393
9394 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9395 PyObject *obj;
9396 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9397 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9398 return SWIG_Py_Void();
9399 }
9400
9401 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9402 return SWIG_Python_InitShadowInstance(args);
9403 }
9404
9405 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9406 PyObject *resultobj = 0;
9407 int arg1 = (int) 9 ;
9408 int arg2 = (int) wxID_FILE1 ;
9409 wxFileHistory *result = 0 ;
9410 int val1 ;
9411 int ecode1 = 0 ;
9412 int val2 ;
9413 int ecode2 = 0 ;
9414 PyObject * obj0 = 0 ;
9415 PyObject * obj1 = 0 ;
9416 char * kwnames[] = {
9417 (char *) "maxFiles",(char *) "idBase", NULL
9418 };
9419
9420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9421 if (obj0) {
9422 ecode1 = SWIG_AsVal_int(obj0, &val1);
9423 if (!SWIG_IsOK(ecode1)) {
9424 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9425 }
9426 arg1 = static_cast< int >(val1);
9427 }
9428 if (obj1) {
9429 ecode2 = SWIG_AsVal_int(obj1, &val2);
9430 if (!SWIG_IsOK(ecode2)) {
9431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9432 }
9433 arg2 = static_cast< int >(val2);
9434 }
9435 {
9436 PyThreadState* __tstate = wxPyBeginAllowThreads();
9437 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9438 wxPyEndAllowThreads(__tstate);
9439 if (PyErr_Occurred()) SWIG_fail;
9440 }
9441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9442 return resultobj;
9443 fail:
9444 return NULL;
9445 }
9446
9447
9448 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9449 PyObject *resultobj = 0;
9450 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9451 void *argp1 = 0 ;
9452 int res1 = 0 ;
9453 PyObject *swig_obj[1] ;
9454
9455 if (!args) SWIG_fail;
9456 swig_obj[0] = args;
9457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9458 if (!SWIG_IsOK(res1)) {
9459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9460 }
9461 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9462 {
9463 PyThreadState* __tstate = wxPyBeginAllowThreads();
9464 delete arg1;
9465
9466 wxPyEndAllowThreads(__tstate);
9467 if (PyErr_Occurred()) SWIG_fail;
9468 }
9469 resultobj = SWIG_Py_Void();
9470 return resultobj;
9471 fail:
9472 return NULL;
9473 }
9474
9475
9476 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9477 PyObject *resultobj = 0;
9478 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9479 wxString *arg2 = 0 ;
9480 void *argp1 = 0 ;
9481 int res1 = 0 ;
9482 bool temp2 = false ;
9483 PyObject * obj0 = 0 ;
9484 PyObject * obj1 = 0 ;
9485 char * kwnames[] = {
9486 (char *) "self",(char *) "file", NULL
9487 };
9488
9489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9491 if (!SWIG_IsOK(res1)) {
9492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9493 }
9494 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9495 {
9496 arg2 = wxString_in_helper(obj1);
9497 if (arg2 == NULL) SWIG_fail;
9498 temp2 = true;
9499 }
9500 {
9501 PyThreadState* __tstate = wxPyBeginAllowThreads();
9502 (arg1)->AddFileToHistory((wxString const &)*arg2);
9503 wxPyEndAllowThreads(__tstate);
9504 if (PyErr_Occurred()) SWIG_fail;
9505 }
9506 resultobj = SWIG_Py_Void();
9507 {
9508 if (temp2)
9509 delete arg2;
9510 }
9511 return resultobj;
9512 fail:
9513 {
9514 if (temp2)
9515 delete arg2;
9516 }
9517 return NULL;
9518 }
9519
9520
9521 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9522 PyObject *resultobj = 0;
9523 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9524 int arg2 ;
9525 void *argp1 = 0 ;
9526 int res1 = 0 ;
9527 int val2 ;
9528 int ecode2 = 0 ;
9529 PyObject * obj0 = 0 ;
9530 PyObject * obj1 = 0 ;
9531 char * kwnames[] = {
9532 (char *) "self",(char *) "i", NULL
9533 };
9534
9535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9537 if (!SWIG_IsOK(res1)) {
9538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9539 }
9540 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9541 ecode2 = SWIG_AsVal_int(obj1, &val2);
9542 if (!SWIG_IsOK(ecode2)) {
9543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9544 }
9545 arg2 = static_cast< int >(val2);
9546 {
9547 PyThreadState* __tstate = wxPyBeginAllowThreads();
9548 (arg1)->RemoveFileFromHistory(arg2);
9549 wxPyEndAllowThreads(__tstate);
9550 if (PyErr_Occurred()) SWIG_fail;
9551 }
9552 resultobj = SWIG_Py_Void();
9553 return resultobj;
9554 fail:
9555 return NULL;
9556 }
9557
9558
9559 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9560 PyObject *resultobj = 0;
9561 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9562 int result;
9563 void *argp1 = 0 ;
9564 int res1 = 0 ;
9565 PyObject *swig_obj[1] ;
9566
9567 if (!args) SWIG_fail;
9568 swig_obj[0] = args;
9569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9570 if (!SWIG_IsOK(res1)) {
9571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9572 }
9573 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9574 {
9575 PyThreadState* __tstate = wxPyBeginAllowThreads();
9576 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9577 wxPyEndAllowThreads(__tstate);
9578 if (PyErr_Occurred()) SWIG_fail;
9579 }
9580 resultobj = SWIG_From_int(static_cast< int >(result));
9581 return resultobj;
9582 fail:
9583 return NULL;
9584 }
9585
9586
9587 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9588 PyObject *resultobj = 0;
9589 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9590 wxMenu *arg2 = (wxMenu *) 0 ;
9591 void *argp1 = 0 ;
9592 int res1 = 0 ;
9593 void *argp2 = 0 ;
9594 int res2 = 0 ;
9595 PyObject * obj0 = 0 ;
9596 PyObject * obj1 = 0 ;
9597 char * kwnames[] = {
9598 (char *) "self",(char *) "menu", NULL
9599 };
9600
9601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9603 if (!SWIG_IsOK(res1)) {
9604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9605 }
9606 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9608 if (!SWIG_IsOK(res2)) {
9609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9610 }
9611 arg2 = reinterpret_cast< wxMenu * >(argp2);
9612 {
9613 PyThreadState* __tstate = wxPyBeginAllowThreads();
9614 (arg1)->UseMenu(arg2);
9615 wxPyEndAllowThreads(__tstate);
9616 if (PyErr_Occurred()) SWIG_fail;
9617 }
9618 resultobj = SWIG_Py_Void();
9619 return resultobj;
9620 fail:
9621 return NULL;
9622 }
9623
9624
9625 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9626 PyObject *resultobj = 0;
9627 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9628 wxMenu *arg2 = (wxMenu *) 0 ;
9629 void *argp1 = 0 ;
9630 int res1 = 0 ;
9631 void *argp2 = 0 ;
9632 int res2 = 0 ;
9633 PyObject * obj0 = 0 ;
9634 PyObject * obj1 = 0 ;
9635 char * kwnames[] = {
9636 (char *) "self",(char *) "menu", NULL
9637 };
9638
9639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9641 if (!SWIG_IsOK(res1)) {
9642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9643 }
9644 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9645 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9646 if (!SWIG_IsOK(res2)) {
9647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9648 }
9649 arg2 = reinterpret_cast< wxMenu * >(argp2);
9650 {
9651 PyThreadState* __tstate = wxPyBeginAllowThreads();
9652 (arg1)->RemoveMenu(arg2);
9653 wxPyEndAllowThreads(__tstate);
9654 if (PyErr_Occurred()) SWIG_fail;
9655 }
9656 resultobj = SWIG_Py_Void();
9657 return resultobj;
9658 fail:
9659 return NULL;
9660 }
9661
9662
9663 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9664 PyObject *resultobj = 0;
9665 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9666 wxConfigBase *arg2 = 0 ;
9667 void *argp1 = 0 ;
9668 int res1 = 0 ;
9669 void *argp2 = 0 ;
9670 int res2 = 0 ;
9671 PyObject * obj0 = 0 ;
9672 PyObject * obj1 = 0 ;
9673 char * kwnames[] = {
9674 (char *) "self",(char *) "config", NULL
9675 };
9676
9677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9679 if (!SWIG_IsOK(res1)) {
9680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9681 }
9682 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9683 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9684 if (!SWIG_IsOK(res2)) {
9685 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9686 }
9687 if (!argp2) {
9688 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9689 }
9690 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9691 {
9692 PyThreadState* __tstate = wxPyBeginAllowThreads();
9693 (arg1)->Load(*arg2);
9694 wxPyEndAllowThreads(__tstate);
9695 if (PyErr_Occurred()) SWIG_fail;
9696 }
9697 resultobj = SWIG_Py_Void();
9698 return resultobj;
9699 fail:
9700 return NULL;
9701 }
9702
9703
9704 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9705 PyObject *resultobj = 0;
9706 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9707 wxConfigBase *arg2 = 0 ;
9708 void *argp1 = 0 ;
9709 int res1 = 0 ;
9710 void *argp2 = 0 ;
9711 int res2 = 0 ;
9712 PyObject * obj0 = 0 ;
9713 PyObject * obj1 = 0 ;
9714 char * kwnames[] = {
9715 (char *) "self",(char *) "config", NULL
9716 };
9717
9718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9720 if (!SWIG_IsOK(res1)) {
9721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9722 }
9723 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9724 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9725 if (!SWIG_IsOK(res2)) {
9726 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9727 }
9728 if (!argp2) {
9729 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9730 }
9731 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9732 {
9733 PyThreadState* __tstate = wxPyBeginAllowThreads();
9734 (arg1)->Save(*arg2);
9735 wxPyEndAllowThreads(__tstate);
9736 if (PyErr_Occurred()) SWIG_fail;
9737 }
9738 resultobj = SWIG_Py_Void();
9739 return resultobj;
9740 fail:
9741 return NULL;
9742 }
9743
9744
9745 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9746 PyObject *resultobj = 0;
9747 wxFileHistory *arg1 = (wxFileHistory *) 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_wxFileHistory, 0 | 0 );
9755 if (!SWIG_IsOK(res1)) {
9756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9757 }
9758 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9759 {
9760 PyThreadState* __tstate = wxPyBeginAllowThreads();
9761 (arg1)->AddFilesToMenu();
9762 wxPyEndAllowThreads(__tstate);
9763 if (PyErr_Occurred()) SWIG_fail;
9764 }
9765 resultobj = SWIG_Py_Void();
9766 return resultobj;
9767 fail:
9768 return NULL;
9769 }
9770
9771
9772 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9773 PyObject *resultobj = 0;
9774 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9775 wxMenu *arg2 = (wxMenu *) 0 ;
9776 void *argp1 = 0 ;
9777 int res1 = 0 ;
9778 void *argp2 = 0 ;
9779 int res2 = 0 ;
9780 PyObject * obj0 = 0 ;
9781 PyObject * obj1 = 0 ;
9782 char * kwnames[] = {
9783 (char *) "self",(char *) "menu", NULL
9784 };
9785
9786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9788 if (!SWIG_IsOK(res1)) {
9789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9790 }
9791 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9792 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9793 if (!SWIG_IsOK(res2)) {
9794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9795 }
9796 arg2 = reinterpret_cast< wxMenu * >(argp2);
9797 {
9798 PyThreadState* __tstate = wxPyBeginAllowThreads();
9799 (arg1)->AddFilesToMenu(arg2);
9800 wxPyEndAllowThreads(__tstate);
9801 if (PyErr_Occurred()) SWIG_fail;
9802 }
9803 resultobj = SWIG_Py_Void();
9804 return resultobj;
9805 fail:
9806 return NULL;
9807 }
9808
9809
9810 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9811 PyObject *resultobj = 0;
9812 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9813 int arg2 ;
9814 wxString result;
9815 void *argp1 = 0 ;
9816 int res1 = 0 ;
9817 int val2 ;
9818 int ecode2 = 0 ;
9819 PyObject * obj0 = 0 ;
9820 PyObject * obj1 = 0 ;
9821 char * kwnames[] = {
9822 (char *) "self",(char *) "i", NULL
9823 };
9824
9825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9827 if (!SWIG_IsOK(res1)) {
9828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9829 }
9830 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9831 ecode2 = SWIG_AsVal_int(obj1, &val2);
9832 if (!SWIG_IsOK(ecode2)) {
9833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9834 }
9835 arg2 = static_cast< int >(val2);
9836 {
9837 PyThreadState* __tstate = wxPyBeginAllowThreads();
9838 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9839 wxPyEndAllowThreads(__tstate);
9840 if (PyErr_Occurred()) SWIG_fail;
9841 }
9842 {
9843 #if wxUSE_UNICODE
9844 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9845 #else
9846 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9847 #endif
9848 }
9849 return resultobj;
9850 fail:
9851 return NULL;
9852 }
9853
9854
9855 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9856 PyObject *resultobj = 0;
9857 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9858 int result;
9859 void *argp1 = 0 ;
9860 int res1 = 0 ;
9861 PyObject *swig_obj[1] ;
9862
9863 if (!args) SWIG_fail;
9864 swig_obj[0] = args;
9865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9866 if (!SWIG_IsOK(res1)) {
9867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9868 }
9869 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9870 {
9871 PyThreadState* __tstate = wxPyBeginAllowThreads();
9872 result = (int)((wxFileHistory const *)arg1)->GetCount();
9873 wxPyEndAllowThreads(__tstate);
9874 if (PyErr_Occurred()) SWIG_fail;
9875 }
9876 resultobj = SWIG_From_int(static_cast< int >(result));
9877 return resultobj;
9878 fail:
9879 return NULL;
9880 }
9881
9882
9883 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9884 PyObject *obj;
9885 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9886 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9887 return SWIG_Py_Void();
9888 }
9889
9890 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9891 return SWIG_Python_InitShadowInstance(args);
9892 }
9893
9894 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9895 PyObject *resultobj = 0;
9896 wxString *arg1 = 0 ;
9897 wxString const &arg2_defvalue = wxPyEmptyString ;
9898 wxString *arg2 = (wxString *) &arg2_defvalue ;
9899 wxSingleInstanceChecker *result = 0 ;
9900 bool temp1 = false ;
9901 bool temp2 = false ;
9902 PyObject * obj0 = 0 ;
9903 PyObject * obj1 = 0 ;
9904 char * kwnames[] = {
9905 (char *) "name",(char *) "path", NULL
9906 };
9907
9908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9909 {
9910 arg1 = wxString_in_helper(obj0);
9911 if (arg1 == NULL) SWIG_fail;
9912 temp1 = true;
9913 }
9914 if (obj1) {
9915 {
9916 arg2 = wxString_in_helper(obj1);
9917 if (arg2 == NULL) SWIG_fail;
9918 temp2 = true;
9919 }
9920 }
9921 {
9922 PyThreadState* __tstate = wxPyBeginAllowThreads();
9923 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9924 wxPyEndAllowThreads(__tstate);
9925 if (PyErr_Occurred()) SWIG_fail;
9926 }
9927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9928 {
9929 if (temp1)
9930 delete arg1;
9931 }
9932 {
9933 if (temp2)
9934 delete arg2;
9935 }
9936 return resultobj;
9937 fail:
9938 {
9939 if (temp1)
9940 delete arg1;
9941 }
9942 {
9943 if (temp2)
9944 delete arg2;
9945 }
9946 return NULL;
9947 }
9948
9949
9950 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9951 PyObject *resultobj = 0;
9952 wxSingleInstanceChecker *result = 0 ;
9953
9954 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9955 {
9956 PyThreadState* __tstate = wxPyBeginAllowThreads();
9957 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9958 wxPyEndAllowThreads(__tstate);
9959 if (PyErr_Occurred()) SWIG_fail;
9960 }
9961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9962 return resultobj;
9963 fail:
9964 return NULL;
9965 }
9966
9967
9968 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9969 PyObject *resultobj = 0;
9970 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9971 void *argp1 = 0 ;
9972 int res1 = 0 ;
9973 PyObject *swig_obj[1] ;
9974
9975 if (!args) SWIG_fail;
9976 swig_obj[0] = args;
9977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9978 if (!SWIG_IsOK(res1)) {
9979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9980 }
9981 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9982 {
9983 PyThreadState* __tstate = wxPyBeginAllowThreads();
9984 delete arg1;
9985
9986 wxPyEndAllowThreads(__tstate);
9987 if (PyErr_Occurred()) SWIG_fail;
9988 }
9989 resultobj = SWIG_Py_Void();
9990 return resultobj;
9991 fail:
9992 return NULL;
9993 }
9994
9995
9996 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9997 PyObject *resultobj = 0;
9998 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9999 wxString *arg2 = 0 ;
10000 wxString const &arg3_defvalue = wxPyEmptyString ;
10001 wxString *arg3 = (wxString *) &arg3_defvalue ;
10002 bool result;
10003 void *argp1 = 0 ;
10004 int res1 = 0 ;
10005 bool temp2 = false ;
10006 bool temp3 = false ;
10007 PyObject * obj0 = 0 ;
10008 PyObject * obj1 = 0 ;
10009 PyObject * obj2 = 0 ;
10010 char * kwnames[] = {
10011 (char *) "self",(char *) "name",(char *) "path", NULL
10012 };
10013
10014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10016 if (!SWIG_IsOK(res1)) {
10017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10018 }
10019 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10020 {
10021 arg2 = wxString_in_helper(obj1);
10022 if (arg2 == NULL) SWIG_fail;
10023 temp2 = true;
10024 }
10025 if (obj2) {
10026 {
10027 arg3 = wxString_in_helper(obj2);
10028 if (arg3 == NULL) SWIG_fail;
10029 temp3 = true;
10030 }
10031 }
10032 {
10033 PyThreadState* __tstate = wxPyBeginAllowThreads();
10034 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10035 wxPyEndAllowThreads(__tstate);
10036 if (PyErr_Occurred()) SWIG_fail;
10037 }
10038 {
10039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10040 }
10041 {
10042 if (temp2)
10043 delete arg2;
10044 }
10045 {
10046 if (temp3)
10047 delete arg3;
10048 }
10049 return resultobj;
10050 fail:
10051 {
10052 if (temp2)
10053 delete arg2;
10054 }
10055 {
10056 if (temp3)
10057 delete arg3;
10058 }
10059 return NULL;
10060 }
10061
10062
10063 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10064 PyObject *resultobj = 0;
10065 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10066 bool result;
10067 void *argp1 = 0 ;
10068 int res1 = 0 ;
10069 PyObject *swig_obj[1] ;
10070
10071 if (!args) SWIG_fail;
10072 swig_obj[0] = args;
10073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10074 if (!SWIG_IsOK(res1)) {
10075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10076 }
10077 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10078 {
10079 PyThreadState* __tstate = wxPyBeginAllowThreads();
10080 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10081 wxPyEndAllowThreads(__tstate);
10082 if (PyErr_Occurred()) SWIG_fail;
10083 }
10084 {
10085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10086 }
10087 return resultobj;
10088 fail:
10089 return NULL;
10090 }
10091
10092
10093 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10094 PyObject *obj;
10095 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10096 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10097 return SWIG_Py_Void();
10098 }
10099
10100 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10101 return SWIG_Python_InitShadowInstance(args);
10102 }
10103
10104 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10105 PyObject *resultobj = 0;
10106 wxPlatformInfo *result = 0 ;
10107
10108 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10109 {
10110 PyThreadState* __tstate = wxPyBeginAllowThreads();
10111 result = (wxPlatformInfo *)new wxPlatformInfo();
10112 wxPyEndAllowThreads(__tstate);
10113 if (PyErr_Occurred()) SWIG_fail;
10114 }
10115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10116 return resultobj;
10117 fail:
10118 return NULL;
10119 }
10120
10121
10122 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10123 PyObject *resultobj = 0;
10124 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10125 wxPlatformInfo *arg2 = 0 ;
10126 bool result;
10127 void *argp1 = 0 ;
10128 int res1 = 0 ;
10129 void *argp2 = 0 ;
10130 int res2 = 0 ;
10131 PyObject * obj0 = 0 ;
10132 PyObject * obj1 = 0 ;
10133 char * kwnames[] = {
10134 (char *) "self",(char *) "t", NULL
10135 };
10136
10137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10139 if (!SWIG_IsOK(res1)) {
10140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10141 }
10142 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10143 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10144 if (!SWIG_IsOK(res2)) {
10145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10146 }
10147 if (!argp2) {
10148 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10149 }
10150 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10151 {
10152 PyThreadState* __tstate = wxPyBeginAllowThreads();
10153 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10154 wxPyEndAllowThreads(__tstate);
10155 if (PyErr_Occurred()) SWIG_fail;
10156 }
10157 {
10158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10159 }
10160 return resultobj;
10161 fail:
10162 return NULL;
10163 }
10164
10165
10166 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10167 PyObject *resultobj = 0;
10168 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10169 wxPlatformInfo *arg2 = 0 ;
10170 bool result;
10171 void *argp1 = 0 ;
10172 int res1 = 0 ;
10173 void *argp2 = 0 ;
10174 int res2 = 0 ;
10175 PyObject * obj0 = 0 ;
10176 PyObject * obj1 = 0 ;
10177 char * kwnames[] = {
10178 (char *) "self",(char *) "t", NULL
10179 };
10180
10181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10183 if (!SWIG_IsOK(res1)) {
10184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10185 }
10186 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10187 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10188 if (!SWIG_IsOK(res2)) {
10189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10190 }
10191 if (!argp2) {
10192 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10193 }
10194 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10195 {
10196 PyThreadState* __tstate = wxPyBeginAllowThreads();
10197 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10198 wxPyEndAllowThreads(__tstate);
10199 if (PyErr_Occurred()) SWIG_fail;
10200 }
10201 {
10202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10203 }
10204 return resultobj;
10205 fail:
10206 return NULL;
10207 }
10208
10209
10210 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10211 PyObject *resultobj = 0;
10212 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10213 int result;
10214 void *argp1 = 0 ;
10215 int res1 = 0 ;
10216 PyObject *swig_obj[1] ;
10217
10218 if (!args) SWIG_fail;
10219 swig_obj[0] = args;
10220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10221 if (!SWIG_IsOK(res1)) {
10222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10223 }
10224 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10225 {
10226 PyThreadState* __tstate = wxPyBeginAllowThreads();
10227 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10228 wxPyEndAllowThreads(__tstate);
10229 if (PyErr_Occurred()) SWIG_fail;
10230 }
10231 resultobj = SWIG_From_int(static_cast< int >(result));
10232 return resultobj;
10233 fail:
10234 return NULL;
10235 }
10236
10237
10238 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10239 PyObject *resultobj = 0;
10240 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10241 int result;
10242 void *argp1 = 0 ;
10243 int res1 = 0 ;
10244 PyObject *swig_obj[1] ;
10245
10246 if (!args) SWIG_fail;
10247 swig_obj[0] = args;
10248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10249 if (!SWIG_IsOK(res1)) {
10250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10251 }
10252 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10253 {
10254 PyThreadState* __tstate = wxPyBeginAllowThreads();
10255 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10256 wxPyEndAllowThreads(__tstate);
10257 if (PyErr_Occurred()) SWIG_fail;
10258 }
10259 resultobj = SWIG_From_int(static_cast< int >(result));
10260 return resultobj;
10261 fail:
10262 return NULL;
10263 }
10264
10265
10266 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10267 PyObject *resultobj = 0;
10268 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10269 int result;
10270 void *argp1 = 0 ;
10271 int res1 = 0 ;
10272 PyObject *swig_obj[1] ;
10273
10274 if (!args) SWIG_fail;
10275 swig_obj[0] = args;
10276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10277 if (!SWIG_IsOK(res1)) {
10278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10279 }
10280 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10281 {
10282 PyThreadState* __tstate = wxPyBeginAllowThreads();
10283 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10284 wxPyEndAllowThreads(__tstate);
10285 if (PyErr_Occurred()) SWIG_fail;
10286 }
10287 resultobj = SWIG_From_int(static_cast< int >(result));
10288 return resultobj;
10289 fail:
10290 return NULL;
10291 }
10292
10293
10294 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10295 PyObject *resultobj = 0;
10296 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10297 int result;
10298 void *argp1 = 0 ;
10299 int res1 = 0 ;
10300 PyObject *swig_obj[1] ;
10301
10302 if (!args) SWIG_fail;
10303 swig_obj[0] = args;
10304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10305 if (!SWIG_IsOK(res1)) {
10306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10307 }
10308 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10309 {
10310 PyThreadState* __tstate = wxPyBeginAllowThreads();
10311 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10312 wxPyEndAllowThreads(__tstate);
10313 if (PyErr_Occurred()) SWIG_fail;
10314 }
10315 resultobj = SWIG_From_int(static_cast< int >(result));
10316 return resultobj;
10317 fail:
10318 return NULL;
10319 }
10320
10321
10322 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10323 PyObject *resultobj = 0;
10324 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10325 bool result;
10326 void *argp1 = 0 ;
10327 int res1 = 0 ;
10328 PyObject *swig_obj[1] ;
10329
10330 if (!args) SWIG_fail;
10331 swig_obj[0] = args;
10332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10333 if (!SWIG_IsOK(res1)) {
10334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10335 }
10336 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10337 {
10338 PyThreadState* __tstate = wxPyBeginAllowThreads();
10339 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10340 wxPyEndAllowThreads(__tstate);
10341 if (PyErr_Occurred()) SWIG_fail;
10342 }
10343 {
10344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10345 }
10346 return resultobj;
10347 fail:
10348 return NULL;
10349 }
10350
10351
10352 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10353 PyObject *resultobj = 0;
10354 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10355 wxOperatingSystemId result;
10356 void *argp1 = 0 ;
10357 int res1 = 0 ;
10358 PyObject *swig_obj[1] ;
10359
10360 if (!args) SWIG_fail;
10361 swig_obj[0] = args;
10362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10363 if (!SWIG_IsOK(res1)) {
10364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10365 }
10366 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10367 {
10368 PyThreadState* __tstate = wxPyBeginAllowThreads();
10369 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10370 wxPyEndAllowThreads(__tstate);
10371 if (PyErr_Occurred()) SWIG_fail;
10372 }
10373 resultobj = SWIG_From_int(static_cast< int >(result));
10374 return resultobj;
10375 fail:
10376 return NULL;
10377 }
10378
10379
10380 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10381 PyObject *resultobj = 0;
10382 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10383 wxPortId result;
10384 void *argp1 = 0 ;
10385 int res1 = 0 ;
10386 PyObject *swig_obj[1] ;
10387
10388 if (!args) SWIG_fail;
10389 swig_obj[0] = args;
10390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10391 if (!SWIG_IsOK(res1)) {
10392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10393 }
10394 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10395 {
10396 PyThreadState* __tstate = wxPyBeginAllowThreads();
10397 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10398 wxPyEndAllowThreads(__tstate);
10399 if (PyErr_Occurred()) SWIG_fail;
10400 }
10401 resultobj = SWIG_From_int(static_cast< int >(result));
10402 return resultobj;
10403 fail:
10404 return NULL;
10405 }
10406
10407
10408 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10409 PyObject *resultobj = 0;
10410 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10411 wxArchitecture result;
10412 void *argp1 = 0 ;
10413 int res1 = 0 ;
10414 PyObject *swig_obj[1] ;
10415
10416 if (!args) SWIG_fail;
10417 swig_obj[0] = args;
10418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10419 if (!SWIG_IsOK(res1)) {
10420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10421 }
10422 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10423 {
10424 PyThreadState* __tstate = wxPyBeginAllowThreads();
10425 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10426 wxPyEndAllowThreads(__tstate);
10427 if (PyErr_Occurred()) SWIG_fail;
10428 }
10429 resultobj = SWIG_From_int(static_cast< int >(result));
10430 return resultobj;
10431 fail:
10432 return NULL;
10433 }
10434
10435
10436 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10437 PyObject *resultobj = 0;
10438 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10439 wxEndianness result;
10440 void *argp1 = 0 ;
10441 int res1 = 0 ;
10442 PyObject *swig_obj[1] ;
10443
10444 if (!args) SWIG_fail;
10445 swig_obj[0] = args;
10446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10447 if (!SWIG_IsOK(res1)) {
10448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10449 }
10450 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10451 {
10452 PyThreadState* __tstate = wxPyBeginAllowThreads();
10453 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10454 wxPyEndAllowThreads(__tstate);
10455 if (PyErr_Occurred()) SWIG_fail;
10456 }
10457 resultobj = SWIG_From_int(static_cast< int >(result));
10458 return resultobj;
10459 fail:
10460 return NULL;
10461 }
10462
10463
10464 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10465 PyObject *resultobj = 0;
10466 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10467 wxString result;
10468 void *argp1 = 0 ;
10469 int res1 = 0 ;
10470 PyObject *swig_obj[1] ;
10471
10472 if (!args) SWIG_fail;
10473 swig_obj[0] = args;
10474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10475 if (!SWIG_IsOK(res1)) {
10476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10477 }
10478 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10479 {
10480 PyThreadState* __tstate = wxPyBeginAllowThreads();
10481 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10482 wxPyEndAllowThreads(__tstate);
10483 if (PyErr_Occurred()) SWIG_fail;
10484 }
10485 {
10486 #if wxUSE_UNICODE
10487 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10488 #else
10489 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10490 #endif
10491 }
10492 return resultobj;
10493 fail:
10494 return NULL;
10495 }
10496
10497
10498 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10499 PyObject *resultobj = 0;
10500 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10501 wxString result;
10502 void *argp1 = 0 ;
10503 int res1 = 0 ;
10504 PyObject *swig_obj[1] ;
10505
10506 if (!args) SWIG_fail;
10507 swig_obj[0] = args;
10508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10509 if (!SWIG_IsOK(res1)) {
10510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10511 }
10512 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10513 {
10514 PyThreadState* __tstate = wxPyBeginAllowThreads();
10515 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10516 wxPyEndAllowThreads(__tstate);
10517 if (PyErr_Occurred()) SWIG_fail;
10518 }
10519 {
10520 #if wxUSE_UNICODE
10521 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10522 #else
10523 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10524 #endif
10525 }
10526 return resultobj;
10527 fail:
10528 return NULL;
10529 }
10530
10531
10532 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10533 PyObject *resultobj = 0;
10534 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10535 wxString result;
10536 void *argp1 = 0 ;
10537 int res1 = 0 ;
10538 PyObject *swig_obj[1] ;
10539
10540 if (!args) SWIG_fail;
10541 swig_obj[0] = args;
10542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10543 if (!SWIG_IsOK(res1)) {
10544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10545 }
10546 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10547 {
10548 PyThreadState* __tstate = wxPyBeginAllowThreads();
10549 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10550 wxPyEndAllowThreads(__tstate);
10551 if (PyErr_Occurred()) SWIG_fail;
10552 }
10553 {
10554 #if wxUSE_UNICODE
10555 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10556 #else
10557 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10558 #endif
10559 }
10560 return resultobj;
10561 fail:
10562 return NULL;
10563 }
10564
10565
10566 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10567 PyObject *resultobj = 0;
10568 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10569 wxString result;
10570 void *argp1 = 0 ;
10571 int res1 = 0 ;
10572 PyObject *swig_obj[1] ;
10573
10574 if (!args) SWIG_fail;
10575 swig_obj[0] = args;
10576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10577 if (!SWIG_IsOK(res1)) {
10578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10579 }
10580 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10581 {
10582 PyThreadState* __tstate = wxPyBeginAllowThreads();
10583 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10584 wxPyEndAllowThreads(__tstate);
10585 if (PyErr_Occurred()) SWIG_fail;
10586 }
10587 {
10588 #if wxUSE_UNICODE
10589 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10590 #else
10591 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10592 #endif
10593 }
10594 return resultobj;
10595 fail:
10596 return NULL;
10597 }
10598
10599
10600 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10601 PyObject *resultobj = 0;
10602 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10603 wxString result;
10604 void *argp1 = 0 ;
10605 int res1 = 0 ;
10606 PyObject *swig_obj[1] ;
10607
10608 if (!args) SWIG_fail;
10609 swig_obj[0] = args;
10610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10611 if (!SWIG_IsOK(res1)) {
10612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10613 }
10614 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10615 {
10616 PyThreadState* __tstate = wxPyBeginAllowThreads();
10617 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10618 wxPyEndAllowThreads(__tstate);
10619 if (PyErr_Occurred()) SWIG_fail;
10620 }
10621 {
10622 #if wxUSE_UNICODE
10623 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10624 #else
10625 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10626 #endif
10627 }
10628 return resultobj;
10629 fail:
10630 return NULL;
10631 }
10632
10633
10634 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10635 PyObject *resultobj = 0;
10636 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10637 wxString result;
10638 void *argp1 = 0 ;
10639 int res1 = 0 ;
10640 PyObject *swig_obj[1] ;
10641
10642 if (!args) SWIG_fail;
10643 swig_obj[0] = args;
10644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10645 if (!SWIG_IsOK(res1)) {
10646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10647 }
10648 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10649 {
10650 PyThreadState* __tstate = wxPyBeginAllowThreads();
10651 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10652 wxPyEndAllowThreads(__tstate);
10653 if (PyErr_Occurred()) SWIG_fail;
10654 }
10655 {
10656 #if wxUSE_UNICODE
10657 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10658 #else
10659 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10660 #endif
10661 }
10662 return resultobj;
10663 fail:
10664 return NULL;
10665 }
10666
10667
10668 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10669 PyObject *resultobj = 0;
10670 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10671 int arg2 ;
10672 int arg3 ;
10673 void *argp1 = 0 ;
10674 int res1 = 0 ;
10675 int val2 ;
10676 int ecode2 = 0 ;
10677 int val3 ;
10678 int ecode3 = 0 ;
10679 PyObject * obj0 = 0 ;
10680 PyObject * obj1 = 0 ;
10681 PyObject * obj2 = 0 ;
10682 char * kwnames[] = {
10683 (char *) "self",(char *) "major",(char *) "minor", NULL
10684 };
10685
10686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10688 if (!SWIG_IsOK(res1)) {
10689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10690 }
10691 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10692 ecode2 = SWIG_AsVal_int(obj1, &val2);
10693 if (!SWIG_IsOK(ecode2)) {
10694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10695 }
10696 arg2 = static_cast< int >(val2);
10697 ecode3 = SWIG_AsVal_int(obj2, &val3);
10698 if (!SWIG_IsOK(ecode3)) {
10699 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10700 }
10701 arg3 = static_cast< int >(val3);
10702 {
10703 PyThreadState* __tstate = wxPyBeginAllowThreads();
10704 (arg1)->SetOSVersion(arg2,arg3);
10705 wxPyEndAllowThreads(__tstate);
10706 if (PyErr_Occurred()) SWIG_fail;
10707 }
10708 resultobj = SWIG_Py_Void();
10709 return resultobj;
10710 fail:
10711 return NULL;
10712 }
10713
10714
10715 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10716 PyObject *resultobj = 0;
10717 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10718 int arg2 ;
10719 int arg3 ;
10720 void *argp1 = 0 ;
10721 int res1 = 0 ;
10722 int val2 ;
10723 int ecode2 = 0 ;
10724 int val3 ;
10725 int ecode3 = 0 ;
10726 PyObject * obj0 = 0 ;
10727 PyObject * obj1 = 0 ;
10728 PyObject * obj2 = 0 ;
10729 char * kwnames[] = {
10730 (char *) "self",(char *) "major",(char *) "minor", NULL
10731 };
10732
10733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10735 if (!SWIG_IsOK(res1)) {
10736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10737 }
10738 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10739 ecode2 = SWIG_AsVal_int(obj1, &val2);
10740 if (!SWIG_IsOK(ecode2)) {
10741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10742 }
10743 arg2 = static_cast< int >(val2);
10744 ecode3 = SWIG_AsVal_int(obj2, &val3);
10745 if (!SWIG_IsOK(ecode3)) {
10746 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10747 }
10748 arg3 = static_cast< int >(val3);
10749 {
10750 PyThreadState* __tstate = wxPyBeginAllowThreads();
10751 (arg1)->SetToolkitVersion(arg2,arg3);
10752 wxPyEndAllowThreads(__tstate);
10753 if (PyErr_Occurred()) SWIG_fail;
10754 }
10755 resultobj = SWIG_Py_Void();
10756 return resultobj;
10757 fail:
10758 return NULL;
10759 }
10760
10761
10762 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10763 PyObject *resultobj = 0;
10764 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10765 wxOperatingSystemId arg2 ;
10766 void *argp1 = 0 ;
10767 int res1 = 0 ;
10768 int val2 ;
10769 int ecode2 = 0 ;
10770 PyObject * obj0 = 0 ;
10771 PyObject * obj1 = 0 ;
10772 char * kwnames[] = {
10773 (char *) "self",(char *) "n", NULL
10774 };
10775
10776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10778 if (!SWIG_IsOK(res1)) {
10779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10780 }
10781 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10782 ecode2 = SWIG_AsVal_int(obj1, &val2);
10783 if (!SWIG_IsOK(ecode2)) {
10784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10785 }
10786 arg2 = static_cast< wxOperatingSystemId >(val2);
10787 {
10788 PyThreadState* __tstate = wxPyBeginAllowThreads();
10789 (arg1)->SetOperatingSystemId(arg2);
10790 wxPyEndAllowThreads(__tstate);
10791 if (PyErr_Occurred()) SWIG_fail;
10792 }
10793 resultobj = SWIG_Py_Void();
10794 return resultobj;
10795 fail:
10796 return NULL;
10797 }
10798
10799
10800 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10801 PyObject *resultobj = 0;
10802 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10803 wxPortId arg2 ;
10804 void *argp1 = 0 ;
10805 int res1 = 0 ;
10806 int val2 ;
10807 int ecode2 = 0 ;
10808 PyObject * obj0 = 0 ;
10809 PyObject * obj1 = 0 ;
10810 char * kwnames[] = {
10811 (char *) "self",(char *) "n", NULL
10812 };
10813
10814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10816 if (!SWIG_IsOK(res1)) {
10817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10818 }
10819 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10820 ecode2 = SWIG_AsVal_int(obj1, &val2);
10821 if (!SWIG_IsOK(ecode2)) {
10822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10823 }
10824 arg2 = static_cast< wxPortId >(val2);
10825 {
10826 PyThreadState* __tstate = wxPyBeginAllowThreads();
10827 (arg1)->SetPortId(arg2);
10828 wxPyEndAllowThreads(__tstate);
10829 if (PyErr_Occurred()) SWIG_fail;
10830 }
10831 resultobj = SWIG_Py_Void();
10832 return resultobj;
10833 fail:
10834 return NULL;
10835 }
10836
10837
10838 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10839 PyObject *resultobj = 0;
10840 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10841 wxArchitecture arg2 ;
10842 void *argp1 = 0 ;
10843 int res1 = 0 ;
10844 int val2 ;
10845 int ecode2 = 0 ;
10846 PyObject * obj0 = 0 ;
10847 PyObject * obj1 = 0 ;
10848 char * kwnames[] = {
10849 (char *) "self",(char *) "n", NULL
10850 };
10851
10852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
10853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10854 if (!SWIG_IsOK(res1)) {
10855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10856 }
10857 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10858 ecode2 = SWIG_AsVal_int(obj1, &val2);
10859 if (!SWIG_IsOK(ecode2)) {
10860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
10861 }
10862 arg2 = static_cast< wxArchitecture >(val2);
10863 {
10864 PyThreadState* __tstate = wxPyBeginAllowThreads();
10865 (arg1)->SetArchitecture(arg2);
10866 wxPyEndAllowThreads(__tstate);
10867 if (PyErr_Occurred()) SWIG_fail;
10868 }
10869 resultobj = SWIG_Py_Void();
10870 return resultobj;
10871 fail:
10872 return NULL;
10873 }
10874
10875
10876 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10877 PyObject *resultobj = 0;
10878 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10879 wxEndianness arg2 ;
10880 void *argp1 = 0 ;
10881 int res1 = 0 ;
10882 int val2 ;
10883 int ecode2 = 0 ;
10884 PyObject * obj0 = 0 ;
10885 PyObject * obj1 = 0 ;
10886 char * kwnames[] = {
10887 (char *) "self",(char *) "n", NULL
10888 };
10889
10890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
10891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10892 if (!SWIG_IsOK(res1)) {
10893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10894 }
10895 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10896 ecode2 = SWIG_AsVal_int(obj1, &val2);
10897 if (!SWIG_IsOK(ecode2)) {
10898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
10899 }
10900 arg2 = static_cast< wxEndianness >(val2);
10901 {
10902 PyThreadState* __tstate = wxPyBeginAllowThreads();
10903 (arg1)->SetEndianness(arg2);
10904 wxPyEndAllowThreads(__tstate);
10905 if (PyErr_Occurred()) SWIG_fail;
10906 }
10907 resultobj = SWIG_Py_Void();
10908 return resultobj;
10909 fail:
10910 return NULL;
10911 }
10912
10913
10914 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10915 PyObject *resultobj = 0;
10916 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10917 bool result;
10918 void *argp1 = 0 ;
10919 int res1 = 0 ;
10920 PyObject *swig_obj[1] ;
10921
10922 if (!args) SWIG_fail;
10923 swig_obj[0] = args;
10924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10925 if (!SWIG_IsOK(res1)) {
10926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10927 }
10928 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10929 {
10930 PyThreadState* __tstate = wxPyBeginAllowThreads();
10931 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
10932 wxPyEndAllowThreads(__tstate);
10933 if (PyErr_Occurred()) SWIG_fail;
10934 }
10935 {
10936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10937 }
10938 return resultobj;
10939 fail:
10940 return NULL;
10941 }
10942
10943
10944 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10945 PyObject *obj;
10946 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10947 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
10948 return SWIG_Py_Void();
10949 }
10950
10951 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10952 return SWIG_Python_InitShadowInstance(args);
10953 }
10954
10955 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10956 PyObject *resultobj = 0;
10957 wxWindow *arg1 = (wxWindow *) 0 ;
10958 wxDC *arg2 = 0 ;
10959 bool result;
10960 void *argp1 = 0 ;
10961 int res1 = 0 ;
10962 void *argp2 = 0 ;
10963 int res2 = 0 ;
10964 PyObject * obj0 = 0 ;
10965 PyObject * obj1 = 0 ;
10966 char * kwnames[] = {
10967 (char *) "window",(char *) "dc", NULL
10968 };
10969
10970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
10971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10972 if (!SWIG_IsOK(res1)) {
10973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
10974 }
10975 arg1 = reinterpret_cast< wxWindow * >(argp1);
10976 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
10977 if (!SWIG_IsOK(res2)) {
10978 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10979 }
10980 if (!argp2) {
10981 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10982 }
10983 arg2 = reinterpret_cast< wxDC * >(argp2);
10984 {
10985 PyThreadState* __tstate = wxPyBeginAllowThreads();
10986 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
10987 wxPyEndAllowThreads(__tstate);
10988 if (PyErr_Occurred()) SWIG_fail;
10989 }
10990 {
10991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10992 }
10993 return resultobj;
10994 fail:
10995 return NULL;
10996 }
10997
10998
10999 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11000 PyObject *resultobj = 0;
11001 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11002 void *argp1 = 0 ;
11003 int res1 = 0 ;
11004 PyObject *swig_obj[1] ;
11005
11006 if (!args) SWIG_fail;
11007 swig_obj[0] = args;
11008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11009 if (!SWIG_IsOK(res1)) {
11010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11011 }
11012 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11013 {
11014 PyThreadState* __tstate = wxPyBeginAllowThreads();
11015 delete arg1;
11016
11017 wxPyEndAllowThreads(__tstate);
11018 if (PyErr_Occurred()) SWIG_fail;
11019 }
11020 resultobj = SWIG_Py_Void();
11021 return resultobj;
11022 fail:
11023 return NULL;
11024 }
11025
11026
11027 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11028 PyObject *resultobj = 0;
11029 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11030 wxString result;
11031 void *argp1 = 0 ;
11032 int res1 = 0 ;
11033 PyObject *swig_obj[1] ;
11034
11035 if (!args) SWIG_fail;
11036 swig_obj[0] = args;
11037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11038 if (!SWIG_IsOK(res1)) {
11039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11040 }
11041 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11042 {
11043 PyThreadState* __tstate = wxPyBeginAllowThreads();
11044 result = (arg1)->GetTip();
11045 wxPyEndAllowThreads(__tstate);
11046 if (PyErr_Occurred()) SWIG_fail;
11047 }
11048 {
11049 #if wxUSE_UNICODE
11050 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11051 #else
11052 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11053 #endif
11054 }
11055 return resultobj;
11056 fail:
11057 return NULL;
11058 }
11059
11060
11061 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11062 PyObject *resultobj = 0;
11063 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11064 size_t result;
11065 void *argp1 = 0 ;
11066 int res1 = 0 ;
11067 PyObject *swig_obj[1] ;
11068
11069 if (!args) SWIG_fail;
11070 swig_obj[0] = args;
11071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11072 if (!SWIG_IsOK(res1)) {
11073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11074 }
11075 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11076 {
11077 PyThreadState* __tstate = wxPyBeginAllowThreads();
11078 result = (size_t)(arg1)->GetCurrentTip();
11079 wxPyEndAllowThreads(__tstate);
11080 if (PyErr_Occurred()) SWIG_fail;
11081 }
11082 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11083 return resultobj;
11084 fail:
11085 return NULL;
11086 }
11087
11088
11089 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11090 PyObject *resultobj = 0;
11091 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11092 wxString *arg2 = 0 ;
11093 wxString result;
11094 void *argp1 = 0 ;
11095 int res1 = 0 ;
11096 bool temp2 = false ;
11097 PyObject * obj0 = 0 ;
11098 PyObject * obj1 = 0 ;
11099 char * kwnames[] = {
11100 (char *) "self",(char *) "tip", NULL
11101 };
11102
11103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11105 if (!SWIG_IsOK(res1)) {
11106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11107 }
11108 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11109 {
11110 arg2 = wxString_in_helper(obj1);
11111 if (arg2 == NULL) SWIG_fail;
11112 temp2 = true;
11113 }
11114 {
11115 PyThreadState* __tstate = wxPyBeginAllowThreads();
11116 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11117 wxPyEndAllowThreads(__tstate);
11118 if (PyErr_Occurred()) SWIG_fail;
11119 }
11120 {
11121 #if wxUSE_UNICODE
11122 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11123 #else
11124 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11125 #endif
11126 }
11127 {
11128 if (temp2)
11129 delete arg2;
11130 }
11131 return resultobj;
11132 fail:
11133 {
11134 if (temp2)
11135 delete arg2;
11136 }
11137 return NULL;
11138 }
11139
11140
11141 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11142 PyObject *obj;
11143 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11144 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11145 return SWIG_Py_Void();
11146 }
11147
11148 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11149 PyObject *resultobj = 0;
11150 size_t arg1 ;
11151 wxPyTipProvider *result = 0 ;
11152 size_t val1 ;
11153 int ecode1 = 0 ;
11154 PyObject * obj0 = 0 ;
11155 char * kwnames[] = {
11156 (char *) "currentTip", NULL
11157 };
11158
11159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11160 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11161 if (!SWIG_IsOK(ecode1)) {
11162 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11163 }
11164 arg1 = static_cast< size_t >(val1);
11165 {
11166 PyThreadState* __tstate = wxPyBeginAllowThreads();
11167 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11168 wxPyEndAllowThreads(__tstate);
11169 if (PyErr_Occurred()) SWIG_fail;
11170 }
11171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11172 return resultobj;
11173 fail:
11174 return NULL;
11175 }
11176
11177
11178 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11179 PyObject *resultobj = 0;
11180 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11181 PyObject *arg2 = (PyObject *) 0 ;
11182 PyObject *arg3 = (PyObject *) 0 ;
11183 void *argp1 = 0 ;
11184 int res1 = 0 ;
11185 PyObject * obj0 = 0 ;
11186 PyObject * obj1 = 0 ;
11187 PyObject * obj2 = 0 ;
11188 char * kwnames[] = {
11189 (char *) "self",(char *) "self",(char *) "_class", NULL
11190 };
11191
11192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11194 if (!SWIG_IsOK(res1)) {
11195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11196 }
11197 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11198 arg2 = obj1;
11199 arg3 = obj2;
11200 {
11201 PyThreadState* __tstate = wxPyBeginAllowThreads();
11202 (arg1)->_setCallbackInfo(arg2,arg3);
11203 wxPyEndAllowThreads(__tstate);
11204 if (PyErr_Occurred()) SWIG_fail;
11205 }
11206 resultobj = SWIG_Py_Void();
11207 return resultobj;
11208 fail:
11209 return NULL;
11210 }
11211
11212
11213 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11214 PyObject *obj;
11215 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11216 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11217 return SWIG_Py_Void();
11218 }
11219
11220 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11221 return SWIG_Python_InitShadowInstance(args);
11222 }
11223
11224 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11225 PyObject *resultobj = 0;
11226 wxWindow *arg1 = (wxWindow *) 0 ;
11227 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11228 bool arg3 = (bool) true ;
11229 bool result;
11230 void *argp1 = 0 ;
11231 int res1 = 0 ;
11232 void *argp2 = 0 ;
11233 int res2 = 0 ;
11234 bool val3 ;
11235 int ecode3 = 0 ;
11236 PyObject * obj0 = 0 ;
11237 PyObject * obj1 = 0 ;
11238 PyObject * obj2 = 0 ;
11239 char * kwnames[] = {
11240 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11241 };
11242
11243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11245 if (!SWIG_IsOK(res1)) {
11246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11247 }
11248 arg1 = reinterpret_cast< wxWindow * >(argp1);
11249 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11250 if (!SWIG_IsOK(res2)) {
11251 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11252 }
11253 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11254 if (obj2) {
11255 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11256 if (!SWIG_IsOK(ecode3)) {
11257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11258 }
11259 arg3 = static_cast< bool >(val3);
11260 }
11261 {
11262 if (!wxPyCheckForApp()) SWIG_fail;
11263 PyThreadState* __tstate = wxPyBeginAllowThreads();
11264 result = (bool)wxShowTip(arg1,arg2,arg3);
11265 wxPyEndAllowThreads(__tstate);
11266 if (PyErr_Occurred()) SWIG_fail;
11267 }
11268 {
11269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11270 }
11271 return resultobj;
11272 fail:
11273 return NULL;
11274 }
11275
11276
11277 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11278 PyObject *resultobj = 0;
11279 wxString *arg1 = 0 ;
11280 size_t arg2 ;
11281 wxTipProvider *result = 0 ;
11282 bool temp1 = false ;
11283 size_t val2 ;
11284 int ecode2 = 0 ;
11285 PyObject * obj0 = 0 ;
11286 PyObject * obj1 = 0 ;
11287 char * kwnames[] = {
11288 (char *) "filename",(char *) "currentTip", NULL
11289 };
11290
11291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11292 {
11293 arg1 = wxString_in_helper(obj0);
11294 if (arg1 == NULL) SWIG_fail;
11295 temp1 = true;
11296 }
11297 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11298 if (!SWIG_IsOK(ecode2)) {
11299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11300 }
11301 arg2 = static_cast< size_t >(val2);
11302 {
11303 if (!wxPyCheckForApp()) SWIG_fail;
11304 PyThreadState* __tstate = wxPyBeginAllowThreads();
11305 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11306 wxPyEndAllowThreads(__tstate);
11307 if (PyErr_Occurred()) SWIG_fail;
11308 }
11309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11310 {
11311 if (temp1)
11312 delete arg1;
11313 }
11314 return resultobj;
11315 fail:
11316 {
11317 if (temp1)
11318 delete arg1;
11319 }
11320 return NULL;
11321 }
11322
11323
11324 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11325 PyObject *resultobj = 0;
11326 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11327 int arg2 = (int) wxID_ANY ;
11328 wxPyTimer *result = 0 ;
11329 void *argp1 = 0 ;
11330 int res1 = 0 ;
11331 int val2 ;
11332 int ecode2 = 0 ;
11333 PyObject * obj0 = 0 ;
11334 PyObject * obj1 = 0 ;
11335 char * kwnames[] = {
11336 (char *) "owner",(char *) "id", NULL
11337 };
11338
11339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11340 if (obj0) {
11341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11342 if (!SWIG_IsOK(res1)) {
11343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11344 }
11345 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11346 }
11347 if (obj1) {
11348 ecode2 = SWIG_AsVal_int(obj1, &val2);
11349 if (!SWIG_IsOK(ecode2)) {
11350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11351 }
11352 arg2 = static_cast< int >(val2);
11353 }
11354 {
11355 if (!wxPyCheckForApp()) SWIG_fail;
11356 PyThreadState* __tstate = wxPyBeginAllowThreads();
11357 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11358 wxPyEndAllowThreads(__tstate);
11359 if (PyErr_Occurred()) SWIG_fail;
11360 }
11361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11362 return resultobj;
11363 fail:
11364 return NULL;
11365 }
11366
11367
11368 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11369 PyObject *resultobj = 0;
11370 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11371 void *argp1 = 0 ;
11372 int res1 = 0 ;
11373 PyObject *swig_obj[1] ;
11374
11375 if (!args) SWIG_fail;
11376 swig_obj[0] = args;
11377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11378 if (!SWIG_IsOK(res1)) {
11379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11380 }
11381 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11382 {
11383 PyThreadState* __tstate = wxPyBeginAllowThreads();
11384 delete arg1;
11385
11386 wxPyEndAllowThreads(__tstate);
11387 if (PyErr_Occurred()) SWIG_fail;
11388 }
11389 resultobj = SWIG_Py_Void();
11390 return resultobj;
11391 fail:
11392 return NULL;
11393 }
11394
11395
11396 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11397 PyObject *resultobj = 0;
11398 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11399 PyObject *arg2 = (PyObject *) 0 ;
11400 PyObject *arg3 = (PyObject *) 0 ;
11401 int arg4 = (int) 1 ;
11402 void *argp1 = 0 ;
11403 int res1 = 0 ;
11404 int val4 ;
11405 int ecode4 = 0 ;
11406 PyObject * obj0 = 0 ;
11407 PyObject * obj1 = 0 ;
11408 PyObject * obj2 = 0 ;
11409 PyObject * obj3 = 0 ;
11410 char * kwnames[] = {
11411 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11412 };
11413
11414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11416 if (!SWIG_IsOK(res1)) {
11417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11418 }
11419 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11420 arg2 = obj1;
11421 arg3 = obj2;
11422 if (obj3) {
11423 ecode4 = SWIG_AsVal_int(obj3, &val4);
11424 if (!SWIG_IsOK(ecode4)) {
11425 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11426 }
11427 arg4 = static_cast< int >(val4);
11428 }
11429 {
11430 PyThreadState* __tstate = wxPyBeginAllowThreads();
11431 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11432 wxPyEndAllowThreads(__tstate);
11433 if (PyErr_Occurred()) SWIG_fail;
11434 }
11435 resultobj = SWIG_Py_Void();
11436 return resultobj;
11437 fail:
11438 return NULL;
11439 }
11440
11441
11442 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11443 PyObject *resultobj = 0;
11444 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11445 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11446 int arg3 = (int) wxID_ANY ;
11447 void *argp1 = 0 ;
11448 int res1 = 0 ;
11449 void *argp2 = 0 ;
11450 int res2 = 0 ;
11451 int val3 ;
11452 int ecode3 = 0 ;
11453 PyObject * obj0 = 0 ;
11454 PyObject * obj1 = 0 ;
11455 PyObject * obj2 = 0 ;
11456 char * kwnames[] = {
11457 (char *) "self",(char *) "owner",(char *) "id", NULL
11458 };
11459
11460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11462 if (!SWIG_IsOK(res1)) {
11463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11464 }
11465 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11466 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11467 if (!SWIG_IsOK(res2)) {
11468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11469 }
11470 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11471 if (obj2) {
11472 ecode3 = SWIG_AsVal_int(obj2, &val3);
11473 if (!SWIG_IsOK(ecode3)) {
11474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11475 }
11476 arg3 = static_cast< int >(val3);
11477 }
11478 {
11479 PyThreadState* __tstate = wxPyBeginAllowThreads();
11480 (arg1)->SetOwner(arg2,arg3);
11481 wxPyEndAllowThreads(__tstate);
11482 if (PyErr_Occurred()) SWIG_fail;
11483 }
11484 resultobj = SWIG_Py_Void();
11485 return resultobj;
11486 fail:
11487 return NULL;
11488 }
11489
11490
11491 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11492 PyObject *resultobj = 0;
11493 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11494 wxEvtHandler *result = 0 ;
11495 void *argp1 = 0 ;
11496 int res1 = 0 ;
11497 PyObject *swig_obj[1] ;
11498
11499 if (!args) SWIG_fail;
11500 swig_obj[0] = args;
11501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11502 if (!SWIG_IsOK(res1)) {
11503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11504 }
11505 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11506 {
11507 PyThreadState* __tstate = wxPyBeginAllowThreads();
11508 result = (wxEvtHandler *)(arg1)->GetOwner();
11509 wxPyEndAllowThreads(__tstate);
11510 if (PyErr_Occurred()) SWIG_fail;
11511 }
11512 {
11513 resultobj = wxPyMake_wxObject(result, 0);
11514 }
11515 return resultobj;
11516 fail:
11517 return NULL;
11518 }
11519
11520
11521 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11522 PyObject *resultobj = 0;
11523 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11524 int arg2 = (int) -1 ;
11525 bool arg3 = (bool) false ;
11526 bool result;
11527 void *argp1 = 0 ;
11528 int res1 = 0 ;
11529 int val2 ;
11530 int ecode2 = 0 ;
11531 bool val3 ;
11532 int ecode3 = 0 ;
11533 PyObject * obj0 = 0 ;
11534 PyObject * obj1 = 0 ;
11535 PyObject * obj2 = 0 ;
11536 char * kwnames[] = {
11537 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11538 };
11539
11540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11542 if (!SWIG_IsOK(res1)) {
11543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11544 }
11545 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11546 if (obj1) {
11547 ecode2 = SWIG_AsVal_int(obj1, &val2);
11548 if (!SWIG_IsOK(ecode2)) {
11549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11550 }
11551 arg2 = static_cast< int >(val2);
11552 }
11553 if (obj2) {
11554 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11555 if (!SWIG_IsOK(ecode3)) {
11556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11557 }
11558 arg3 = static_cast< bool >(val3);
11559 }
11560 {
11561 PyThreadState* __tstate = wxPyBeginAllowThreads();
11562 result = (bool)(arg1)->Start(arg2,arg3);
11563 wxPyEndAllowThreads(__tstate);
11564 if (PyErr_Occurred()) SWIG_fail;
11565 }
11566 {
11567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11568 }
11569 return resultobj;
11570 fail:
11571 return NULL;
11572 }
11573
11574
11575 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11576 PyObject *resultobj = 0;
11577 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11578 void *argp1 = 0 ;
11579 int res1 = 0 ;
11580 PyObject *swig_obj[1] ;
11581
11582 if (!args) SWIG_fail;
11583 swig_obj[0] = args;
11584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11585 if (!SWIG_IsOK(res1)) {
11586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11587 }
11588 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11589 {
11590 PyThreadState* __tstate = wxPyBeginAllowThreads();
11591 (arg1)->Stop();
11592 wxPyEndAllowThreads(__tstate);
11593 if (PyErr_Occurred()) SWIG_fail;
11594 }
11595 resultobj = SWIG_Py_Void();
11596 return resultobj;
11597 fail:
11598 return NULL;
11599 }
11600
11601
11602 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11603 PyObject *resultobj = 0;
11604 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11605 void *argp1 = 0 ;
11606 int res1 = 0 ;
11607 PyObject *swig_obj[1] ;
11608
11609 if (!args) SWIG_fail;
11610 swig_obj[0] = args;
11611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11612 if (!SWIG_IsOK(res1)) {
11613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11614 }
11615 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11616 {
11617 PyThreadState* __tstate = wxPyBeginAllowThreads();
11618 (arg1)->Notify();
11619 wxPyEndAllowThreads(__tstate);
11620 if (PyErr_Occurred()) SWIG_fail;
11621 }
11622 resultobj = SWIG_Py_Void();
11623 return resultobj;
11624 fail:
11625 return NULL;
11626 }
11627
11628
11629 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11630 PyObject *resultobj = 0;
11631 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11632 bool result;
11633 void *argp1 = 0 ;
11634 int res1 = 0 ;
11635 PyObject *swig_obj[1] ;
11636
11637 if (!args) SWIG_fail;
11638 swig_obj[0] = args;
11639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11640 if (!SWIG_IsOK(res1)) {
11641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11642 }
11643 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11644 {
11645 PyThreadState* __tstate = wxPyBeginAllowThreads();
11646 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11647 wxPyEndAllowThreads(__tstate);
11648 if (PyErr_Occurred()) SWIG_fail;
11649 }
11650 {
11651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11652 }
11653 return resultobj;
11654 fail:
11655 return NULL;
11656 }
11657
11658
11659 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11660 PyObject *resultobj = 0;
11661 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11662 int result;
11663 void *argp1 = 0 ;
11664 int res1 = 0 ;
11665 PyObject *swig_obj[1] ;
11666
11667 if (!args) SWIG_fail;
11668 swig_obj[0] = args;
11669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11670 if (!SWIG_IsOK(res1)) {
11671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11672 }
11673 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11674 {
11675 PyThreadState* __tstate = wxPyBeginAllowThreads();
11676 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11677 wxPyEndAllowThreads(__tstate);
11678 if (PyErr_Occurred()) SWIG_fail;
11679 }
11680 resultobj = SWIG_From_int(static_cast< int >(result));
11681 return resultobj;
11682 fail:
11683 return NULL;
11684 }
11685
11686
11687 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11688 PyObject *resultobj = 0;
11689 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11690 int result;
11691 void *argp1 = 0 ;
11692 int res1 = 0 ;
11693 PyObject *swig_obj[1] ;
11694
11695 if (!args) SWIG_fail;
11696 swig_obj[0] = args;
11697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11698 if (!SWIG_IsOK(res1)) {
11699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11700 }
11701 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11702 {
11703 PyThreadState* __tstate = wxPyBeginAllowThreads();
11704 result = (int)((wxPyTimer const *)arg1)->GetId();
11705 wxPyEndAllowThreads(__tstate);
11706 if (PyErr_Occurred()) SWIG_fail;
11707 }
11708 resultobj = SWIG_From_int(static_cast< int >(result));
11709 return resultobj;
11710 fail:
11711 return NULL;
11712 }
11713
11714
11715 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11716 PyObject *resultobj = 0;
11717 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11718 bool result;
11719 void *argp1 = 0 ;
11720 int res1 = 0 ;
11721 PyObject *swig_obj[1] ;
11722
11723 if (!args) SWIG_fail;
11724 swig_obj[0] = args;
11725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11726 if (!SWIG_IsOK(res1)) {
11727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11728 }
11729 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11730 {
11731 PyThreadState* __tstate = wxPyBeginAllowThreads();
11732 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11733 wxPyEndAllowThreads(__tstate);
11734 if (PyErr_Occurred()) SWIG_fail;
11735 }
11736 {
11737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11738 }
11739 return resultobj;
11740 fail:
11741 return NULL;
11742 }
11743
11744
11745 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11746 PyObject *obj;
11747 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11748 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11749 return SWIG_Py_Void();
11750 }
11751
11752 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11753 return SWIG_Python_InitShadowInstance(args);
11754 }
11755
11756 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11757 PyObject *resultobj = 0;
11758 int arg1 = (int) 0 ;
11759 int arg2 = (int) 0 ;
11760 wxTimerEvent *result = 0 ;
11761 int val1 ;
11762 int ecode1 = 0 ;
11763 int val2 ;
11764 int ecode2 = 0 ;
11765 PyObject * obj0 = 0 ;
11766 PyObject * obj1 = 0 ;
11767 char * kwnames[] = {
11768 (char *) "timerid",(char *) "interval", NULL
11769 };
11770
11771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11772 if (obj0) {
11773 ecode1 = SWIG_AsVal_int(obj0, &val1);
11774 if (!SWIG_IsOK(ecode1)) {
11775 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11776 }
11777 arg1 = static_cast< int >(val1);
11778 }
11779 if (obj1) {
11780 ecode2 = SWIG_AsVal_int(obj1, &val2);
11781 if (!SWIG_IsOK(ecode2)) {
11782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11783 }
11784 arg2 = static_cast< int >(val2);
11785 }
11786 {
11787 PyThreadState* __tstate = wxPyBeginAllowThreads();
11788 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11789 wxPyEndAllowThreads(__tstate);
11790 if (PyErr_Occurred()) SWIG_fail;
11791 }
11792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11793 return resultobj;
11794 fail:
11795 return NULL;
11796 }
11797
11798
11799 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11800 PyObject *resultobj = 0;
11801 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11802 int result;
11803 void *argp1 = 0 ;
11804 int res1 = 0 ;
11805 PyObject *swig_obj[1] ;
11806
11807 if (!args) SWIG_fail;
11808 swig_obj[0] = args;
11809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11810 if (!SWIG_IsOK(res1)) {
11811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11812 }
11813 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11814 {
11815 PyThreadState* __tstate = wxPyBeginAllowThreads();
11816 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11817 wxPyEndAllowThreads(__tstate);
11818 if (PyErr_Occurred()) SWIG_fail;
11819 }
11820 resultobj = SWIG_From_int(static_cast< int >(result));
11821 return resultobj;
11822 fail:
11823 return NULL;
11824 }
11825
11826
11827 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11828 PyObject *obj;
11829 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11830 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11831 return SWIG_Py_Void();
11832 }
11833
11834 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11835 return SWIG_Python_InitShadowInstance(args);
11836 }
11837
11838 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11839 PyObject *resultobj = 0;
11840 wxTimer *arg1 = 0 ;
11841 wxTimerRunner *result = 0 ;
11842 void *argp1 = 0 ;
11843 int res1 = 0 ;
11844
11845 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11847 if (!SWIG_IsOK(res1)) {
11848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11849 }
11850 if (!argp1) {
11851 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11852 }
11853 arg1 = reinterpret_cast< wxTimer * >(argp1);
11854 {
11855 if (!wxPyCheckForApp()) SWIG_fail;
11856 PyThreadState* __tstate = wxPyBeginAllowThreads();
11857 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
11858 wxPyEndAllowThreads(__tstate);
11859 if (PyErr_Occurred()) SWIG_fail;
11860 }
11861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
11862 return resultobj;
11863 fail:
11864 return NULL;
11865 }
11866
11867
11868 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11869 PyObject *resultobj = 0;
11870 wxTimer *arg1 = 0 ;
11871 int arg2 ;
11872 bool arg3 = (bool) false ;
11873 wxTimerRunner *result = 0 ;
11874 void *argp1 = 0 ;
11875 int res1 = 0 ;
11876 int val2 ;
11877 int ecode2 = 0 ;
11878 bool val3 ;
11879 int ecode3 = 0 ;
11880
11881 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
11882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11883 if (!SWIG_IsOK(res1)) {
11884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11885 }
11886 if (!argp1) {
11887 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11888 }
11889 arg1 = reinterpret_cast< wxTimer * >(argp1);
11890 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11891 if (!SWIG_IsOK(ecode2)) {
11892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
11893 }
11894 arg2 = static_cast< int >(val2);
11895 if (swig_obj[2]) {
11896 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
11897 if (!SWIG_IsOK(ecode3)) {
11898 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
11899 }
11900 arg3 = static_cast< bool >(val3);
11901 }
11902 {
11903 if (!wxPyCheckForApp()) SWIG_fail;
11904 PyThreadState* __tstate = wxPyBeginAllowThreads();
11905 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
11906 wxPyEndAllowThreads(__tstate);
11907 if (PyErr_Occurred()) SWIG_fail;
11908 }
11909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
11910 return resultobj;
11911 fail:
11912 return NULL;
11913 }
11914
11915
11916 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
11917 int argc;
11918 PyObject *argv[4];
11919
11920 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
11921 --argc;
11922 if (argc == 1) {
11923 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
11924 }
11925 if ((argc >= 2) && (argc <= 3)) {
11926 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
11927 }
11928
11929 fail:
11930 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
11931 return NULL;
11932 }
11933
11934
11935 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11936 PyObject *resultobj = 0;
11937 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11938 void *argp1 = 0 ;
11939 int res1 = 0 ;
11940 PyObject *swig_obj[1] ;
11941
11942 if (!args) SWIG_fail;
11943 swig_obj[0] = args;
11944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
11945 if (!SWIG_IsOK(res1)) {
11946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11947 }
11948 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11949 {
11950 PyThreadState* __tstate = wxPyBeginAllowThreads();
11951 delete arg1;
11952
11953 wxPyEndAllowThreads(__tstate);
11954 if (PyErr_Occurred()) SWIG_fail;
11955 }
11956 resultobj = SWIG_Py_Void();
11957 return resultobj;
11958 fail:
11959 return NULL;
11960 }
11961
11962
11963 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11964 PyObject *resultobj = 0;
11965 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11966 int arg2 ;
11967 bool arg3 = (bool) false ;
11968 void *argp1 = 0 ;
11969 int res1 = 0 ;
11970 int val2 ;
11971 int ecode2 = 0 ;
11972 bool val3 ;
11973 int ecode3 = 0 ;
11974 PyObject * obj0 = 0 ;
11975 PyObject * obj1 = 0 ;
11976 PyObject * obj2 = 0 ;
11977 char * kwnames[] = {
11978 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
11979 };
11980
11981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
11983 if (!SWIG_IsOK(res1)) {
11984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11985 }
11986 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11987 ecode2 = SWIG_AsVal_int(obj1, &val2);
11988 if (!SWIG_IsOK(ecode2)) {
11989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
11990 }
11991 arg2 = static_cast< int >(val2);
11992 if (obj2) {
11993 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11994 if (!SWIG_IsOK(ecode3)) {
11995 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
11996 }
11997 arg3 = static_cast< bool >(val3);
11998 }
11999 {
12000 PyThreadState* __tstate = wxPyBeginAllowThreads();
12001 (arg1)->Start(arg2,arg3);
12002 wxPyEndAllowThreads(__tstate);
12003 if (PyErr_Occurred()) SWIG_fail;
12004 }
12005 resultobj = SWIG_Py_Void();
12006 return resultobj;
12007 fail:
12008 return NULL;
12009 }
12010
12011
12012 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12013 PyObject *obj;
12014 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12015 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12016 return SWIG_Py_Void();
12017 }
12018
12019 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12020 return SWIG_Python_InitShadowInstance(args);
12021 }
12022
12023 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12024 PyObject *resultobj = 0;
12025 wxLog *result = 0 ;
12026
12027 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12028 {
12029 PyThreadState* __tstate = wxPyBeginAllowThreads();
12030 result = (wxLog *)new wxLog();
12031 wxPyEndAllowThreads(__tstate);
12032 if (PyErr_Occurred()) SWIG_fail;
12033 }
12034 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12035 return resultobj;
12036 fail:
12037 return NULL;
12038 }
12039
12040
12041 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12042 PyObject *resultobj = 0;
12043 wxLog *arg1 = (wxLog *) 0 ;
12044 void *argp1 = 0 ;
12045 int res1 = 0 ;
12046 PyObject *swig_obj[1] ;
12047
12048 if (!args) SWIG_fail;
12049 swig_obj[0] = args;
12050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12051 if (!SWIG_IsOK(res1)) {
12052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12053 }
12054 arg1 = reinterpret_cast< wxLog * >(argp1);
12055 {
12056 PyThreadState* __tstate = wxPyBeginAllowThreads();
12057 delete arg1;
12058
12059 wxPyEndAllowThreads(__tstate);
12060 if (PyErr_Occurred()) SWIG_fail;
12061 }
12062 resultobj = SWIG_Py_Void();
12063 return resultobj;
12064 fail:
12065 return NULL;
12066 }
12067
12068
12069 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12070 PyObject *resultobj = 0;
12071 bool result;
12072
12073 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12074 {
12075 PyThreadState* __tstate = wxPyBeginAllowThreads();
12076 result = (bool)wxLog::IsEnabled();
12077 wxPyEndAllowThreads(__tstate);
12078 if (PyErr_Occurred()) SWIG_fail;
12079 }
12080 {
12081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12082 }
12083 return resultobj;
12084 fail:
12085 return NULL;
12086 }
12087
12088
12089 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12090 PyObject *resultobj = 0;
12091 bool arg1 = (bool) true ;
12092 bool result;
12093 bool val1 ;
12094 int ecode1 = 0 ;
12095 PyObject * obj0 = 0 ;
12096 char * kwnames[] = {
12097 (char *) "doIt", NULL
12098 };
12099
12100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12101 if (obj0) {
12102 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12103 if (!SWIG_IsOK(ecode1)) {
12104 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12105 }
12106 arg1 = static_cast< bool >(val1);
12107 }
12108 {
12109 PyThreadState* __tstate = wxPyBeginAllowThreads();
12110 result = (bool)wxLog::EnableLogging(arg1);
12111 wxPyEndAllowThreads(__tstate);
12112 if (PyErr_Occurred()) SWIG_fail;
12113 }
12114 {
12115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12116 }
12117 return resultobj;
12118 fail:
12119 return NULL;
12120 }
12121
12122
12123 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12124 PyObject *resultobj = 0;
12125 wxLogLevel arg1 ;
12126 wxChar *arg2 = (wxChar *) 0 ;
12127 time_t arg3 ;
12128 unsigned long val1 ;
12129 int ecode1 = 0 ;
12130 void *argp2 = 0 ;
12131 int res2 = 0 ;
12132 unsigned int val3 ;
12133 int ecode3 = 0 ;
12134 PyObject * obj0 = 0 ;
12135 PyObject * obj1 = 0 ;
12136 PyObject * obj2 = 0 ;
12137 char * kwnames[] = {
12138 (char *) "level",(char *) "szString",(char *) "t", NULL
12139 };
12140
12141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12142 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12143 if (!SWIG_IsOK(ecode1)) {
12144 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12145 }
12146 arg1 = static_cast< wxLogLevel >(val1);
12147 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12148 if (!SWIG_IsOK(res2)) {
12149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12150 }
12151 arg2 = reinterpret_cast< wxChar * >(argp2);
12152 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12153 if (!SWIG_IsOK(ecode3)) {
12154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12155 }
12156 arg3 = static_cast< time_t >(val3);
12157 {
12158 PyThreadState* __tstate = wxPyBeginAllowThreads();
12159 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12160 wxPyEndAllowThreads(__tstate);
12161 if (PyErr_Occurred()) SWIG_fail;
12162 }
12163 resultobj = SWIG_Py_Void();
12164 return resultobj;
12165 fail:
12166 return NULL;
12167 }
12168
12169
12170 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12171 PyObject *resultobj = 0;
12172 wxLog *arg1 = (wxLog *) 0 ;
12173 void *argp1 = 0 ;
12174 int res1 = 0 ;
12175 PyObject *swig_obj[1] ;
12176
12177 if (!args) SWIG_fail;
12178 swig_obj[0] = args;
12179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12180 if (!SWIG_IsOK(res1)) {
12181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12182 }
12183 arg1 = reinterpret_cast< wxLog * >(argp1);
12184 {
12185 PyThreadState* __tstate = wxPyBeginAllowThreads();
12186 (arg1)->Flush();
12187 wxPyEndAllowThreads(__tstate);
12188 if (PyErr_Occurred()) SWIG_fail;
12189 }
12190 resultobj = SWIG_Py_Void();
12191 return resultobj;
12192 fail:
12193 return NULL;
12194 }
12195
12196
12197 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12198 PyObject *resultobj = 0;
12199
12200 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12201 {
12202 PyThreadState* __tstate = wxPyBeginAllowThreads();
12203 wxLog::FlushActive();
12204 wxPyEndAllowThreads(__tstate);
12205 if (PyErr_Occurred()) SWIG_fail;
12206 }
12207 resultobj = SWIG_Py_Void();
12208 return resultobj;
12209 fail:
12210 return NULL;
12211 }
12212
12213
12214 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12215 PyObject *resultobj = 0;
12216 wxLog *result = 0 ;
12217
12218 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12219 {
12220 PyThreadState* __tstate = wxPyBeginAllowThreads();
12221 result = (wxLog *)wxLog::GetActiveTarget();
12222 wxPyEndAllowThreads(__tstate);
12223 if (PyErr_Occurred()) SWIG_fail;
12224 }
12225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12226 return resultobj;
12227 fail:
12228 return NULL;
12229 }
12230
12231
12232 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12233 PyObject *resultobj = 0;
12234 wxLog *arg1 = (wxLog *) 0 ;
12235 wxLog *result = 0 ;
12236 int res1 = 0 ;
12237 PyObject * obj0 = 0 ;
12238 char * kwnames[] = {
12239 (char *) "pLogger", NULL
12240 };
12241
12242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12243 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12244 if (!SWIG_IsOK(res1)) {
12245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12246 }
12247 {
12248 PyThreadState* __tstate = wxPyBeginAllowThreads();
12249 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12250 wxPyEndAllowThreads(__tstate);
12251 if (PyErr_Occurred()) SWIG_fail;
12252 }
12253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12254 return resultobj;
12255 fail:
12256 return NULL;
12257 }
12258
12259
12260 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12261 PyObject *resultobj = 0;
12262
12263 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12264 {
12265 PyThreadState* __tstate = wxPyBeginAllowThreads();
12266 wxLog::Suspend();
12267 wxPyEndAllowThreads(__tstate);
12268 if (PyErr_Occurred()) SWIG_fail;
12269 }
12270 resultobj = SWIG_Py_Void();
12271 return resultobj;
12272 fail:
12273 return NULL;
12274 }
12275
12276
12277 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12278 PyObject *resultobj = 0;
12279
12280 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12281 {
12282 PyThreadState* __tstate = wxPyBeginAllowThreads();
12283 wxLog::Resume();
12284 wxPyEndAllowThreads(__tstate);
12285 if (PyErr_Occurred()) SWIG_fail;
12286 }
12287 resultobj = SWIG_Py_Void();
12288 return resultobj;
12289 fail:
12290 return NULL;
12291 }
12292
12293
12294 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12295 PyObject *resultobj = 0;
12296 bool arg1 = (bool) true ;
12297 bool val1 ;
12298 int ecode1 = 0 ;
12299 PyObject * obj0 = 0 ;
12300 char * kwnames[] = {
12301 (char *) "bVerbose", NULL
12302 };
12303
12304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12305 if (obj0) {
12306 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12307 if (!SWIG_IsOK(ecode1)) {
12308 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12309 }
12310 arg1 = static_cast< bool >(val1);
12311 }
12312 {
12313 PyThreadState* __tstate = wxPyBeginAllowThreads();
12314 wxLog::SetVerbose(arg1);
12315 wxPyEndAllowThreads(__tstate);
12316 if (PyErr_Occurred()) SWIG_fail;
12317 }
12318 resultobj = SWIG_Py_Void();
12319 return resultobj;
12320 fail:
12321 return NULL;
12322 }
12323
12324
12325 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12326 PyObject *resultobj = 0;
12327 wxLogLevel arg1 ;
12328 unsigned long val1 ;
12329 int ecode1 = 0 ;
12330 PyObject * obj0 = 0 ;
12331 char * kwnames[] = {
12332 (char *) "logLevel", NULL
12333 };
12334
12335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12336 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12337 if (!SWIG_IsOK(ecode1)) {
12338 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12339 }
12340 arg1 = static_cast< wxLogLevel >(val1);
12341 {
12342 PyThreadState* __tstate = wxPyBeginAllowThreads();
12343 wxLog::SetLogLevel(arg1);
12344 wxPyEndAllowThreads(__tstate);
12345 if (PyErr_Occurred()) SWIG_fail;
12346 }
12347 resultobj = SWIG_Py_Void();
12348 return resultobj;
12349 fail:
12350 return NULL;
12351 }
12352
12353
12354 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12355 PyObject *resultobj = 0;
12356
12357 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12358 {
12359 PyThreadState* __tstate = wxPyBeginAllowThreads();
12360 wxLog::DontCreateOnDemand();
12361 wxPyEndAllowThreads(__tstate);
12362 if (PyErr_Occurred()) SWIG_fail;
12363 }
12364 resultobj = SWIG_Py_Void();
12365 return resultobj;
12366 fail:
12367 return NULL;
12368 }
12369
12370
12371 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12372 PyObject *resultobj = 0;
12373 bool arg1 = (bool) true ;
12374 bool val1 ;
12375 int ecode1 = 0 ;
12376 PyObject * obj0 = 0 ;
12377 char * kwnames[] = {
12378 (char *) "bRepetCounting", NULL
12379 };
12380
12381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12382 if (obj0) {
12383 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12384 if (!SWIG_IsOK(ecode1)) {
12385 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12386 }
12387 arg1 = static_cast< bool >(val1);
12388 }
12389 {
12390 PyThreadState* __tstate = wxPyBeginAllowThreads();
12391 wxLog::SetRepetitionCounting(arg1);
12392 wxPyEndAllowThreads(__tstate);
12393 if (PyErr_Occurred()) SWIG_fail;
12394 }
12395 resultobj = SWIG_Py_Void();
12396 return resultobj;
12397 fail:
12398 return NULL;
12399 }
12400
12401
12402 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12403 PyObject *resultobj = 0;
12404 bool result;
12405
12406 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12407 {
12408 PyThreadState* __tstate = wxPyBeginAllowThreads();
12409 result = (bool)wxLog::GetRepetitionCounting();
12410 wxPyEndAllowThreads(__tstate);
12411 if (PyErr_Occurred()) SWIG_fail;
12412 }
12413 {
12414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12415 }
12416 return resultobj;
12417 fail:
12418 return NULL;
12419 }
12420
12421
12422 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12423 PyObject *resultobj = 0;
12424 wxTraceMask arg1 ;
12425 unsigned long val1 ;
12426 int ecode1 = 0 ;
12427 PyObject * obj0 = 0 ;
12428 char * kwnames[] = {
12429 (char *) "ulMask", NULL
12430 };
12431
12432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12433 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12434 if (!SWIG_IsOK(ecode1)) {
12435 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12436 }
12437 arg1 = static_cast< wxTraceMask >(val1);
12438 {
12439 PyThreadState* __tstate = wxPyBeginAllowThreads();
12440 wxLog::SetTraceMask(arg1);
12441 wxPyEndAllowThreads(__tstate);
12442 if (PyErr_Occurred()) SWIG_fail;
12443 }
12444 resultobj = SWIG_Py_Void();
12445 return resultobj;
12446 fail:
12447 return NULL;
12448 }
12449
12450
12451 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12452 PyObject *resultobj = 0;
12453 wxString *arg1 = 0 ;
12454 bool temp1 = false ;
12455 PyObject * obj0 = 0 ;
12456 char * kwnames[] = {
12457 (char *) "str", NULL
12458 };
12459
12460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12461 {
12462 arg1 = wxString_in_helper(obj0);
12463 if (arg1 == NULL) SWIG_fail;
12464 temp1 = true;
12465 }
12466 {
12467 PyThreadState* __tstate = wxPyBeginAllowThreads();
12468 wxLog::AddTraceMask((wxString const &)*arg1);
12469 wxPyEndAllowThreads(__tstate);
12470 if (PyErr_Occurred()) SWIG_fail;
12471 }
12472 resultobj = SWIG_Py_Void();
12473 {
12474 if (temp1)
12475 delete arg1;
12476 }
12477 return resultobj;
12478 fail:
12479 {
12480 if (temp1)
12481 delete arg1;
12482 }
12483 return NULL;
12484 }
12485
12486
12487 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12488 PyObject *resultobj = 0;
12489 wxString *arg1 = 0 ;
12490 bool temp1 = false ;
12491 PyObject * obj0 = 0 ;
12492 char * kwnames[] = {
12493 (char *) "str", NULL
12494 };
12495
12496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12497 {
12498 arg1 = wxString_in_helper(obj0);
12499 if (arg1 == NULL) SWIG_fail;
12500 temp1 = true;
12501 }
12502 {
12503 PyThreadState* __tstate = wxPyBeginAllowThreads();
12504 wxLog::RemoveTraceMask((wxString const &)*arg1);
12505 wxPyEndAllowThreads(__tstate);
12506 if (PyErr_Occurred()) SWIG_fail;
12507 }
12508 resultobj = SWIG_Py_Void();
12509 {
12510 if (temp1)
12511 delete arg1;
12512 }
12513 return resultobj;
12514 fail:
12515 {
12516 if (temp1)
12517 delete arg1;
12518 }
12519 return NULL;
12520 }
12521
12522
12523 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12524 PyObject *resultobj = 0;
12525
12526 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12527 {
12528 PyThreadState* __tstate = wxPyBeginAllowThreads();
12529 wxLog::ClearTraceMasks();
12530 wxPyEndAllowThreads(__tstate);
12531 if (PyErr_Occurred()) SWIG_fail;
12532 }
12533 resultobj = SWIG_Py_Void();
12534 return resultobj;
12535 fail:
12536 return NULL;
12537 }
12538
12539
12540 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12541 PyObject *resultobj = 0;
12542 wxArrayString *result = 0 ;
12543
12544 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12545 {
12546 PyThreadState* __tstate = wxPyBeginAllowThreads();
12547 {
12548 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12549 result = (wxArrayString *) &_result_ref;
12550 }
12551 wxPyEndAllowThreads(__tstate);
12552 if (PyErr_Occurred()) SWIG_fail;
12553 }
12554 {
12555 resultobj = wxArrayString2PyList_helper(*result);
12556 }
12557 return resultobj;
12558 fail:
12559 return NULL;
12560 }
12561
12562
12563 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12564 PyObject *resultobj = 0;
12565 wxChar *arg1 = (wxChar *) 0 ;
12566 void *argp1 = 0 ;
12567 int res1 = 0 ;
12568 PyObject * obj0 = 0 ;
12569 char * kwnames[] = {
12570 (char *) "ts", NULL
12571 };
12572
12573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12575 if (!SWIG_IsOK(res1)) {
12576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12577 }
12578 arg1 = reinterpret_cast< wxChar * >(argp1);
12579 {
12580 PyThreadState* __tstate = wxPyBeginAllowThreads();
12581 wxLog::SetTimestamp((wxChar const *)arg1);
12582 wxPyEndAllowThreads(__tstate);
12583 if (PyErr_Occurred()) SWIG_fail;
12584 }
12585 resultobj = SWIG_Py_Void();
12586 return resultobj;
12587 fail:
12588 return NULL;
12589 }
12590
12591
12592 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12593 PyObject *resultobj = 0;
12594 bool result;
12595
12596 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12597 {
12598 PyThreadState* __tstate = wxPyBeginAllowThreads();
12599 result = (bool)wxLog::GetVerbose();
12600 wxPyEndAllowThreads(__tstate);
12601 if (PyErr_Occurred()) SWIG_fail;
12602 }
12603 {
12604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12605 }
12606 return resultobj;
12607 fail:
12608 return NULL;
12609 }
12610
12611
12612 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12613 PyObject *resultobj = 0;
12614 wxTraceMask result;
12615
12616 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12617 {
12618 PyThreadState* __tstate = wxPyBeginAllowThreads();
12619 result = (wxTraceMask)wxLog::GetTraceMask();
12620 wxPyEndAllowThreads(__tstate);
12621 if (PyErr_Occurred()) SWIG_fail;
12622 }
12623 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12624 return resultobj;
12625 fail:
12626 return NULL;
12627 }
12628
12629
12630 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12631 PyObject *resultobj = 0;
12632 wxChar *arg1 = (wxChar *) 0 ;
12633 bool result;
12634 void *argp1 = 0 ;
12635 int res1 = 0 ;
12636 PyObject * obj0 = 0 ;
12637 char * kwnames[] = {
12638 (char *) "mask", NULL
12639 };
12640
12641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12643 if (!SWIG_IsOK(res1)) {
12644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12645 }
12646 arg1 = reinterpret_cast< wxChar * >(argp1);
12647 {
12648 PyThreadState* __tstate = wxPyBeginAllowThreads();
12649 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12650 wxPyEndAllowThreads(__tstate);
12651 if (PyErr_Occurred()) SWIG_fail;
12652 }
12653 {
12654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12655 }
12656 return resultobj;
12657 fail:
12658 return NULL;
12659 }
12660
12661
12662 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12663 PyObject *resultobj = 0;
12664 wxLogLevel result;
12665
12666 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12667 {
12668 PyThreadState* __tstate = wxPyBeginAllowThreads();
12669 result = (wxLogLevel)wxLog::GetLogLevel();
12670 wxPyEndAllowThreads(__tstate);
12671 if (PyErr_Occurred()) SWIG_fail;
12672 }
12673 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12674 return resultobj;
12675 fail:
12676 return NULL;
12677 }
12678
12679
12680 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12681 PyObject *resultobj = 0;
12682 wxChar *result = 0 ;
12683
12684 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12685 {
12686 PyThreadState* __tstate = wxPyBeginAllowThreads();
12687 result = (wxChar *)wxLog::GetTimestamp();
12688 wxPyEndAllowThreads(__tstate);
12689 if (PyErr_Occurred()) SWIG_fail;
12690 }
12691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12692 return resultobj;
12693 fail:
12694 return NULL;
12695 }
12696
12697
12698 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12699 PyObject *resultobj = 0;
12700 wxString result;
12701
12702 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12703 {
12704 PyThreadState* __tstate = wxPyBeginAllowThreads();
12705 result = wxLog_TimeStamp();
12706 wxPyEndAllowThreads(__tstate);
12707 if (PyErr_Occurred()) SWIG_fail;
12708 }
12709 {
12710 #if wxUSE_UNICODE
12711 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12712 #else
12713 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12714 #endif
12715 }
12716 return resultobj;
12717 fail:
12718 return NULL;
12719 }
12720
12721
12722 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12723 PyObject *resultobj = 0;
12724 wxLog *arg1 = (wxLog *) 0 ;
12725 void *argp1 = 0 ;
12726 int res1 = 0 ;
12727 PyObject *swig_obj[1] ;
12728
12729 if (!args) SWIG_fail;
12730 swig_obj[0] = args;
12731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12732 if (!SWIG_IsOK(res1)) {
12733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12734 }
12735 arg1 = reinterpret_cast< wxLog * >(argp1);
12736 {
12737 PyThreadState* __tstate = wxPyBeginAllowThreads();
12738 wxLog_Destroy(arg1);
12739 wxPyEndAllowThreads(__tstate);
12740 if (PyErr_Occurred()) SWIG_fail;
12741 }
12742 resultobj = SWIG_Py_Void();
12743 return resultobj;
12744 fail:
12745 return NULL;
12746 }
12747
12748
12749 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12750 PyObject *obj;
12751 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12752 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12753 return SWIG_Py_Void();
12754 }
12755
12756 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12757 return SWIG_Python_InitShadowInstance(args);
12758 }
12759
12760 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12761 PyObject *resultobj = 0;
12762 wxLogStderr *result = 0 ;
12763
12764 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12765 {
12766 PyThreadState* __tstate = wxPyBeginAllowThreads();
12767 result = (wxLogStderr *)new wxLogStderr();
12768 wxPyEndAllowThreads(__tstate);
12769 if (PyErr_Occurred()) SWIG_fail;
12770 }
12771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12772 return resultobj;
12773 fail:
12774 return NULL;
12775 }
12776
12777
12778 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12779 PyObject *obj;
12780 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12781 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12782 return SWIG_Py_Void();
12783 }
12784
12785 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12786 return SWIG_Python_InitShadowInstance(args);
12787 }
12788
12789 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12790 PyObject *resultobj = 0;
12791 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12792 wxLogTextCtrl *result = 0 ;
12793 void *argp1 = 0 ;
12794 int res1 = 0 ;
12795 PyObject * obj0 = 0 ;
12796 char * kwnames[] = {
12797 (char *) "pTextCtrl", NULL
12798 };
12799
12800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12802 if (!SWIG_IsOK(res1)) {
12803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12804 }
12805 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12806 {
12807 PyThreadState* __tstate = wxPyBeginAllowThreads();
12808 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12809 wxPyEndAllowThreads(__tstate);
12810 if (PyErr_Occurred()) SWIG_fail;
12811 }
12812 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12813 return resultobj;
12814 fail:
12815 return NULL;
12816 }
12817
12818
12819 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12820 PyObject *obj;
12821 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12822 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12823 return SWIG_Py_Void();
12824 }
12825
12826 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12827 return SWIG_Python_InitShadowInstance(args);
12828 }
12829
12830 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12831 PyObject *resultobj = 0;
12832 wxLogGui *result = 0 ;
12833
12834 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12835 {
12836 PyThreadState* __tstate = wxPyBeginAllowThreads();
12837 result = (wxLogGui *)new wxLogGui();
12838 wxPyEndAllowThreads(__tstate);
12839 if (PyErr_Occurred()) SWIG_fail;
12840 }
12841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12842 return resultobj;
12843 fail:
12844 return NULL;
12845 }
12846
12847
12848 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12849 PyObject *obj;
12850 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12851 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12852 return SWIG_Py_Void();
12853 }
12854
12855 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12856 return SWIG_Python_InitShadowInstance(args);
12857 }
12858
12859 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12860 PyObject *resultobj = 0;
12861 wxFrame *arg1 = (wxFrame *) 0 ;
12862 wxString *arg2 = 0 ;
12863 bool arg3 = (bool) true ;
12864 bool arg4 = (bool) true ;
12865 wxLogWindow *result = 0 ;
12866 void *argp1 = 0 ;
12867 int res1 = 0 ;
12868 bool temp2 = false ;
12869 bool val3 ;
12870 int ecode3 = 0 ;
12871 bool val4 ;
12872 int ecode4 = 0 ;
12873 PyObject * obj0 = 0 ;
12874 PyObject * obj1 = 0 ;
12875 PyObject * obj2 = 0 ;
12876 PyObject * obj3 = 0 ;
12877 char * kwnames[] = {
12878 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
12879 };
12880
12881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12883 if (!SWIG_IsOK(res1)) {
12884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
12885 }
12886 arg1 = reinterpret_cast< wxFrame * >(argp1);
12887 {
12888 arg2 = wxString_in_helper(obj1);
12889 if (arg2 == NULL) SWIG_fail;
12890 temp2 = true;
12891 }
12892 if (obj2) {
12893 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12894 if (!SWIG_IsOK(ecode3)) {
12895 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
12896 }
12897 arg3 = static_cast< bool >(val3);
12898 }
12899 if (obj3) {
12900 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12901 if (!SWIG_IsOK(ecode4)) {
12902 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
12903 }
12904 arg4 = static_cast< bool >(val4);
12905 }
12906 {
12907 PyThreadState* __tstate = wxPyBeginAllowThreads();
12908 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
12909 wxPyEndAllowThreads(__tstate);
12910 if (PyErr_Occurred()) SWIG_fail;
12911 }
12912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
12913 {
12914 if (temp2)
12915 delete arg2;
12916 }
12917 return resultobj;
12918 fail:
12919 {
12920 if (temp2)
12921 delete arg2;
12922 }
12923 return NULL;
12924 }
12925
12926
12927 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12928 PyObject *resultobj = 0;
12929 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12930 bool arg2 = (bool) true ;
12931 void *argp1 = 0 ;
12932 int res1 = 0 ;
12933 bool val2 ;
12934 int ecode2 = 0 ;
12935 PyObject * obj0 = 0 ;
12936 PyObject * obj1 = 0 ;
12937 char * kwnames[] = {
12938 (char *) "self",(char *) "bShow", NULL
12939 };
12940
12941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
12942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12943 if (!SWIG_IsOK(res1)) {
12944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
12945 }
12946 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12947 if (obj1) {
12948 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12949 if (!SWIG_IsOK(ecode2)) {
12950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
12951 }
12952 arg2 = static_cast< bool >(val2);
12953 }
12954 {
12955 PyThreadState* __tstate = wxPyBeginAllowThreads();
12956 (arg1)->Show(arg2);
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 *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12968 PyObject *resultobj = 0;
12969 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12970 wxFrame *result = 0 ;
12971 void *argp1 = 0 ;
12972 int res1 = 0 ;
12973 PyObject *swig_obj[1] ;
12974
12975 if (!args) SWIG_fail;
12976 swig_obj[0] = args;
12977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12978 if (!SWIG_IsOK(res1)) {
12979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12980 }
12981 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12982 {
12983 PyThreadState* __tstate = wxPyBeginAllowThreads();
12984 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
12985 wxPyEndAllowThreads(__tstate);
12986 if (PyErr_Occurred()) SWIG_fail;
12987 }
12988 {
12989 resultobj = wxPyMake_wxObject(result, (bool)0);
12990 }
12991 return resultobj;
12992 fail:
12993 return NULL;
12994 }
12995
12996
12997 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12998 PyObject *resultobj = 0;
12999 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13000 wxLog *result = 0 ;
13001 void *argp1 = 0 ;
13002 int res1 = 0 ;
13003 PyObject *swig_obj[1] ;
13004
13005 if (!args) SWIG_fail;
13006 swig_obj[0] = args;
13007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13008 if (!SWIG_IsOK(res1)) {
13009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13010 }
13011 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13012 {
13013 PyThreadState* __tstate = wxPyBeginAllowThreads();
13014 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13015 wxPyEndAllowThreads(__tstate);
13016 if (PyErr_Occurred()) SWIG_fail;
13017 }
13018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13019 return resultobj;
13020 fail:
13021 return NULL;
13022 }
13023
13024
13025 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13026 PyObject *resultobj = 0;
13027 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13028 bool result;
13029 void *argp1 = 0 ;
13030 int res1 = 0 ;
13031 PyObject *swig_obj[1] ;
13032
13033 if (!args) SWIG_fail;
13034 swig_obj[0] = args;
13035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13036 if (!SWIG_IsOK(res1)) {
13037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13038 }
13039 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13040 {
13041 PyThreadState* __tstate = wxPyBeginAllowThreads();
13042 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13043 wxPyEndAllowThreads(__tstate);
13044 if (PyErr_Occurred()) SWIG_fail;
13045 }
13046 {
13047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13048 }
13049 return resultobj;
13050 fail:
13051 return NULL;
13052 }
13053
13054
13055 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13056 PyObject *resultobj = 0;
13057 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13058 bool arg2 ;
13059 void *argp1 = 0 ;
13060 int res1 = 0 ;
13061 bool val2 ;
13062 int ecode2 = 0 ;
13063 PyObject * obj0 = 0 ;
13064 PyObject * obj1 = 0 ;
13065 char * kwnames[] = {
13066 (char *) "self",(char *) "bDoPass", NULL
13067 };
13068
13069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13071 if (!SWIG_IsOK(res1)) {
13072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13073 }
13074 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13075 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13076 if (!SWIG_IsOK(ecode2)) {
13077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13078 }
13079 arg2 = static_cast< bool >(val2);
13080 {
13081 PyThreadState* __tstate = wxPyBeginAllowThreads();
13082 (arg1)->PassMessages(arg2);
13083 wxPyEndAllowThreads(__tstate);
13084 if (PyErr_Occurred()) SWIG_fail;
13085 }
13086 resultobj = SWIG_Py_Void();
13087 return resultobj;
13088 fail:
13089 return NULL;
13090 }
13091
13092
13093 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13094 PyObject *obj;
13095 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13096 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13097 return SWIG_Py_Void();
13098 }
13099
13100 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13101 return SWIG_Python_InitShadowInstance(args);
13102 }
13103
13104 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13105 PyObject *resultobj = 0;
13106 wxLog *arg1 = (wxLog *) 0 ;
13107 wxLogChain *result = 0 ;
13108 void *argp1 = 0 ;
13109 int res1 = 0 ;
13110 PyObject * obj0 = 0 ;
13111 char * kwnames[] = {
13112 (char *) "logger", NULL
13113 };
13114
13115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13117 if (!SWIG_IsOK(res1)) {
13118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13119 }
13120 arg1 = reinterpret_cast< wxLog * >(argp1);
13121 {
13122 PyThreadState* __tstate = wxPyBeginAllowThreads();
13123 result = (wxLogChain *)new wxLogChain(arg1);
13124 wxPyEndAllowThreads(__tstate);
13125 if (PyErr_Occurred()) SWIG_fail;
13126 }
13127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13128 return resultobj;
13129 fail:
13130 return NULL;
13131 }
13132
13133
13134 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13135 PyObject *resultobj = 0;
13136 wxLogChain *arg1 = (wxLogChain *) 0 ;
13137 wxLog *arg2 = (wxLog *) 0 ;
13138 void *argp1 = 0 ;
13139 int res1 = 0 ;
13140 void *argp2 = 0 ;
13141 int res2 = 0 ;
13142 PyObject * obj0 = 0 ;
13143 PyObject * obj1 = 0 ;
13144 char * kwnames[] = {
13145 (char *) "self",(char *) "logger", NULL
13146 };
13147
13148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13150 if (!SWIG_IsOK(res1)) {
13151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13152 }
13153 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13154 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13155 if (!SWIG_IsOK(res2)) {
13156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13157 }
13158 arg2 = reinterpret_cast< wxLog * >(argp2);
13159 {
13160 PyThreadState* __tstate = wxPyBeginAllowThreads();
13161 (arg1)->SetLog(arg2);
13162 wxPyEndAllowThreads(__tstate);
13163 if (PyErr_Occurred()) SWIG_fail;
13164 }
13165 resultobj = SWIG_Py_Void();
13166 return resultobj;
13167 fail:
13168 return NULL;
13169 }
13170
13171
13172 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13173 PyObject *resultobj = 0;
13174 wxLogChain *arg1 = (wxLogChain *) 0 ;
13175 bool arg2 ;
13176 void *argp1 = 0 ;
13177 int res1 = 0 ;
13178 bool val2 ;
13179 int ecode2 = 0 ;
13180 PyObject * obj0 = 0 ;
13181 PyObject * obj1 = 0 ;
13182 char * kwnames[] = {
13183 (char *) "self",(char *) "bDoPass", NULL
13184 };
13185
13186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13188 if (!SWIG_IsOK(res1)) {
13189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13190 }
13191 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13192 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13193 if (!SWIG_IsOK(ecode2)) {
13194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13195 }
13196 arg2 = static_cast< bool >(val2);
13197 {
13198 PyThreadState* __tstate = wxPyBeginAllowThreads();
13199 (arg1)->PassMessages(arg2);
13200 wxPyEndAllowThreads(__tstate);
13201 if (PyErr_Occurred()) SWIG_fail;
13202 }
13203 resultobj = SWIG_Py_Void();
13204 return resultobj;
13205 fail:
13206 return NULL;
13207 }
13208
13209
13210 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13211 PyObject *resultobj = 0;
13212 wxLogChain *arg1 = (wxLogChain *) 0 ;
13213 bool result;
13214 void *argp1 = 0 ;
13215 int res1 = 0 ;
13216 PyObject *swig_obj[1] ;
13217
13218 if (!args) SWIG_fail;
13219 swig_obj[0] = args;
13220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13221 if (!SWIG_IsOK(res1)) {
13222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13223 }
13224 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13225 {
13226 PyThreadState* __tstate = wxPyBeginAllowThreads();
13227 result = (bool)(arg1)->IsPassingMessages();
13228 wxPyEndAllowThreads(__tstate);
13229 if (PyErr_Occurred()) SWIG_fail;
13230 }
13231 {
13232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13233 }
13234 return resultobj;
13235 fail:
13236 return NULL;
13237 }
13238
13239
13240 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13241 PyObject *resultobj = 0;
13242 wxLogChain *arg1 = (wxLogChain *) 0 ;
13243 wxLog *result = 0 ;
13244 void *argp1 = 0 ;
13245 int res1 = 0 ;
13246 PyObject *swig_obj[1] ;
13247
13248 if (!args) SWIG_fail;
13249 swig_obj[0] = args;
13250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13251 if (!SWIG_IsOK(res1)) {
13252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13253 }
13254 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13255 {
13256 PyThreadState* __tstate = wxPyBeginAllowThreads();
13257 result = (wxLog *)(arg1)->GetOldLog();
13258 wxPyEndAllowThreads(__tstate);
13259 if (PyErr_Occurred()) SWIG_fail;
13260 }
13261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13262 return resultobj;
13263 fail:
13264 return NULL;
13265 }
13266
13267
13268 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13269 PyObject *obj;
13270 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13271 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13272 return SWIG_Py_Void();
13273 }
13274
13275 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13276 return SWIG_Python_InitShadowInstance(args);
13277 }
13278
13279 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13280 PyObject *resultobj = 0;
13281 wxLogBuffer *result = 0 ;
13282
13283 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13284 {
13285 PyThreadState* __tstate = wxPyBeginAllowThreads();
13286 result = (wxLogBuffer *)new wxLogBuffer();
13287 wxPyEndAllowThreads(__tstate);
13288 if (PyErr_Occurred()) SWIG_fail;
13289 }
13290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13291 return resultobj;
13292 fail:
13293 return NULL;
13294 }
13295
13296
13297 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13298 PyObject *resultobj = 0;
13299 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13300 wxString *result = 0 ;
13301 void *argp1 = 0 ;
13302 int res1 = 0 ;
13303 PyObject *swig_obj[1] ;
13304
13305 if (!args) SWIG_fail;
13306 swig_obj[0] = args;
13307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13308 if (!SWIG_IsOK(res1)) {
13309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13310 }
13311 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13312 {
13313 PyThreadState* __tstate = wxPyBeginAllowThreads();
13314 {
13315 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13316 result = (wxString *) &_result_ref;
13317 }
13318 wxPyEndAllowThreads(__tstate);
13319 if (PyErr_Occurred()) SWIG_fail;
13320 }
13321 {
13322 #if wxUSE_UNICODE
13323 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13324 #else
13325 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13326 #endif
13327 }
13328 return resultobj;
13329 fail:
13330 return NULL;
13331 }
13332
13333
13334 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13335 PyObject *obj;
13336 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13337 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13338 return SWIG_Py_Void();
13339 }
13340
13341 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13342 return SWIG_Python_InitShadowInstance(args);
13343 }
13344
13345 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13346 PyObject *resultobj = 0;
13347 unsigned long result;
13348
13349 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13350 {
13351 PyThreadState* __tstate = wxPyBeginAllowThreads();
13352 result = (unsigned long)wxSysErrorCode();
13353 wxPyEndAllowThreads(__tstate);
13354 if (PyErr_Occurred()) SWIG_fail;
13355 }
13356 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13357 return resultobj;
13358 fail:
13359 return NULL;
13360 }
13361
13362
13363 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13364 PyObject *resultobj = 0;
13365 unsigned long arg1 = (unsigned long) 0 ;
13366 wxString result;
13367 unsigned long val1 ;
13368 int ecode1 = 0 ;
13369 PyObject * obj0 = 0 ;
13370 char * kwnames[] = {
13371 (char *) "nErrCode", NULL
13372 };
13373
13374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13375 if (obj0) {
13376 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13377 if (!SWIG_IsOK(ecode1)) {
13378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13379 }
13380 arg1 = static_cast< unsigned long >(val1);
13381 }
13382 {
13383 PyThreadState* __tstate = wxPyBeginAllowThreads();
13384 result = wxSysErrorMsg(arg1);
13385 wxPyEndAllowThreads(__tstate);
13386 if (PyErr_Occurred()) SWIG_fail;
13387 }
13388 {
13389 #if wxUSE_UNICODE
13390 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13391 #else
13392 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13393 #endif
13394 }
13395 return resultobj;
13396 fail:
13397 return NULL;
13398 }
13399
13400
13401 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13402 PyObject *resultobj = 0;
13403 wxString *arg1 = 0 ;
13404 bool temp1 = false ;
13405 PyObject * obj0 = 0 ;
13406 char * kwnames[] = {
13407 (char *) "msg", NULL
13408 };
13409
13410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13411 {
13412 arg1 = wxString_in_helper(obj0);
13413 if (arg1 == NULL) SWIG_fail;
13414 temp1 = true;
13415 }
13416 {
13417 PyThreadState* __tstate = wxPyBeginAllowThreads();
13418 wxPyLogFatalError((wxString const &)*arg1);
13419 wxPyEndAllowThreads(__tstate);
13420 if (PyErr_Occurred()) SWIG_fail;
13421 }
13422 resultobj = SWIG_Py_Void();
13423 {
13424 if (temp1)
13425 delete arg1;
13426 }
13427 return resultobj;
13428 fail:
13429 {
13430 if (temp1)
13431 delete arg1;
13432 }
13433 return NULL;
13434 }
13435
13436
13437 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13438 PyObject *resultobj = 0;
13439 wxString *arg1 = 0 ;
13440 bool temp1 = false ;
13441 PyObject * obj0 = 0 ;
13442 char * kwnames[] = {
13443 (char *) "msg", NULL
13444 };
13445
13446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13447 {
13448 arg1 = wxString_in_helper(obj0);
13449 if (arg1 == NULL) SWIG_fail;
13450 temp1 = true;
13451 }
13452 {
13453 PyThreadState* __tstate = wxPyBeginAllowThreads();
13454 wxPyLogError((wxString const &)*arg1);
13455 wxPyEndAllowThreads(__tstate);
13456 if (PyErr_Occurred()) SWIG_fail;
13457 }
13458 resultobj = SWIG_Py_Void();
13459 {
13460 if (temp1)
13461 delete arg1;
13462 }
13463 return resultobj;
13464 fail:
13465 {
13466 if (temp1)
13467 delete arg1;
13468 }
13469 return NULL;
13470 }
13471
13472
13473 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13474 PyObject *resultobj = 0;
13475 wxString *arg1 = 0 ;
13476 bool temp1 = false ;
13477 PyObject * obj0 = 0 ;
13478 char * kwnames[] = {
13479 (char *) "msg", NULL
13480 };
13481
13482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13483 {
13484 arg1 = wxString_in_helper(obj0);
13485 if (arg1 == NULL) SWIG_fail;
13486 temp1 = true;
13487 }
13488 {
13489 PyThreadState* __tstate = wxPyBeginAllowThreads();
13490 wxPyLogWarning((wxString const &)*arg1);
13491 wxPyEndAllowThreads(__tstate);
13492 if (PyErr_Occurred()) SWIG_fail;
13493 }
13494 resultobj = SWIG_Py_Void();
13495 {
13496 if (temp1)
13497 delete arg1;
13498 }
13499 return resultobj;
13500 fail:
13501 {
13502 if (temp1)
13503 delete arg1;
13504 }
13505 return NULL;
13506 }
13507
13508
13509 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13510 PyObject *resultobj = 0;
13511 wxString *arg1 = 0 ;
13512 bool temp1 = false ;
13513 PyObject * obj0 = 0 ;
13514 char * kwnames[] = {
13515 (char *) "msg", NULL
13516 };
13517
13518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13519 {
13520 arg1 = wxString_in_helper(obj0);
13521 if (arg1 == NULL) SWIG_fail;
13522 temp1 = true;
13523 }
13524 {
13525 PyThreadState* __tstate = wxPyBeginAllowThreads();
13526 wxPyLogMessage((wxString const &)*arg1);
13527 wxPyEndAllowThreads(__tstate);
13528 if (PyErr_Occurred()) SWIG_fail;
13529 }
13530 resultobj = SWIG_Py_Void();
13531 {
13532 if (temp1)
13533 delete arg1;
13534 }
13535 return resultobj;
13536 fail:
13537 {
13538 if (temp1)
13539 delete arg1;
13540 }
13541 return NULL;
13542 }
13543
13544
13545 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13546 PyObject *resultobj = 0;
13547 wxString *arg1 = 0 ;
13548 bool temp1 = false ;
13549 PyObject * obj0 = 0 ;
13550 char * kwnames[] = {
13551 (char *) "msg", NULL
13552 };
13553
13554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13555 {
13556 arg1 = wxString_in_helper(obj0);
13557 if (arg1 == NULL) SWIG_fail;
13558 temp1 = true;
13559 }
13560 {
13561 PyThreadState* __tstate = wxPyBeginAllowThreads();
13562 wxPyLogInfo((wxString const &)*arg1);
13563 wxPyEndAllowThreads(__tstate);
13564 if (PyErr_Occurred()) SWIG_fail;
13565 }
13566 resultobj = SWIG_Py_Void();
13567 {
13568 if (temp1)
13569 delete arg1;
13570 }
13571 return resultobj;
13572 fail:
13573 {
13574 if (temp1)
13575 delete arg1;
13576 }
13577 return NULL;
13578 }
13579
13580
13581 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13582 PyObject *resultobj = 0;
13583 wxString *arg1 = 0 ;
13584 bool temp1 = false ;
13585 PyObject * obj0 = 0 ;
13586 char * kwnames[] = {
13587 (char *) "msg", NULL
13588 };
13589
13590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13591 {
13592 arg1 = wxString_in_helper(obj0);
13593 if (arg1 == NULL) SWIG_fail;
13594 temp1 = true;
13595 }
13596 {
13597 PyThreadState* __tstate = wxPyBeginAllowThreads();
13598 wxPyLogDebug((wxString const &)*arg1);
13599 wxPyEndAllowThreads(__tstate);
13600 if (PyErr_Occurred()) SWIG_fail;
13601 }
13602 resultobj = SWIG_Py_Void();
13603 {
13604 if (temp1)
13605 delete arg1;
13606 }
13607 return resultobj;
13608 fail:
13609 {
13610 if (temp1)
13611 delete arg1;
13612 }
13613 return NULL;
13614 }
13615
13616
13617 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13618 PyObject *resultobj = 0;
13619 wxString *arg1 = 0 ;
13620 bool temp1 = false ;
13621 PyObject * obj0 = 0 ;
13622 char * kwnames[] = {
13623 (char *) "msg", NULL
13624 };
13625
13626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13627 {
13628 arg1 = wxString_in_helper(obj0);
13629 if (arg1 == NULL) SWIG_fail;
13630 temp1 = true;
13631 }
13632 {
13633 PyThreadState* __tstate = wxPyBeginAllowThreads();
13634 wxPyLogVerbose((wxString const &)*arg1);
13635 wxPyEndAllowThreads(__tstate);
13636 if (PyErr_Occurred()) SWIG_fail;
13637 }
13638 resultobj = SWIG_Py_Void();
13639 {
13640 if (temp1)
13641 delete arg1;
13642 }
13643 return resultobj;
13644 fail:
13645 {
13646 if (temp1)
13647 delete arg1;
13648 }
13649 return NULL;
13650 }
13651
13652
13653 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13654 PyObject *resultobj = 0;
13655 wxString *arg1 = 0 ;
13656 bool temp1 = false ;
13657 PyObject * obj0 = 0 ;
13658 char * kwnames[] = {
13659 (char *) "msg", NULL
13660 };
13661
13662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13663 {
13664 arg1 = wxString_in_helper(obj0);
13665 if (arg1 == NULL) SWIG_fail;
13666 temp1 = true;
13667 }
13668 {
13669 PyThreadState* __tstate = wxPyBeginAllowThreads();
13670 wxPyLogStatus((wxString const &)*arg1);
13671 wxPyEndAllowThreads(__tstate);
13672 if (PyErr_Occurred()) SWIG_fail;
13673 }
13674 resultobj = SWIG_Py_Void();
13675 {
13676 if (temp1)
13677 delete arg1;
13678 }
13679 return resultobj;
13680 fail:
13681 {
13682 if (temp1)
13683 delete arg1;
13684 }
13685 return NULL;
13686 }
13687
13688
13689 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13690 PyObject *resultobj = 0;
13691 wxFrame *arg1 = (wxFrame *) 0 ;
13692 wxString *arg2 = 0 ;
13693 void *argp1 = 0 ;
13694 int res1 = 0 ;
13695 bool temp2 = false ;
13696 PyObject * obj0 = 0 ;
13697 PyObject * obj1 = 0 ;
13698 char * kwnames[] = {
13699 (char *) "pFrame",(char *) "msg", NULL
13700 };
13701
13702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13704 if (!SWIG_IsOK(res1)) {
13705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13706 }
13707 arg1 = reinterpret_cast< wxFrame * >(argp1);
13708 {
13709 arg2 = wxString_in_helper(obj1);
13710 if (arg2 == NULL) SWIG_fail;
13711 temp2 = true;
13712 }
13713 {
13714 PyThreadState* __tstate = wxPyBeginAllowThreads();
13715 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13716 wxPyEndAllowThreads(__tstate);
13717 if (PyErr_Occurred()) SWIG_fail;
13718 }
13719 resultobj = SWIG_Py_Void();
13720 {
13721 if (temp2)
13722 delete arg2;
13723 }
13724 return resultobj;
13725 fail:
13726 {
13727 if (temp2)
13728 delete arg2;
13729 }
13730 return NULL;
13731 }
13732
13733
13734 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13735 PyObject *resultobj = 0;
13736 wxString *arg1 = 0 ;
13737 bool temp1 = false ;
13738 PyObject * obj0 = 0 ;
13739 char * kwnames[] = {
13740 (char *) "msg", NULL
13741 };
13742
13743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13744 {
13745 arg1 = wxString_in_helper(obj0);
13746 if (arg1 == NULL) SWIG_fail;
13747 temp1 = true;
13748 }
13749 {
13750 PyThreadState* __tstate = wxPyBeginAllowThreads();
13751 wxPyLogSysError((wxString const &)*arg1);
13752 wxPyEndAllowThreads(__tstate);
13753 if (PyErr_Occurred()) SWIG_fail;
13754 }
13755 resultobj = SWIG_Py_Void();
13756 {
13757 if (temp1)
13758 delete arg1;
13759 }
13760 return resultobj;
13761 fail:
13762 {
13763 if (temp1)
13764 delete arg1;
13765 }
13766 return NULL;
13767 }
13768
13769
13770 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13771 PyObject *resultobj = 0;
13772 unsigned long arg1 ;
13773 wxString *arg2 = 0 ;
13774 unsigned long val1 ;
13775 int ecode1 = 0 ;
13776 bool temp2 = false ;
13777 PyObject * obj0 = 0 ;
13778 PyObject * obj1 = 0 ;
13779 char * kwnames[] = {
13780 (char *) "level",(char *) "msg", NULL
13781 };
13782
13783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13784 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13785 if (!SWIG_IsOK(ecode1)) {
13786 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13787 }
13788 arg1 = static_cast< unsigned long >(val1);
13789 {
13790 arg2 = wxString_in_helper(obj1);
13791 if (arg2 == NULL) SWIG_fail;
13792 temp2 = true;
13793 }
13794 {
13795 PyThreadState* __tstate = wxPyBeginAllowThreads();
13796 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13797 wxPyEndAllowThreads(__tstate);
13798 if (PyErr_Occurred()) SWIG_fail;
13799 }
13800 resultobj = SWIG_Py_Void();
13801 {
13802 if (temp2)
13803 delete arg2;
13804 }
13805 return resultobj;
13806 fail:
13807 {
13808 if (temp2)
13809 delete arg2;
13810 }
13811 return NULL;
13812 }
13813
13814
13815 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13816 PyObject *resultobj = 0;
13817 unsigned long arg1 ;
13818 wxString *arg2 = 0 ;
13819 unsigned long val1 ;
13820 int ecode1 = 0 ;
13821 bool temp2 = false ;
13822
13823 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13824 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13825 if (!SWIG_IsOK(ecode1)) {
13826 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13827 }
13828 arg1 = static_cast< unsigned long >(val1);
13829 {
13830 arg2 = wxString_in_helper(swig_obj[1]);
13831 if (arg2 == NULL) SWIG_fail;
13832 temp2 = true;
13833 }
13834 {
13835 PyThreadState* __tstate = wxPyBeginAllowThreads();
13836 wxPyLogTrace(arg1,(wxString const &)*arg2);
13837 wxPyEndAllowThreads(__tstate);
13838 if (PyErr_Occurred()) SWIG_fail;
13839 }
13840 resultobj = SWIG_Py_Void();
13841 {
13842 if (temp2)
13843 delete arg2;
13844 }
13845 return resultobj;
13846 fail:
13847 {
13848 if (temp2)
13849 delete arg2;
13850 }
13851 return NULL;
13852 }
13853
13854
13855 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13856 PyObject *resultobj = 0;
13857 wxString *arg1 = 0 ;
13858 wxString *arg2 = 0 ;
13859 bool temp1 = false ;
13860 bool temp2 = false ;
13861
13862 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13863 {
13864 arg1 = wxString_in_helper(swig_obj[0]);
13865 if (arg1 == NULL) SWIG_fail;
13866 temp1 = true;
13867 }
13868 {
13869 arg2 = wxString_in_helper(swig_obj[1]);
13870 if (arg2 == NULL) SWIG_fail;
13871 temp2 = true;
13872 }
13873 {
13874 PyThreadState* __tstate = wxPyBeginAllowThreads();
13875 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
13876 wxPyEndAllowThreads(__tstate);
13877 if (PyErr_Occurred()) SWIG_fail;
13878 }
13879 resultobj = SWIG_Py_Void();
13880 {
13881 if (temp1)
13882 delete arg1;
13883 }
13884 {
13885 if (temp2)
13886 delete arg2;
13887 }
13888 return resultobj;
13889 fail:
13890 {
13891 if (temp1)
13892 delete arg1;
13893 }
13894 {
13895 if (temp2)
13896 delete arg2;
13897 }
13898 return NULL;
13899 }
13900
13901
13902 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
13903 int argc;
13904 PyObject *argv[3];
13905
13906 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
13907 --argc;
13908 if (argc == 2) {
13909 int _v = 0;
13910 {
13911 {
13912 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
13913 }
13914 }
13915 if (!_v) goto check_1;
13916 return _wrap_LogTrace__SWIG_1(self, argc, argv);
13917 }
13918 check_1:
13919
13920 if (argc == 2) {
13921 return _wrap_LogTrace__SWIG_0(self, argc, argv);
13922 }
13923
13924 fail:
13925 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
13926 return NULL;
13927 }
13928
13929
13930 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13931 PyObject *resultobj = 0;
13932 wxString *arg1 = 0 ;
13933 wxString *arg2 = 0 ;
13934 bool temp1 = false ;
13935 bool temp2 = false ;
13936 PyObject * obj0 = 0 ;
13937 PyObject * obj1 = 0 ;
13938 char * kwnames[] = {
13939 (char *) "title",(char *) "text", NULL
13940 };
13941
13942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
13943 {
13944 arg1 = wxString_in_helper(obj0);
13945 if (arg1 == NULL) SWIG_fail;
13946 temp1 = true;
13947 }
13948 {
13949 arg2 = wxString_in_helper(obj1);
13950 if (arg2 == NULL) SWIG_fail;
13951 temp2 = true;
13952 }
13953 {
13954 PyThreadState* __tstate = wxPyBeginAllowThreads();
13955 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
13956 wxPyEndAllowThreads(__tstate);
13957 if (PyErr_Occurred()) SWIG_fail;
13958 }
13959 resultobj = SWIG_Py_Void();
13960 {
13961 if (temp1)
13962 delete arg1;
13963 }
13964 {
13965 if (temp2)
13966 delete arg2;
13967 }
13968 return resultobj;
13969 fail:
13970 {
13971 if (temp1)
13972 delete arg1;
13973 }
13974 {
13975 if (temp2)
13976 delete arg2;
13977 }
13978 return NULL;
13979 }
13980
13981
13982 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13983 PyObject *resultobj = 0;
13984 wxLogNull *result = 0 ;
13985
13986 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
13987 {
13988 PyThreadState* __tstate = wxPyBeginAllowThreads();
13989 result = (wxLogNull *)new wxLogNull();
13990 wxPyEndAllowThreads(__tstate);
13991 if (PyErr_Occurred()) SWIG_fail;
13992 }
13993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
13994 return resultobj;
13995 fail:
13996 return NULL;
13997 }
13998
13999
14000 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14001 PyObject *resultobj = 0;
14002 wxLogNull *arg1 = (wxLogNull *) 0 ;
14003 void *argp1 = 0 ;
14004 int res1 = 0 ;
14005 PyObject *swig_obj[1] ;
14006
14007 if (!args) SWIG_fail;
14008 swig_obj[0] = args;
14009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14010 if (!SWIG_IsOK(res1)) {
14011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14012 }
14013 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14014 {
14015 PyThreadState* __tstate = wxPyBeginAllowThreads();
14016 delete arg1;
14017
14018 wxPyEndAllowThreads(__tstate);
14019 if (PyErr_Occurred()) SWIG_fail;
14020 }
14021 resultobj = SWIG_Py_Void();
14022 return resultobj;
14023 fail:
14024 return NULL;
14025 }
14026
14027
14028 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14029 PyObject *obj;
14030 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14031 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14032 return SWIG_Py_Void();
14033 }
14034
14035 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14036 return SWIG_Python_InitShadowInstance(args);
14037 }
14038
14039 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14040 PyObject *resultobj = 0;
14041 wxPyLog *result = 0 ;
14042
14043 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14044 {
14045 PyThreadState* __tstate = wxPyBeginAllowThreads();
14046 result = (wxPyLog *)new wxPyLog();
14047 wxPyEndAllowThreads(__tstate);
14048 if (PyErr_Occurred()) SWIG_fail;
14049 }
14050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14051 return resultobj;
14052 fail:
14053 return NULL;
14054 }
14055
14056
14057 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14058 PyObject *resultobj = 0;
14059 wxPyLog *arg1 = (wxPyLog *) 0 ;
14060 PyObject *arg2 = (PyObject *) 0 ;
14061 PyObject *arg3 = (PyObject *) 0 ;
14062 void *argp1 = 0 ;
14063 int res1 = 0 ;
14064 PyObject * obj0 = 0 ;
14065 PyObject * obj1 = 0 ;
14066 PyObject * obj2 = 0 ;
14067 char * kwnames[] = {
14068 (char *) "self",(char *) "self",(char *) "_class", NULL
14069 };
14070
14071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14073 if (!SWIG_IsOK(res1)) {
14074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14075 }
14076 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14077 arg2 = obj1;
14078 arg3 = obj2;
14079 {
14080 PyThreadState* __tstate = wxPyBeginAllowThreads();
14081 (arg1)->_setCallbackInfo(arg2,arg3);
14082 wxPyEndAllowThreads(__tstate);
14083 if (PyErr_Occurred()) SWIG_fail;
14084 }
14085 resultobj = SWIG_Py_Void();
14086 return resultobj;
14087 fail:
14088 return NULL;
14089 }
14090
14091
14092 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14093 PyObject *obj;
14094 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14095 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14096 return SWIG_Py_Void();
14097 }
14098
14099 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14100 return SWIG_Python_InitShadowInstance(args);
14101 }
14102
14103 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14104 PyObject *resultobj = 0;
14105 int arg1 ;
14106 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14107 int arg3 = (int) wxKILL_NOCHILDREN ;
14108 wxKillError result;
14109 int val1 ;
14110 int ecode1 = 0 ;
14111 int val2 ;
14112 int ecode2 = 0 ;
14113 int val3 ;
14114 int ecode3 = 0 ;
14115 PyObject * obj0 = 0 ;
14116 PyObject * obj1 = 0 ;
14117 PyObject * obj2 = 0 ;
14118 char * kwnames[] = {
14119 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14120 };
14121
14122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14123 ecode1 = SWIG_AsVal_int(obj0, &val1);
14124 if (!SWIG_IsOK(ecode1)) {
14125 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14126 }
14127 arg1 = static_cast< int >(val1);
14128 if (obj1) {
14129 ecode2 = SWIG_AsVal_int(obj1, &val2);
14130 if (!SWIG_IsOK(ecode2)) {
14131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14132 }
14133 arg2 = static_cast< wxSignal >(val2);
14134 }
14135 if (obj2) {
14136 ecode3 = SWIG_AsVal_int(obj2, &val3);
14137 if (!SWIG_IsOK(ecode3)) {
14138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14139 }
14140 arg3 = static_cast< int >(val3);
14141 }
14142 {
14143 PyThreadState* __tstate = wxPyBeginAllowThreads();
14144 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
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_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14156 PyObject *resultobj = 0;
14157 int arg1 ;
14158 bool result;
14159 int val1 ;
14160 int ecode1 = 0 ;
14161 PyObject * obj0 = 0 ;
14162 char * kwnames[] = {
14163 (char *) "pid", NULL
14164 };
14165
14166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14167 ecode1 = SWIG_AsVal_int(obj0, &val1);
14168 if (!SWIG_IsOK(ecode1)) {
14169 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14170 }
14171 arg1 = static_cast< int >(val1);
14172 {
14173 PyThreadState* __tstate = wxPyBeginAllowThreads();
14174 result = (bool)wxPyProcess::Exists(arg1);
14175 wxPyEndAllowThreads(__tstate);
14176 if (PyErr_Occurred()) SWIG_fail;
14177 }
14178 {
14179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14180 }
14181 return resultobj;
14182 fail:
14183 return NULL;
14184 }
14185
14186
14187 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14188 PyObject *resultobj = 0;
14189 wxString *arg1 = 0 ;
14190 int arg2 = (int) wxEXEC_ASYNC ;
14191 wxPyProcess *result = 0 ;
14192 bool temp1 = false ;
14193 int val2 ;
14194 int ecode2 = 0 ;
14195 PyObject * obj0 = 0 ;
14196 PyObject * obj1 = 0 ;
14197 char * kwnames[] = {
14198 (char *) "cmd",(char *) "flags", NULL
14199 };
14200
14201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14202 {
14203 arg1 = wxString_in_helper(obj0);
14204 if (arg1 == NULL) SWIG_fail;
14205 temp1 = true;
14206 }
14207 if (obj1) {
14208 ecode2 = SWIG_AsVal_int(obj1, &val2);
14209 if (!SWIG_IsOK(ecode2)) {
14210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14211 }
14212 arg2 = static_cast< int >(val2);
14213 }
14214 {
14215 PyThreadState* __tstate = wxPyBeginAllowThreads();
14216 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14217 wxPyEndAllowThreads(__tstate);
14218 if (PyErr_Occurred()) SWIG_fail;
14219 }
14220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14221 {
14222 if (temp1)
14223 delete arg1;
14224 }
14225 return resultobj;
14226 fail:
14227 {
14228 if (temp1)
14229 delete arg1;
14230 }
14231 return NULL;
14232 }
14233
14234
14235 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14236 PyObject *resultobj = 0;
14237 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14238 int arg2 = (int) -1 ;
14239 wxPyProcess *result = 0 ;
14240 void *argp1 = 0 ;
14241 int res1 = 0 ;
14242 int val2 ;
14243 int ecode2 = 0 ;
14244 PyObject * obj0 = 0 ;
14245 PyObject * obj1 = 0 ;
14246 char * kwnames[] = {
14247 (char *) "parent",(char *) "id", NULL
14248 };
14249
14250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14251 if (obj0) {
14252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14253 if (!SWIG_IsOK(res1)) {
14254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14255 }
14256 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14257 }
14258 if (obj1) {
14259 ecode2 = SWIG_AsVal_int(obj1, &val2);
14260 if (!SWIG_IsOK(ecode2)) {
14261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14262 }
14263 arg2 = static_cast< int >(val2);
14264 }
14265 {
14266 PyThreadState* __tstate = wxPyBeginAllowThreads();
14267 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14268 wxPyEndAllowThreads(__tstate);
14269 if (PyErr_Occurred()) SWIG_fail;
14270 }
14271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14272 return resultobj;
14273 fail:
14274 return NULL;
14275 }
14276
14277
14278 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14279 PyObject *resultobj = 0;
14280 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14281 PyObject *arg2 = (PyObject *) 0 ;
14282 PyObject *arg3 = (PyObject *) 0 ;
14283 void *argp1 = 0 ;
14284 int res1 = 0 ;
14285 PyObject * obj0 = 0 ;
14286 PyObject * obj1 = 0 ;
14287 PyObject * obj2 = 0 ;
14288 char * kwnames[] = {
14289 (char *) "self",(char *) "self",(char *) "_class", NULL
14290 };
14291
14292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14294 if (!SWIG_IsOK(res1)) {
14295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14296 }
14297 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14298 arg2 = obj1;
14299 arg3 = obj2;
14300 {
14301 PyThreadState* __tstate = wxPyBeginAllowThreads();
14302 (arg1)->_setCallbackInfo(arg2,arg3);
14303 wxPyEndAllowThreads(__tstate);
14304 if (PyErr_Occurred()) SWIG_fail;
14305 }
14306 resultobj = SWIG_Py_Void();
14307 return resultobj;
14308 fail:
14309 return NULL;
14310 }
14311
14312
14313 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14314 PyObject *resultobj = 0;
14315 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14316 int arg2 ;
14317 int arg3 ;
14318 void *argp1 = 0 ;
14319 int res1 = 0 ;
14320 int val2 ;
14321 int ecode2 = 0 ;
14322 int val3 ;
14323 int ecode3 = 0 ;
14324 PyObject * obj0 = 0 ;
14325 PyObject * obj1 = 0 ;
14326 PyObject * obj2 = 0 ;
14327 char * kwnames[] = {
14328 (char *) "self",(char *) "pid",(char *) "status", NULL
14329 };
14330
14331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14333 if (!SWIG_IsOK(res1)) {
14334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14335 }
14336 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14337 ecode2 = SWIG_AsVal_int(obj1, &val2);
14338 if (!SWIG_IsOK(ecode2)) {
14339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14340 }
14341 arg2 = static_cast< int >(val2);
14342 ecode3 = SWIG_AsVal_int(obj2, &val3);
14343 if (!SWIG_IsOK(ecode3)) {
14344 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14345 }
14346 arg3 = static_cast< int >(val3);
14347 {
14348 PyThreadState* __tstate = wxPyBeginAllowThreads();
14349 (arg1)->OnTerminate(arg2,arg3);
14350 wxPyEndAllowThreads(__tstate);
14351 if (PyErr_Occurred()) SWIG_fail;
14352 }
14353 resultobj = SWIG_Py_Void();
14354 return resultobj;
14355 fail:
14356 return NULL;
14357 }
14358
14359
14360 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14361 PyObject *resultobj = 0;
14362 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14363 void *argp1 = 0 ;
14364 int res1 = 0 ;
14365 PyObject *swig_obj[1] ;
14366
14367 if (!args) SWIG_fail;
14368 swig_obj[0] = args;
14369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14370 if (!SWIG_IsOK(res1)) {
14371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14372 }
14373 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14374 {
14375 PyThreadState* __tstate = wxPyBeginAllowThreads();
14376 (arg1)->Redirect();
14377 wxPyEndAllowThreads(__tstate);
14378 if (PyErr_Occurred()) SWIG_fail;
14379 }
14380 resultobj = SWIG_Py_Void();
14381 return resultobj;
14382 fail:
14383 return NULL;
14384 }
14385
14386
14387 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14388 PyObject *resultobj = 0;
14389 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14390 bool result;
14391 void *argp1 = 0 ;
14392 int res1 = 0 ;
14393 PyObject *swig_obj[1] ;
14394
14395 if (!args) SWIG_fail;
14396 swig_obj[0] = args;
14397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14398 if (!SWIG_IsOK(res1)) {
14399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14400 }
14401 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14402 {
14403 PyThreadState* __tstate = wxPyBeginAllowThreads();
14404 result = (bool)(arg1)->IsRedirected();
14405 wxPyEndAllowThreads(__tstate);
14406 if (PyErr_Occurred()) SWIG_fail;
14407 }
14408 {
14409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14410 }
14411 return resultobj;
14412 fail:
14413 return NULL;
14414 }
14415
14416
14417 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14418 PyObject *resultobj = 0;
14419 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14420 void *argp1 = 0 ;
14421 int res1 = 0 ;
14422 PyObject *swig_obj[1] ;
14423
14424 if (!args) SWIG_fail;
14425 swig_obj[0] = args;
14426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14427 if (!SWIG_IsOK(res1)) {
14428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14429 }
14430 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14431 {
14432 PyThreadState* __tstate = wxPyBeginAllowThreads();
14433 (arg1)->Detach();
14434 wxPyEndAllowThreads(__tstate);
14435 if (PyErr_Occurred()) SWIG_fail;
14436 }
14437 resultobj = SWIG_Py_Void();
14438 return resultobj;
14439 fail:
14440 return NULL;
14441 }
14442
14443
14444 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14445 PyObject *resultobj = 0;
14446 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14447 wxInputStream *result = 0 ;
14448 void *argp1 = 0 ;
14449 int res1 = 0 ;
14450 PyObject *swig_obj[1] ;
14451
14452 if (!args) SWIG_fail;
14453 swig_obj[0] = args;
14454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14455 if (!SWIG_IsOK(res1)) {
14456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14457 }
14458 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14459 {
14460 PyThreadState* __tstate = wxPyBeginAllowThreads();
14461 result = (wxInputStream *)(arg1)->GetInputStream();
14462 wxPyEndAllowThreads(__tstate);
14463 if (PyErr_Occurred()) SWIG_fail;
14464 }
14465 {
14466 wxPyInputStream * _ptr = NULL;
14467
14468 if (result) {
14469 _ptr = new wxPyInputStream(result);
14470 }
14471 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14472 }
14473 return resultobj;
14474 fail:
14475 return NULL;
14476 }
14477
14478
14479 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14480 PyObject *resultobj = 0;
14481 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14482 wxInputStream *result = 0 ;
14483 void *argp1 = 0 ;
14484 int res1 = 0 ;
14485 PyObject *swig_obj[1] ;
14486
14487 if (!args) SWIG_fail;
14488 swig_obj[0] = args;
14489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14490 if (!SWIG_IsOK(res1)) {
14491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14492 }
14493 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14494 {
14495 PyThreadState* __tstate = wxPyBeginAllowThreads();
14496 result = (wxInputStream *)(arg1)->GetErrorStream();
14497 wxPyEndAllowThreads(__tstate);
14498 if (PyErr_Occurred()) SWIG_fail;
14499 }
14500 {
14501 wxPyInputStream * _ptr = NULL;
14502
14503 if (result) {
14504 _ptr = new wxPyInputStream(result);
14505 }
14506 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14507 }
14508 return resultobj;
14509 fail:
14510 return NULL;
14511 }
14512
14513
14514 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14515 PyObject *resultobj = 0;
14516 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14517 wxOutputStream *result = 0 ;
14518 void *argp1 = 0 ;
14519 int res1 = 0 ;
14520 PyObject *swig_obj[1] ;
14521
14522 if (!args) SWIG_fail;
14523 swig_obj[0] = args;
14524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14525 if (!SWIG_IsOK(res1)) {
14526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14527 }
14528 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14529 {
14530 PyThreadState* __tstate = wxPyBeginAllowThreads();
14531 result = (wxOutputStream *)(arg1)->GetOutputStream();
14532 wxPyEndAllowThreads(__tstate);
14533 if (PyErr_Occurred()) SWIG_fail;
14534 }
14535 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14536 return resultobj;
14537 fail:
14538 return NULL;
14539 }
14540
14541
14542 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14543 PyObject *resultobj = 0;
14544 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14545 void *argp1 = 0 ;
14546 int res1 = 0 ;
14547 PyObject *swig_obj[1] ;
14548
14549 if (!args) SWIG_fail;
14550 swig_obj[0] = args;
14551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14552 if (!SWIG_IsOK(res1)) {
14553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14554 }
14555 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14556 {
14557 PyThreadState* __tstate = wxPyBeginAllowThreads();
14558 (arg1)->CloseOutput();
14559 wxPyEndAllowThreads(__tstate);
14560 if (PyErr_Occurred()) SWIG_fail;
14561 }
14562 resultobj = SWIG_Py_Void();
14563 return resultobj;
14564 fail:
14565 return NULL;
14566 }
14567
14568
14569 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14570 PyObject *resultobj = 0;
14571 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14572 bool result;
14573 void *argp1 = 0 ;
14574 int res1 = 0 ;
14575 PyObject *swig_obj[1] ;
14576
14577 if (!args) SWIG_fail;
14578 swig_obj[0] = args;
14579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14580 if (!SWIG_IsOK(res1)) {
14581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14582 }
14583 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14584 {
14585 PyThreadState* __tstate = wxPyBeginAllowThreads();
14586 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14587 wxPyEndAllowThreads(__tstate);
14588 if (PyErr_Occurred()) SWIG_fail;
14589 }
14590 {
14591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14592 }
14593 return resultobj;
14594 fail:
14595 return NULL;
14596 }
14597
14598
14599 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14600 PyObject *resultobj = 0;
14601 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14602 bool result;
14603 void *argp1 = 0 ;
14604 int res1 = 0 ;
14605 PyObject *swig_obj[1] ;
14606
14607 if (!args) SWIG_fail;
14608 swig_obj[0] = args;
14609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14610 if (!SWIG_IsOK(res1)) {
14611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14612 }
14613 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14614 {
14615 PyThreadState* __tstate = wxPyBeginAllowThreads();
14616 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14617 wxPyEndAllowThreads(__tstate);
14618 if (PyErr_Occurred()) SWIG_fail;
14619 }
14620 {
14621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14622 }
14623 return resultobj;
14624 fail:
14625 return NULL;
14626 }
14627
14628
14629 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14630 PyObject *resultobj = 0;
14631 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14632 bool result;
14633 void *argp1 = 0 ;
14634 int res1 = 0 ;
14635 PyObject *swig_obj[1] ;
14636
14637 if (!args) SWIG_fail;
14638 swig_obj[0] = args;
14639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14640 if (!SWIG_IsOK(res1)) {
14641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14642 }
14643 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14644 {
14645 PyThreadState* __tstate = wxPyBeginAllowThreads();
14646 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14647 wxPyEndAllowThreads(__tstate);
14648 if (PyErr_Occurred()) SWIG_fail;
14649 }
14650 {
14651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14652 }
14653 return resultobj;
14654 fail:
14655 return NULL;
14656 }
14657
14658
14659 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14660 PyObject *obj;
14661 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14662 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14663 return SWIG_Py_Void();
14664 }
14665
14666 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14667 return SWIG_Python_InitShadowInstance(args);
14668 }
14669
14670 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14671 PyObject *resultobj = 0;
14672 int arg1 = (int) 0 ;
14673 int arg2 = (int) 0 ;
14674 int arg3 = (int) 0 ;
14675 wxProcessEvent *result = 0 ;
14676 int val1 ;
14677 int ecode1 = 0 ;
14678 int val2 ;
14679 int ecode2 = 0 ;
14680 int val3 ;
14681 int ecode3 = 0 ;
14682 PyObject * obj0 = 0 ;
14683 PyObject * obj1 = 0 ;
14684 PyObject * obj2 = 0 ;
14685 char * kwnames[] = {
14686 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14687 };
14688
14689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14690 if (obj0) {
14691 ecode1 = SWIG_AsVal_int(obj0, &val1);
14692 if (!SWIG_IsOK(ecode1)) {
14693 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14694 }
14695 arg1 = static_cast< int >(val1);
14696 }
14697 if (obj1) {
14698 ecode2 = SWIG_AsVal_int(obj1, &val2);
14699 if (!SWIG_IsOK(ecode2)) {
14700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14701 }
14702 arg2 = static_cast< int >(val2);
14703 }
14704 if (obj2) {
14705 ecode3 = SWIG_AsVal_int(obj2, &val3);
14706 if (!SWIG_IsOK(ecode3)) {
14707 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14708 }
14709 arg3 = static_cast< int >(val3);
14710 }
14711 {
14712 PyThreadState* __tstate = wxPyBeginAllowThreads();
14713 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14714 wxPyEndAllowThreads(__tstate);
14715 if (PyErr_Occurred()) SWIG_fail;
14716 }
14717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14718 return resultobj;
14719 fail:
14720 return NULL;
14721 }
14722
14723
14724 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14725 PyObject *resultobj = 0;
14726 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14727 int result;
14728 void *argp1 = 0 ;
14729 int res1 = 0 ;
14730 PyObject *swig_obj[1] ;
14731
14732 if (!args) SWIG_fail;
14733 swig_obj[0] = args;
14734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14735 if (!SWIG_IsOK(res1)) {
14736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14737 }
14738 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14739 {
14740 PyThreadState* __tstate = wxPyBeginAllowThreads();
14741 result = (int)(arg1)->GetPid();
14742 wxPyEndAllowThreads(__tstate);
14743 if (PyErr_Occurred()) SWIG_fail;
14744 }
14745 resultobj = SWIG_From_int(static_cast< int >(result));
14746 return resultobj;
14747 fail:
14748 return NULL;
14749 }
14750
14751
14752 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14753 PyObject *resultobj = 0;
14754 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14755 int result;
14756 void *argp1 = 0 ;
14757 int res1 = 0 ;
14758 PyObject *swig_obj[1] ;
14759
14760 if (!args) SWIG_fail;
14761 swig_obj[0] = args;
14762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14763 if (!SWIG_IsOK(res1)) {
14764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14765 }
14766 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14767 {
14768 PyThreadState* __tstate = wxPyBeginAllowThreads();
14769 result = (int)(arg1)->GetExitCode();
14770 wxPyEndAllowThreads(__tstate);
14771 if (PyErr_Occurred()) SWIG_fail;
14772 }
14773 resultobj = SWIG_From_int(static_cast< int >(result));
14774 return resultobj;
14775 fail:
14776 return NULL;
14777 }
14778
14779
14780 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14781 PyObject *resultobj = 0;
14782 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14783 int arg2 ;
14784 void *argp1 = 0 ;
14785 int res1 = 0 ;
14786 int val2 ;
14787 int ecode2 = 0 ;
14788 PyObject *swig_obj[2] ;
14789
14790 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14792 if (!SWIG_IsOK(res1)) {
14793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14794 }
14795 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14796 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14797 if (!SWIG_IsOK(ecode2)) {
14798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
14799 }
14800 arg2 = static_cast< int >(val2);
14801 if (arg1) (arg1)->m_pid = arg2;
14802
14803 resultobj = SWIG_Py_Void();
14804 return resultobj;
14805 fail:
14806 return NULL;
14807 }
14808
14809
14810 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14811 PyObject *resultobj = 0;
14812 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14813 int result;
14814 void *argp1 = 0 ;
14815 int res1 = 0 ;
14816 PyObject *swig_obj[1] ;
14817
14818 if (!args) SWIG_fail;
14819 swig_obj[0] = args;
14820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14821 if (!SWIG_IsOK(res1)) {
14822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14823 }
14824 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14825 result = (int) ((arg1)->m_pid);
14826 resultobj = SWIG_From_int(static_cast< int >(result));
14827 return resultobj;
14828 fail:
14829 return NULL;
14830 }
14831
14832
14833 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14834 PyObject *resultobj = 0;
14835 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14836 int arg2 ;
14837 void *argp1 = 0 ;
14838 int res1 = 0 ;
14839 int val2 ;
14840 int ecode2 = 0 ;
14841 PyObject *swig_obj[2] ;
14842
14843 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
14844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14845 if (!SWIG_IsOK(res1)) {
14846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14847 }
14848 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14849 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14850 if (!SWIG_IsOK(ecode2)) {
14851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
14852 }
14853 arg2 = static_cast< int >(val2);
14854 if (arg1) (arg1)->m_exitcode = arg2;
14855
14856 resultobj = SWIG_Py_Void();
14857 return resultobj;
14858 fail:
14859 return NULL;
14860 }
14861
14862
14863 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14864 PyObject *resultobj = 0;
14865 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14866 int result;
14867 void *argp1 = 0 ;
14868 int res1 = 0 ;
14869 PyObject *swig_obj[1] ;
14870
14871 if (!args) SWIG_fail;
14872 swig_obj[0] = args;
14873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14874 if (!SWIG_IsOK(res1)) {
14875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14876 }
14877 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14878 result = (int) ((arg1)->m_exitcode);
14879 resultobj = SWIG_From_int(static_cast< int >(result));
14880 return resultobj;
14881 fail:
14882 return NULL;
14883 }
14884
14885
14886 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14887 PyObject *obj;
14888 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14889 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
14890 return SWIG_Py_Void();
14891 }
14892
14893 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14894 return SWIG_Python_InitShadowInstance(args);
14895 }
14896
14897 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14898 PyObject *resultobj = 0;
14899 wxString *arg1 = 0 ;
14900 int arg2 = (int) wxEXEC_ASYNC ;
14901 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
14902 long result;
14903 bool temp1 = false ;
14904 int val2 ;
14905 int ecode2 = 0 ;
14906 void *argp3 = 0 ;
14907 int res3 = 0 ;
14908 PyObject * obj0 = 0 ;
14909 PyObject * obj1 = 0 ;
14910 PyObject * obj2 = 0 ;
14911 char * kwnames[] = {
14912 (char *) "command",(char *) "flags",(char *) "process", NULL
14913 };
14914
14915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14916 {
14917 arg1 = wxString_in_helper(obj0);
14918 if (arg1 == NULL) SWIG_fail;
14919 temp1 = true;
14920 }
14921 if (obj1) {
14922 ecode2 = SWIG_AsVal_int(obj1, &val2);
14923 if (!SWIG_IsOK(ecode2)) {
14924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
14925 }
14926 arg2 = static_cast< int >(val2);
14927 }
14928 if (obj2) {
14929 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14930 if (!SWIG_IsOK(res3)) {
14931 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
14932 }
14933 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
14934 }
14935 {
14936 if (!wxPyCheckForApp()) SWIG_fail;
14937 PyThreadState* __tstate = wxPyBeginAllowThreads();
14938 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
14939 wxPyEndAllowThreads(__tstate);
14940 if (PyErr_Occurred()) SWIG_fail;
14941 }
14942 resultobj = SWIG_From_long(static_cast< long >(result));
14943 {
14944 if (temp1)
14945 delete arg1;
14946 }
14947 return resultobj;
14948 fail:
14949 {
14950 if (temp1)
14951 delete arg1;
14952 }
14953 return NULL;
14954 }
14955
14956
14957 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14958 PyObject *resultobj = 0;
14959 long arg1 ;
14960 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14961 wxKillError *arg3 = (wxKillError *) 0 ;
14962 int arg4 = (int) wxKILL_NOCHILDREN ;
14963 int result;
14964 long val1 ;
14965 int ecode1 = 0 ;
14966 int val2 ;
14967 int ecode2 = 0 ;
14968 wxKillError temp3 ;
14969 int val4 ;
14970 int ecode4 = 0 ;
14971 PyObject * obj0 = 0 ;
14972 PyObject * obj1 = 0 ;
14973 PyObject * obj2 = 0 ;
14974 char * kwnames[] = {
14975 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14976 };
14977
14978 {
14979 arg3 = &temp3;
14980 }
14981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14982 ecode1 = SWIG_AsVal_long(obj0, &val1);
14983 if (!SWIG_IsOK(ecode1)) {
14984 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
14985 }
14986 arg1 = static_cast< long >(val1);
14987 if (obj1) {
14988 ecode2 = SWIG_AsVal_int(obj1, &val2);
14989 if (!SWIG_IsOK(ecode2)) {
14990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14991 }
14992 arg2 = static_cast< wxSignal >(val2);
14993 }
14994 if (obj2) {
14995 ecode4 = SWIG_AsVal_int(obj2, &val4);
14996 if (!SWIG_IsOK(ecode4)) {
14997 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
14998 }
14999 arg4 = static_cast< int >(val4);
15000 }
15001 {
15002 PyThreadState* __tstate = wxPyBeginAllowThreads();
15003 result = (int)wxKill(arg1,arg2,arg3,arg4);
15004 wxPyEndAllowThreads(__tstate);
15005 if (PyErr_Occurred()) SWIG_fail;
15006 }
15007 resultobj = SWIG_From_int(static_cast< int >(result));
15008 {
15009 PyObject* o;
15010 o = PyInt_FromLong((long) (*arg3));
15011
15012
15013
15014 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15015
15016 }
15017 return resultobj;
15018 fail:
15019 return NULL;
15020 }
15021
15022
15023 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15024 PyObject *resultobj = 0;
15025 int arg1 = (int) wxJOYSTICK1 ;
15026 wxJoystick *result = 0 ;
15027 int val1 ;
15028 int ecode1 = 0 ;
15029 PyObject * obj0 = 0 ;
15030 char * kwnames[] = {
15031 (char *) "joystick", NULL
15032 };
15033
15034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15035 if (obj0) {
15036 ecode1 = SWIG_AsVal_int(obj0, &val1);
15037 if (!SWIG_IsOK(ecode1)) {
15038 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15039 }
15040 arg1 = static_cast< int >(val1);
15041 }
15042 {
15043 if (!wxPyCheckForApp()) SWIG_fail;
15044 PyThreadState* __tstate = wxPyBeginAllowThreads();
15045 result = (wxJoystick *)new wxJoystick(arg1);
15046 wxPyEndAllowThreads(__tstate);
15047 if (PyErr_Occurred()) SWIG_fail;
15048 }
15049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15050 return resultobj;
15051 fail:
15052 return NULL;
15053 }
15054
15055
15056 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15057 PyObject *resultobj = 0;
15058 wxJoystick *arg1 = (wxJoystick *) 0 ;
15059 void *argp1 = 0 ;
15060 int res1 = 0 ;
15061 PyObject *swig_obj[1] ;
15062
15063 if (!args) SWIG_fail;
15064 swig_obj[0] = args;
15065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15066 if (!SWIG_IsOK(res1)) {
15067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15068 }
15069 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15070 {
15071 PyThreadState* __tstate = wxPyBeginAllowThreads();
15072 delete arg1;
15073
15074 wxPyEndAllowThreads(__tstate);
15075 if (PyErr_Occurred()) SWIG_fail;
15076 }
15077 resultobj = SWIG_Py_Void();
15078 return resultobj;
15079 fail:
15080 return NULL;
15081 }
15082
15083
15084 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15085 PyObject *resultobj = 0;
15086 wxJoystick *arg1 = (wxJoystick *) 0 ;
15087 wxPoint result;
15088 void *argp1 = 0 ;
15089 int res1 = 0 ;
15090 PyObject *swig_obj[1] ;
15091
15092 if (!args) SWIG_fail;
15093 swig_obj[0] = args;
15094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15095 if (!SWIG_IsOK(res1)) {
15096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15097 }
15098 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15099 {
15100 PyThreadState* __tstate = wxPyBeginAllowThreads();
15101 result = (arg1)->GetPosition();
15102 wxPyEndAllowThreads(__tstate);
15103 if (PyErr_Occurred()) SWIG_fail;
15104 }
15105 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15106 return resultobj;
15107 fail:
15108 return NULL;
15109 }
15110
15111
15112 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15113 PyObject *resultobj = 0;
15114 wxJoystick *arg1 = (wxJoystick *) 0 ;
15115 int result;
15116 void *argp1 = 0 ;
15117 int res1 = 0 ;
15118 PyObject *swig_obj[1] ;
15119
15120 if (!args) SWIG_fail;
15121 swig_obj[0] = args;
15122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15123 if (!SWIG_IsOK(res1)) {
15124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15125 }
15126 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15127 {
15128 PyThreadState* __tstate = wxPyBeginAllowThreads();
15129 result = (int)(arg1)->GetZPosition();
15130 wxPyEndAllowThreads(__tstate);
15131 if (PyErr_Occurred()) SWIG_fail;
15132 }
15133 resultobj = SWIG_From_int(static_cast< int >(result));
15134 return resultobj;
15135 fail:
15136 return NULL;
15137 }
15138
15139
15140 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15141 PyObject *resultobj = 0;
15142 wxJoystick *arg1 = (wxJoystick *) 0 ;
15143 int result;
15144 void *argp1 = 0 ;
15145 int res1 = 0 ;
15146 PyObject *swig_obj[1] ;
15147
15148 if (!args) SWIG_fail;
15149 swig_obj[0] = args;
15150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15151 if (!SWIG_IsOK(res1)) {
15152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15153 }
15154 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15155 {
15156 PyThreadState* __tstate = wxPyBeginAllowThreads();
15157 result = (int)(arg1)->GetButtonState();
15158 wxPyEndAllowThreads(__tstate);
15159 if (PyErr_Occurred()) SWIG_fail;
15160 }
15161 resultobj = SWIG_From_int(static_cast< int >(result));
15162 return resultobj;
15163 fail:
15164 return NULL;
15165 }
15166
15167
15168 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15169 PyObject *resultobj = 0;
15170 wxJoystick *arg1 = (wxJoystick *) 0 ;
15171 int result;
15172 void *argp1 = 0 ;
15173 int res1 = 0 ;
15174 PyObject *swig_obj[1] ;
15175
15176 if (!args) SWIG_fail;
15177 swig_obj[0] = args;
15178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15179 if (!SWIG_IsOK(res1)) {
15180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15181 }
15182 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15183 {
15184 PyThreadState* __tstate = wxPyBeginAllowThreads();
15185 result = (int)(arg1)->GetPOVPosition();
15186 wxPyEndAllowThreads(__tstate);
15187 if (PyErr_Occurred()) SWIG_fail;
15188 }
15189 resultobj = SWIG_From_int(static_cast< int >(result));
15190 return resultobj;
15191 fail:
15192 return NULL;
15193 }
15194
15195
15196 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15197 PyObject *resultobj = 0;
15198 wxJoystick *arg1 = (wxJoystick *) 0 ;
15199 int result;
15200 void *argp1 = 0 ;
15201 int res1 = 0 ;
15202 PyObject *swig_obj[1] ;
15203
15204 if (!args) SWIG_fail;
15205 swig_obj[0] = args;
15206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15207 if (!SWIG_IsOK(res1)) {
15208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15209 }
15210 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15211 {
15212 PyThreadState* __tstate = wxPyBeginAllowThreads();
15213 result = (int)(arg1)->GetPOVCTSPosition();
15214 wxPyEndAllowThreads(__tstate);
15215 if (PyErr_Occurred()) SWIG_fail;
15216 }
15217 resultobj = SWIG_From_int(static_cast< int >(result));
15218 return resultobj;
15219 fail:
15220 return NULL;
15221 }
15222
15223
15224 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15225 PyObject *resultobj = 0;
15226 wxJoystick *arg1 = (wxJoystick *) 0 ;
15227 int result;
15228 void *argp1 = 0 ;
15229 int res1 = 0 ;
15230 PyObject *swig_obj[1] ;
15231
15232 if (!args) SWIG_fail;
15233 swig_obj[0] = args;
15234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15235 if (!SWIG_IsOK(res1)) {
15236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15237 }
15238 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15239 {
15240 PyThreadState* __tstate = wxPyBeginAllowThreads();
15241 result = (int)(arg1)->GetRudderPosition();
15242 wxPyEndAllowThreads(__tstate);
15243 if (PyErr_Occurred()) SWIG_fail;
15244 }
15245 resultobj = SWIG_From_int(static_cast< int >(result));
15246 return resultobj;
15247 fail:
15248 return NULL;
15249 }
15250
15251
15252 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15253 PyObject *resultobj = 0;
15254 wxJoystick *arg1 = (wxJoystick *) 0 ;
15255 int result;
15256 void *argp1 = 0 ;
15257 int res1 = 0 ;
15258 PyObject *swig_obj[1] ;
15259
15260 if (!args) SWIG_fail;
15261 swig_obj[0] = args;
15262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15263 if (!SWIG_IsOK(res1)) {
15264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15265 }
15266 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15267 {
15268 PyThreadState* __tstate = wxPyBeginAllowThreads();
15269 result = (int)(arg1)->GetUPosition();
15270 wxPyEndAllowThreads(__tstate);
15271 if (PyErr_Occurred()) SWIG_fail;
15272 }
15273 resultobj = SWIG_From_int(static_cast< int >(result));
15274 return resultobj;
15275 fail:
15276 return NULL;
15277 }
15278
15279
15280 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15281 PyObject *resultobj = 0;
15282 wxJoystick *arg1 = (wxJoystick *) 0 ;
15283 int result;
15284 void *argp1 = 0 ;
15285 int res1 = 0 ;
15286 PyObject *swig_obj[1] ;
15287
15288 if (!args) SWIG_fail;
15289 swig_obj[0] = args;
15290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15291 if (!SWIG_IsOK(res1)) {
15292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15293 }
15294 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15295 {
15296 PyThreadState* __tstate = wxPyBeginAllowThreads();
15297 result = (int)(arg1)->GetVPosition();
15298 wxPyEndAllowThreads(__tstate);
15299 if (PyErr_Occurred()) SWIG_fail;
15300 }
15301 resultobj = SWIG_From_int(static_cast< int >(result));
15302 return resultobj;
15303 fail:
15304 return NULL;
15305 }
15306
15307
15308 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15309 PyObject *resultobj = 0;
15310 wxJoystick *arg1 = (wxJoystick *) 0 ;
15311 int result;
15312 void *argp1 = 0 ;
15313 int res1 = 0 ;
15314 PyObject *swig_obj[1] ;
15315
15316 if (!args) SWIG_fail;
15317 swig_obj[0] = args;
15318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15319 if (!SWIG_IsOK(res1)) {
15320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15321 }
15322 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15323 {
15324 PyThreadState* __tstate = wxPyBeginAllowThreads();
15325 result = (int)(arg1)->GetMovementThreshold();
15326 wxPyEndAllowThreads(__tstate);
15327 if (PyErr_Occurred()) SWIG_fail;
15328 }
15329 resultobj = SWIG_From_int(static_cast< int >(result));
15330 return resultobj;
15331 fail:
15332 return NULL;
15333 }
15334
15335
15336 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15337 PyObject *resultobj = 0;
15338 wxJoystick *arg1 = (wxJoystick *) 0 ;
15339 int arg2 ;
15340 void *argp1 = 0 ;
15341 int res1 = 0 ;
15342 int val2 ;
15343 int ecode2 = 0 ;
15344 PyObject * obj0 = 0 ;
15345 PyObject * obj1 = 0 ;
15346 char * kwnames[] = {
15347 (char *) "self",(char *) "threshold", NULL
15348 };
15349
15350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15352 if (!SWIG_IsOK(res1)) {
15353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15354 }
15355 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15356 ecode2 = SWIG_AsVal_int(obj1, &val2);
15357 if (!SWIG_IsOK(ecode2)) {
15358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15359 }
15360 arg2 = static_cast< int >(val2);
15361 {
15362 PyThreadState* __tstate = wxPyBeginAllowThreads();
15363 (arg1)->SetMovementThreshold(arg2);
15364 wxPyEndAllowThreads(__tstate);
15365 if (PyErr_Occurred()) SWIG_fail;
15366 }
15367 resultobj = SWIG_Py_Void();
15368 return resultobj;
15369 fail:
15370 return NULL;
15371 }
15372
15373
15374 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15375 PyObject *resultobj = 0;
15376 wxJoystick *arg1 = (wxJoystick *) 0 ;
15377 bool result;
15378 void *argp1 = 0 ;
15379 int res1 = 0 ;
15380 PyObject *swig_obj[1] ;
15381
15382 if (!args) SWIG_fail;
15383 swig_obj[0] = args;
15384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15385 if (!SWIG_IsOK(res1)) {
15386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15387 }
15388 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15389 {
15390 PyThreadState* __tstate = wxPyBeginAllowThreads();
15391 result = (bool)(arg1)->IsOk();
15392 wxPyEndAllowThreads(__tstate);
15393 if (PyErr_Occurred()) SWIG_fail;
15394 }
15395 {
15396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15397 }
15398 return resultobj;
15399 fail:
15400 return NULL;
15401 }
15402
15403
15404 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15405 PyObject *resultobj = 0;
15406 wxJoystick *arg1 = (wxJoystick *) 0 ;
15407 int result;
15408 void *argp1 = 0 ;
15409 int res1 = 0 ;
15410 PyObject *swig_obj[1] ;
15411
15412 if (!args) SWIG_fail;
15413 swig_obj[0] = args;
15414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15415 if (!SWIG_IsOK(res1)) {
15416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15417 }
15418 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15419 {
15420 PyThreadState* __tstate = wxPyBeginAllowThreads();
15421 result = (int)(arg1)->GetNumberJoysticks();
15422 wxPyEndAllowThreads(__tstate);
15423 if (PyErr_Occurred()) SWIG_fail;
15424 }
15425 resultobj = SWIG_From_int(static_cast< int >(result));
15426 return resultobj;
15427 fail:
15428 return NULL;
15429 }
15430
15431
15432 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15433 PyObject *resultobj = 0;
15434 wxJoystick *arg1 = (wxJoystick *) 0 ;
15435 int result;
15436 void *argp1 = 0 ;
15437 int res1 = 0 ;
15438 PyObject *swig_obj[1] ;
15439
15440 if (!args) SWIG_fail;
15441 swig_obj[0] = args;
15442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15443 if (!SWIG_IsOK(res1)) {
15444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15445 }
15446 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15447 {
15448 PyThreadState* __tstate = wxPyBeginAllowThreads();
15449 result = (int)(arg1)->GetManufacturerId();
15450 wxPyEndAllowThreads(__tstate);
15451 if (PyErr_Occurred()) SWIG_fail;
15452 }
15453 resultobj = SWIG_From_int(static_cast< int >(result));
15454 return resultobj;
15455 fail:
15456 return NULL;
15457 }
15458
15459
15460 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15461 PyObject *resultobj = 0;
15462 wxJoystick *arg1 = (wxJoystick *) 0 ;
15463 int result;
15464 void *argp1 = 0 ;
15465 int res1 = 0 ;
15466 PyObject *swig_obj[1] ;
15467
15468 if (!args) SWIG_fail;
15469 swig_obj[0] = args;
15470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15471 if (!SWIG_IsOK(res1)) {
15472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15473 }
15474 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15475 {
15476 PyThreadState* __tstate = wxPyBeginAllowThreads();
15477 result = (int)(arg1)->GetProductId();
15478 wxPyEndAllowThreads(__tstate);
15479 if (PyErr_Occurred()) SWIG_fail;
15480 }
15481 resultobj = SWIG_From_int(static_cast< int >(result));
15482 return resultobj;
15483 fail:
15484 return NULL;
15485 }
15486
15487
15488 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15489 PyObject *resultobj = 0;
15490 wxJoystick *arg1 = (wxJoystick *) 0 ;
15491 wxString result;
15492 void *argp1 = 0 ;
15493 int res1 = 0 ;
15494 PyObject *swig_obj[1] ;
15495
15496 if (!args) SWIG_fail;
15497 swig_obj[0] = args;
15498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15499 if (!SWIG_IsOK(res1)) {
15500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15501 }
15502 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15503 {
15504 PyThreadState* __tstate = wxPyBeginAllowThreads();
15505 result = (arg1)->GetProductName();
15506 wxPyEndAllowThreads(__tstate);
15507 if (PyErr_Occurred()) SWIG_fail;
15508 }
15509 {
15510 #if wxUSE_UNICODE
15511 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15512 #else
15513 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15514 #endif
15515 }
15516 return resultobj;
15517 fail:
15518 return NULL;
15519 }
15520
15521
15522 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15523 PyObject *resultobj = 0;
15524 wxJoystick *arg1 = (wxJoystick *) 0 ;
15525 int result;
15526 void *argp1 = 0 ;
15527 int res1 = 0 ;
15528 PyObject *swig_obj[1] ;
15529
15530 if (!args) SWIG_fail;
15531 swig_obj[0] = args;
15532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15533 if (!SWIG_IsOK(res1)) {
15534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15535 }
15536 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15537 {
15538 PyThreadState* __tstate = wxPyBeginAllowThreads();
15539 result = (int)(arg1)->GetXMin();
15540 wxPyEndAllowThreads(__tstate);
15541 if (PyErr_Occurred()) SWIG_fail;
15542 }
15543 resultobj = SWIG_From_int(static_cast< int >(result));
15544 return resultobj;
15545 fail:
15546 return NULL;
15547 }
15548
15549
15550 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15551 PyObject *resultobj = 0;
15552 wxJoystick *arg1 = (wxJoystick *) 0 ;
15553 int result;
15554 void *argp1 = 0 ;
15555 int res1 = 0 ;
15556 PyObject *swig_obj[1] ;
15557
15558 if (!args) SWIG_fail;
15559 swig_obj[0] = args;
15560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15561 if (!SWIG_IsOK(res1)) {
15562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15563 }
15564 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15565 {
15566 PyThreadState* __tstate = wxPyBeginAllowThreads();
15567 result = (int)(arg1)->GetYMin();
15568 wxPyEndAllowThreads(__tstate);
15569 if (PyErr_Occurred()) SWIG_fail;
15570 }
15571 resultobj = SWIG_From_int(static_cast< int >(result));
15572 return resultobj;
15573 fail:
15574 return NULL;
15575 }
15576
15577
15578 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15579 PyObject *resultobj = 0;
15580 wxJoystick *arg1 = (wxJoystick *) 0 ;
15581 int result;
15582 void *argp1 = 0 ;
15583 int res1 = 0 ;
15584 PyObject *swig_obj[1] ;
15585
15586 if (!args) SWIG_fail;
15587 swig_obj[0] = args;
15588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15589 if (!SWIG_IsOK(res1)) {
15590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15591 }
15592 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15593 {
15594 PyThreadState* __tstate = wxPyBeginAllowThreads();
15595 result = (int)(arg1)->GetZMin();
15596 wxPyEndAllowThreads(__tstate);
15597 if (PyErr_Occurred()) SWIG_fail;
15598 }
15599 resultobj = SWIG_From_int(static_cast< int >(result));
15600 return resultobj;
15601 fail:
15602 return NULL;
15603 }
15604
15605
15606 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15607 PyObject *resultobj = 0;
15608 wxJoystick *arg1 = (wxJoystick *) 0 ;
15609 int result;
15610 void *argp1 = 0 ;
15611 int res1 = 0 ;
15612 PyObject *swig_obj[1] ;
15613
15614 if (!args) SWIG_fail;
15615 swig_obj[0] = args;
15616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15617 if (!SWIG_IsOK(res1)) {
15618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15619 }
15620 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15621 {
15622 PyThreadState* __tstate = wxPyBeginAllowThreads();
15623 result = (int)(arg1)->GetXMax();
15624 wxPyEndAllowThreads(__tstate);
15625 if (PyErr_Occurred()) SWIG_fail;
15626 }
15627 resultobj = SWIG_From_int(static_cast< int >(result));
15628 return resultobj;
15629 fail:
15630 return NULL;
15631 }
15632
15633
15634 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15635 PyObject *resultobj = 0;
15636 wxJoystick *arg1 = (wxJoystick *) 0 ;
15637 int result;
15638 void *argp1 = 0 ;
15639 int res1 = 0 ;
15640 PyObject *swig_obj[1] ;
15641
15642 if (!args) SWIG_fail;
15643 swig_obj[0] = args;
15644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15645 if (!SWIG_IsOK(res1)) {
15646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15647 }
15648 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15649 {
15650 PyThreadState* __tstate = wxPyBeginAllowThreads();
15651 result = (int)(arg1)->GetYMax();
15652 wxPyEndAllowThreads(__tstate);
15653 if (PyErr_Occurred()) SWIG_fail;
15654 }
15655 resultobj = SWIG_From_int(static_cast< int >(result));
15656 return resultobj;
15657 fail:
15658 return NULL;
15659 }
15660
15661
15662 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15663 PyObject *resultobj = 0;
15664 wxJoystick *arg1 = (wxJoystick *) 0 ;
15665 int result;
15666 void *argp1 = 0 ;
15667 int res1 = 0 ;
15668 PyObject *swig_obj[1] ;
15669
15670 if (!args) SWIG_fail;
15671 swig_obj[0] = args;
15672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15673 if (!SWIG_IsOK(res1)) {
15674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15675 }
15676 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15677 {
15678 PyThreadState* __tstate = wxPyBeginAllowThreads();
15679 result = (int)(arg1)->GetZMax();
15680 wxPyEndAllowThreads(__tstate);
15681 if (PyErr_Occurred()) SWIG_fail;
15682 }
15683 resultobj = SWIG_From_int(static_cast< int >(result));
15684 return resultobj;
15685 fail:
15686 return NULL;
15687 }
15688
15689
15690 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15691 PyObject *resultobj = 0;
15692 wxJoystick *arg1 = (wxJoystick *) 0 ;
15693 int result;
15694 void *argp1 = 0 ;
15695 int res1 = 0 ;
15696 PyObject *swig_obj[1] ;
15697
15698 if (!args) SWIG_fail;
15699 swig_obj[0] = args;
15700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15701 if (!SWIG_IsOK(res1)) {
15702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15703 }
15704 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15705 {
15706 PyThreadState* __tstate = wxPyBeginAllowThreads();
15707 result = (int)(arg1)->GetNumberButtons();
15708 wxPyEndAllowThreads(__tstate);
15709 if (PyErr_Occurred()) SWIG_fail;
15710 }
15711 resultobj = SWIG_From_int(static_cast< int >(result));
15712 return resultobj;
15713 fail:
15714 return NULL;
15715 }
15716
15717
15718 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15719 PyObject *resultobj = 0;
15720 wxJoystick *arg1 = (wxJoystick *) 0 ;
15721 int result;
15722 void *argp1 = 0 ;
15723 int res1 = 0 ;
15724 PyObject *swig_obj[1] ;
15725
15726 if (!args) SWIG_fail;
15727 swig_obj[0] = args;
15728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15729 if (!SWIG_IsOK(res1)) {
15730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15731 }
15732 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15733 {
15734 PyThreadState* __tstate = wxPyBeginAllowThreads();
15735 result = (int)(arg1)->GetNumberAxes();
15736 wxPyEndAllowThreads(__tstate);
15737 if (PyErr_Occurred()) SWIG_fail;
15738 }
15739 resultobj = SWIG_From_int(static_cast< int >(result));
15740 return resultobj;
15741 fail:
15742 return NULL;
15743 }
15744
15745
15746 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15747 PyObject *resultobj = 0;
15748 wxJoystick *arg1 = (wxJoystick *) 0 ;
15749 int result;
15750 void *argp1 = 0 ;
15751 int res1 = 0 ;
15752 PyObject *swig_obj[1] ;
15753
15754 if (!args) SWIG_fail;
15755 swig_obj[0] = args;
15756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15757 if (!SWIG_IsOK(res1)) {
15758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15759 }
15760 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15761 {
15762 PyThreadState* __tstate = wxPyBeginAllowThreads();
15763 result = (int)(arg1)->GetMaxButtons();
15764 wxPyEndAllowThreads(__tstate);
15765 if (PyErr_Occurred()) SWIG_fail;
15766 }
15767 resultobj = SWIG_From_int(static_cast< int >(result));
15768 return resultobj;
15769 fail:
15770 return NULL;
15771 }
15772
15773
15774 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15775 PyObject *resultobj = 0;
15776 wxJoystick *arg1 = (wxJoystick *) 0 ;
15777 int result;
15778 void *argp1 = 0 ;
15779 int res1 = 0 ;
15780 PyObject *swig_obj[1] ;
15781
15782 if (!args) SWIG_fail;
15783 swig_obj[0] = args;
15784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15785 if (!SWIG_IsOK(res1)) {
15786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15787 }
15788 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15789 {
15790 PyThreadState* __tstate = wxPyBeginAllowThreads();
15791 result = (int)(arg1)->GetMaxAxes();
15792 wxPyEndAllowThreads(__tstate);
15793 if (PyErr_Occurred()) SWIG_fail;
15794 }
15795 resultobj = SWIG_From_int(static_cast< int >(result));
15796 return resultobj;
15797 fail:
15798 return NULL;
15799 }
15800
15801
15802 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15803 PyObject *resultobj = 0;
15804 wxJoystick *arg1 = (wxJoystick *) 0 ;
15805 int result;
15806 void *argp1 = 0 ;
15807 int res1 = 0 ;
15808 PyObject *swig_obj[1] ;
15809
15810 if (!args) SWIG_fail;
15811 swig_obj[0] = args;
15812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15813 if (!SWIG_IsOK(res1)) {
15814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15815 }
15816 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15817 {
15818 PyThreadState* __tstate = wxPyBeginAllowThreads();
15819 result = (int)(arg1)->GetPollingMin();
15820 wxPyEndAllowThreads(__tstate);
15821 if (PyErr_Occurred()) SWIG_fail;
15822 }
15823 resultobj = SWIG_From_int(static_cast< int >(result));
15824 return resultobj;
15825 fail:
15826 return NULL;
15827 }
15828
15829
15830 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15831 PyObject *resultobj = 0;
15832 wxJoystick *arg1 = (wxJoystick *) 0 ;
15833 int result;
15834 void *argp1 = 0 ;
15835 int res1 = 0 ;
15836 PyObject *swig_obj[1] ;
15837
15838 if (!args) SWIG_fail;
15839 swig_obj[0] = args;
15840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15841 if (!SWIG_IsOK(res1)) {
15842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15843 }
15844 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15845 {
15846 PyThreadState* __tstate = wxPyBeginAllowThreads();
15847 result = (int)(arg1)->GetPollingMax();
15848 wxPyEndAllowThreads(__tstate);
15849 if (PyErr_Occurred()) SWIG_fail;
15850 }
15851 resultobj = SWIG_From_int(static_cast< int >(result));
15852 return resultobj;
15853 fail:
15854 return NULL;
15855 }
15856
15857
15858 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15859 PyObject *resultobj = 0;
15860 wxJoystick *arg1 = (wxJoystick *) 0 ;
15861 int result;
15862 void *argp1 = 0 ;
15863 int res1 = 0 ;
15864 PyObject *swig_obj[1] ;
15865
15866 if (!args) SWIG_fail;
15867 swig_obj[0] = args;
15868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15869 if (!SWIG_IsOK(res1)) {
15870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15871 }
15872 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15873 {
15874 PyThreadState* __tstate = wxPyBeginAllowThreads();
15875 result = (int)(arg1)->GetRudderMin();
15876 wxPyEndAllowThreads(__tstate);
15877 if (PyErr_Occurred()) SWIG_fail;
15878 }
15879 resultobj = SWIG_From_int(static_cast< int >(result));
15880 return resultobj;
15881 fail:
15882 return NULL;
15883 }
15884
15885
15886 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15887 PyObject *resultobj = 0;
15888 wxJoystick *arg1 = (wxJoystick *) 0 ;
15889 int result;
15890 void *argp1 = 0 ;
15891 int res1 = 0 ;
15892 PyObject *swig_obj[1] ;
15893
15894 if (!args) SWIG_fail;
15895 swig_obj[0] = args;
15896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15897 if (!SWIG_IsOK(res1)) {
15898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15899 }
15900 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15901 {
15902 PyThreadState* __tstate = wxPyBeginAllowThreads();
15903 result = (int)(arg1)->GetRudderMax();
15904 wxPyEndAllowThreads(__tstate);
15905 if (PyErr_Occurred()) SWIG_fail;
15906 }
15907 resultobj = SWIG_From_int(static_cast< int >(result));
15908 return resultobj;
15909 fail:
15910 return NULL;
15911 }
15912
15913
15914 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15915 PyObject *resultobj = 0;
15916 wxJoystick *arg1 = (wxJoystick *) 0 ;
15917 int result;
15918 void *argp1 = 0 ;
15919 int res1 = 0 ;
15920 PyObject *swig_obj[1] ;
15921
15922 if (!args) SWIG_fail;
15923 swig_obj[0] = args;
15924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15925 if (!SWIG_IsOK(res1)) {
15926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15927 }
15928 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15929 {
15930 PyThreadState* __tstate = wxPyBeginAllowThreads();
15931 result = (int)(arg1)->GetUMin();
15932 wxPyEndAllowThreads(__tstate);
15933 if (PyErr_Occurred()) SWIG_fail;
15934 }
15935 resultobj = SWIG_From_int(static_cast< int >(result));
15936 return resultobj;
15937 fail:
15938 return NULL;
15939 }
15940
15941
15942 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15943 PyObject *resultobj = 0;
15944 wxJoystick *arg1 = (wxJoystick *) 0 ;
15945 int result;
15946 void *argp1 = 0 ;
15947 int res1 = 0 ;
15948 PyObject *swig_obj[1] ;
15949
15950 if (!args) SWIG_fail;
15951 swig_obj[0] = args;
15952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15953 if (!SWIG_IsOK(res1)) {
15954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15955 }
15956 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15957 {
15958 PyThreadState* __tstate = wxPyBeginAllowThreads();
15959 result = (int)(arg1)->GetUMax();
15960 wxPyEndAllowThreads(__tstate);
15961 if (PyErr_Occurred()) SWIG_fail;
15962 }
15963 resultobj = SWIG_From_int(static_cast< int >(result));
15964 return resultobj;
15965 fail:
15966 return NULL;
15967 }
15968
15969
15970 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15971 PyObject *resultobj = 0;
15972 wxJoystick *arg1 = (wxJoystick *) 0 ;
15973 int result;
15974 void *argp1 = 0 ;
15975 int res1 = 0 ;
15976 PyObject *swig_obj[1] ;
15977
15978 if (!args) SWIG_fail;
15979 swig_obj[0] = args;
15980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15981 if (!SWIG_IsOK(res1)) {
15982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15983 }
15984 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15985 {
15986 PyThreadState* __tstate = wxPyBeginAllowThreads();
15987 result = (int)(arg1)->GetVMin();
15988 wxPyEndAllowThreads(__tstate);
15989 if (PyErr_Occurred()) SWIG_fail;
15990 }
15991 resultobj = SWIG_From_int(static_cast< int >(result));
15992 return resultobj;
15993 fail:
15994 return NULL;
15995 }
15996
15997
15998 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15999 PyObject *resultobj = 0;
16000 wxJoystick *arg1 = (wxJoystick *) 0 ;
16001 int result;
16002 void *argp1 = 0 ;
16003 int res1 = 0 ;
16004 PyObject *swig_obj[1] ;
16005
16006 if (!args) SWIG_fail;
16007 swig_obj[0] = args;
16008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16009 if (!SWIG_IsOK(res1)) {
16010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16011 }
16012 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16013 {
16014 PyThreadState* __tstate = wxPyBeginAllowThreads();
16015 result = (int)(arg1)->GetVMax();
16016 wxPyEndAllowThreads(__tstate);
16017 if (PyErr_Occurred()) SWIG_fail;
16018 }
16019 resultobj = SWIG_From_int(static_cast< int >(result));
16020 return resultobj;
16021 fail:
16022 return NULL;
16023 }
16024
16025
16026 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16027 PyObject *resultobj = 0;
16028 wxJoystick *arg1 = (wxJoystick *) 0 ;
16029 bool result;
16030 void *argp1 = 0 ;
16031 int res1 = 0 ;
16032 PyObject *swig_obj[1] ;
16033
16034 if (!args) SWIG_fail;
16035 swig_obj[0] = args;
16036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16037 if (!SWIG_IsOK(res1)) {
16038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16039 }
16040 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16041 {
16042 PyThreadState* __tstate = wxPyBeginAllowThreads();
16043 result = (bool)(arg1)->HasRudder();
16044 wxPyEndAllowThreads(__tstate);
16045 if (PyErr_Occurred()) SWIG_fail;
16046 }
16047 {
16048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16049 }
16050 return resultobj;
16051 fail:
16052 return NULL;
16053 }
16054
16055
16056 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16057 PyObject *resultobj = 0;
16058 wxJoystick *arg1 = (wxJoystick *) 0 ;
16059 bool result;
16060 void *argp1 = 0 ;
16061 int res1 = 0 ;
16062 PyObject *swig_obj[1] ;
16063
16064 if (!args) SWIG_fail;
16065 swig_obj[0] = args;
16066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16067 if (!SWIG_IsOK(res1)) {
16068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16069 }
16070 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16071 {
16072 PyThreadState* __tstate = wxPyBeginAllowThreads();
16073 result = (bool)(arg1)->HasZ();
16074 wxPyEndAllowThreads(__tstate);
16075 if (PyErr_Occurred()) SWIG_fail;
16076 }
16077 {
16078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16079 }
16080 return resultobj;
16081 fail:
16082 return NULL;
16083 }
16084
16085
16086 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16087 PyObject *resultobj = 0;
16088 wxJoystick *arg1 = (wxJoystick *) 0 ;
16089 bool result;
16090 void *argp1 = 0 ;
16091 int res1 = 0 ;
16092 PyObject *swig_obj[1] ;
16093
16094 if (!args) SWIG_fail;
16095 swig_obj[0] = args;
16096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16097 if (!SWIG_IsOK(res1)) {
16098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16099 }
16100 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16101 {
16102 PyThreadState* __tstate = wxPyBeginAllowThreads();
16103 result = (bool)(arg1)->HasU();
16104 wxPyEndAllowThreads(__tstate);
16105 if (PyErr_Occurred()) SWIG_fail;
16106 }
16107 {
16108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16109 }
16110 return resultobj;
16111 fail:
16112 return NULL;
16113 }
16114
16115
16116 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16117 PyObject *resultobj = 0;
16118 wxJoystick *arg1 = (wxJoystick *) 0 ;
16119 bool result;
16120 void *argp1 = 0 ;
16121 int res1 = 0 ;
16122 PyObject *swig_obj[1] ;
16123
16124 if (!args) SWIG_fail;
16125 swig_obj[0] = args;
16126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16127 if (!SWIG_IsOK(res1)) {
16128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16129 }
16130 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16131 {
16132 PyThreadState* __tstate = wxPyBeginAllowThreads();
16133 result = (bool)(arg1)->HasV();
16134 wxPyEndAllowThreads(__tstate);
16135 if (PyErr_Occurred()) SWIG_fail;
16136 }
16137 {
16138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16139 }
16140 return resultobj;
16141 fail:
16142 return NULL;
16143 }
16144
16145
16146 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16147 PyObject *resultobj = 0;
16148 wxJoystick *arg1 = (wxJoystick *) 0 ;
16149 bool result;
16150 void *argp1 = 0 ;
16151 int res1 = 0 ;
16152 PyObject *swig_obj[1] ;
16153
16154 if (!args) SWIG_fail;
16155 swig_obj[0] = args;
16156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16157 if (!SWIG_IsOK(res1)) {
16158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16159 }
16160 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16161 {
16162 PyThreadState* __tstate = wxPyBeginAllowThreads();
16163 result = (bool)(arg1)->HasPOV();
16164 wxPyEndAllowThreads(__tstate);
16165 if (PyErr_Occurred()) SWIG_fail;
16166 }
16167 {
16168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16169 }
16170 return resultobj;
16171 fail:
16172 return NULL;
16173 }
16174
16175
16176 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16177 PyObject *resultobj = 0;
16178 wxJoystick *arg1 = (wxJoystick *) 0 ;
16179 bool result;
16180 void *argp1 = 0 ;
16181 int res1 = 0 ;
16182 PyObject *swig_obj[1] ;
16183
16184 if (!args) SWIG_fail;
16185 swig_obj[0] = args;
16186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16187 if (!SWIG_IsOK(res1)) {
16188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16189 }
16190 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16191 {
16192 PyThreadState* __tstate = wxPyBeginAllowThreads();
16193 result = (bool)(arg1)->HasPOV4Dir();
16194 wxPyEndAllowThreads(__tstate);
16195 if (PyErr_Occurred()) SWIG_fail;
16196 }
16197 {
16198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16199 }
16200 return resultobj;
16201 fail:
16202 return NULL;
16203 }
16204
16205
16206 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16207 PyObject *resultobj = 0;
16208 wxJoystick *arg1 = (wxJoystick *) 0 ;
16209 bool result;
16210 void *argp1 = 0 ;
16211 int res1 = 0 ;
16212 PyObject *swig_obj[1] ;
16213
16214 if (!args) SWIG_fail;
16215 swig_obj[0] = args;
16216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16217 if (!SWIG_IsOK(res1)) {
16218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16219 }
16220 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16221 {
16222 PyThreadState* __tstate = wxPyBeginAllowThreads();
16223 result = (bool)(arg1)->HasPOVCTS();
16224 wxPyEndAllowThreads(__tstate);
16225 if (PyErr_Occurred()) SWIG_fail;
16226 }
16227 {
16228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16229 }
16230 return resultobj;
16231 fail:
16232 return NULL;
16233 }
16234
16235
16236 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16237 PyObject *resultobj = 0;
16238 wxJoystick *arg1 = (wxJoystick *) 0 ;
16239 wxWindow *arg2 = (wxWindow *) 0 ;
16240 int arg3 = (int) 0 ;
16241 bool result;
16242 void *argp1 = 0 ;
16243 int res1 = 0 ;
16244 void *argp2 = 0 ;
16245 int res2 = 0 ;
16246 int val3 ;
16247 int ecode3 = 0 ;
16248 PyObject * obj0 = 0 ;
16249 PyObject * obj1 = 0 ;
16250 PyObject * obj2 = 0 ;
16251 char * kwnames[] = {
16252 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16253 };
16254
16255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16257 if (!SWIG_IsOK(res1)) {
16258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16259 }
16260 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16261 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16262 if (!SWIG_IsOK(res2)) {
16263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16264 }
16265 arg2 = reinterpret_cast< wxWindow * >(argp2);
16266 if (obj2) {
16267 ecode3 = SWIG_AsVal_int(obj2, &val3);
16268 if (!SWIG_IsOK(ecode3)) {
16269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16270 }
16271 arg3 = static_cast< int >(val3);
16272 }
16273 {
16274 PyThreadState* __tstate = wxPyBeginAllowThreads();
16275 result = (bool)(arg1)->SetCapture(arg2,arg3);
16276 wxPyEndAllowThreads(__tstate);
16277 if (PyErr_Occurred()) SWIG_fail;
16278 }
16279 {
16280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16281 }
16282 return resultobj;
16283 fail:
16284 return NULL;
16285 }
16286
16287
16288 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16289 PyObject *resultobj = 0;
16290 wxJoystick *arg1 = (wxJoystick *) 0 ;
16291 bool result;
16292 void *argp1 = 0 ;
16293 int res1 = 0 ;
16294 PyObject *swig_obj[1] ;
16295
16296 if (!args) SWIG_fail;
16297 swig_obj[0] = args;
16298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16299 if (!SWIG_IsOK(res1)) {
16300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16301 }
16302 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16303 {
16304 PyThreadState* __tstate = wxPyBeginAllowThreads();
16305 result = (bool)(arg1)->ReleaseCapture();
16306 wxPyEndAllowThreads(__tstate);
16307 if (PyErr_Occurred()) SWIG_fail;
16308 }
16309 {
16310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16311 }
16312 return resultobj;
16313 fail:
16314 return NULL;
16315 }
16316
16317
16318 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16319 PyObject *obj;
16320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16321 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16322 return SWIG_Py_Void();
16323 }
16324
16325 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16326 return SWIG_Python_InitShadowInstance(args);
16327 }
16328
16329 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16330 PyObject *resultobj = 0;
16331 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16332 int arg2 = (int) 0 ;
16333 int arg3 = (int) wxJOYSTICK1 ;
16334 int arg4 = (int) 0 ;
16335 wxJoystickEvent *result = 0 ;
16336 int val1 ;
16337 int ecode1 = 0 ;
16338 int val2 ;
16339 int ecode2 = 0 ;
16340 int val3 ;
16341 int ecode3 = 0 ;
16342 int val4 ;
16343 int ecode4 = 0 ;
16344 PyObject * obj0 = 0 ;
16345 PyObject * obj1 = 0 ;
16346 PyObject * obj2 = 0 ;
16347 PyObject * obj3 = 0 ;
16348 char * kwnames[] = {
16349 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16350 };
16351
16352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16353 if (obj0) {
16354 ecode1 = SWIG_AsVal_int(obj0, &val1);
16355 if (!SWIG_IsOK(ecode1)) {
16356 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16357 }
16358 arg1 = static_cast< wxEventType >(val1);
16359 }
16360 if (obj1) {
16361 ecode2 = SWIG_AsVal_int(obj1, &val2);
16362 if (!SWIG_IsOK(ecode2)) {
16363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16364 }
16365 arg2 = static_cast< int >(val2);
16366 }
16367 if (obj2) {
16368 ecode3 = SWIG_AsVal_int(obj2, &val3);
16369 if (!SWIG_IsOK(ecode3)) {
16370 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16371 }
16372 arg3 = static_cast< int >(val3);
16373 }
16374 if (obj3) {
16375 ecode4 = SWIG_AsVal_int(obj3, &val4);
16376 if (!SWIG_IsOK(ecode4)) {
16377 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16378 }
16379 arg4 = static_cast< int >(val4);
16380 }
16381 {
16382 PyThreadState* __tstate = wxPyBeginAllowThreads();
16383 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16384 wxPyEndAllowThreads(__tstate);
16385 if (PyErr_Occurred()) SWIG_fail;
16386 }
16387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16388 return resultobj;
16389 fail:
16390 return NULL;
16391 }
16392
16393
16394 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16395 PyObject *resultobj = 0;
16396 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16397 wxPoint result;
16398 void *argp1 = 0 ;
16399 int res1 = 0 ;
16400 PyObject *swig_obj[1] ;
16401
16402 if (!args) SWIG_fail;
16403 swig_obj[0] = args;
16404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16405 if (!SWIG_IsOK(res1)) {
16406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16407 }
16408 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16409 {
16410 PyThreadState* __tstate = wxPyBeginAllowThreads();
16411 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16412 wxPyEndAllowThreads(__tstate);
16413 if (PyErr_Occurred()) SWIG_fail;
16414 }
16415 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16416 return resultobj;
16417 fail:
16418 return NULL;
16419 }
16420
16421
16422 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16423 PyObject *resultobj = 0;
16424 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16425 int result;
16426 void *argp1 = 0 ;
16427 int res1 = 0 ;
16428 PyObject *swig_obj[1] ;
16429
16430 if (!args) SWIG_fail;
16431 swig_obj[0] = args;
16432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16433 if (!SWIG_IsOK(res1)) {
16434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16435 }
16436 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16437 {
16438 PyThreadState* __tstate = wxPyBeginAllowThreads();
16439 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16440 wxPyEndAllowThreads(__tstate);
16441 if (PyErr_Occurred()) SWIG_fail;
16442 }
16443 resultobj = SWIG_From_int(static_cast< int >(result));
16444 return resultobj;
16445 fail:
16446 return NULL;
16447 }
16448
16449
16450 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16451 PyObject *resultobj = 0;
16452 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16453 int result;
16454 void *argp1 = 0 ;
16455 int res1 = 0 ;
16456 PyObject *swig_obj[1] ;
16457
16458 if (!args) SWIG_fail;
16459 swig_obj[0] = args;
16460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16461 if (!SWIG_IsOK(res1)) {
16462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16463 }
16464 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16465 {
16466 PyThreadState* __tstate = wxPyBeginAllowThreads();
16467 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16468 wxPyEndAllowThreads(__tstate);
16469 if (PyErr_Occurred()) SWIG_fail;
16470 }
16471 resultobj = SWIG_From_int(static_cast< int >(result));
16472 return resultobj;
16473 fail:
16474 return NULL;
16475 }
16476
16477
16478 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16479 PyObject *resultobj = 0;
16480 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16481 int result;
16482 void *argp1 = 0 ;
16483 int res1 = 0 ;
16484 PyObject *swig_obj[1] ;
16485
16486 if (!args) SWIG_fail;
16487 swig_obj[0] = args;
16488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16489 if (!SWIG_IsOK(res1)) {
16490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16491 }
16492 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16493 {
16494 PyThreadState* __tstate = wxPyBeginAllowThreads();
16495 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16496 wxPyEndAllowThreads(__tstate);
16497 if (PyErr_Occurred()) SWIG_fail;
16498 }
16499 resultobj = SWIG_From_int(static_cast< int >(result));
16500 return resultobj;
16501 fail:
16502 return NULL;
16503 }
16504
16505
16506 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16507 PyObject *resultobj = 0;
16508 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16509 int result;
16510 void *argp1 = 0 ;
16511 int res1 = 0 ;
16512 PyObject *swig_obj[1] ;
16513
16514 if (!args) SWIG_fail;
16515 swig_obj[0] = args;
16516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16517 if (!SWIG_IsOK(res1)) {
16518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16519 }
16520 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16521 {
16522 PyThreadState* __tstate = wxPyBeginAllowThreads();
16523 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16524 wxPyEndAllowThreads(__tstate);
16525 if (PyErr_Occurred()) SWIG_fail;
16526 }
16527 resultobj = SWIG_From_int(static_cast< int >(result));
16528 return resultobj;
16529 fail:
16530 return NULL;
16531 }
16532
16533
16534 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16535 PyObject *resultobj = 0;
16536 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16537 int arg2 ;
16538 void *argp1 = 0 ;
16539 int res1 = 0 ;
16540 int val2 ;
16541 int ecode2 = 0 ;
16542 PyObject * obj0 = 0 ;
16543 PyObject * obj1 = 0 ;
16544 char * kwnames[] = {
16545 (char *) "self",(char *) "stick", NULL
16546 };
16547
16548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16550 if (!SWIG_IsOK(res1)) {
16551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16552 }
16553 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16554 ecode2 = SWIG_AsVal_int(obj1, &val2);
16555 if (!SWIG_IsOK(ecode2)) {
16556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16557 }
16558 arg2 = static_cast< int >(val2);
16559 {
16560 PyThreadState* __tstate = wxPyBeginAllowThreads();
16561 (arg1)->SetJoystick(arg2);
16562 wxPyEndAllowThreads(__tstate);
16563 if (PyErr_Occurred()) SWIG_fail;
16564 }
16565 resultobj = SWIG_Py_Void();
16566 return resultobj;
16567 fail:
16568 return NULL;
16569 }
16570
16571
16572 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16573 PyObject *resultobj = 0;
16574 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16575 int arg2 ;
16576 void *argp1 = 0 ;
16577 int res1 = 0 ;
16578 int val2 ;
16579 int ecode2 = 0 ;
16580 PyObject * obj0 = 0 ;
16581 PyObject * obj1 = 0 ;
16582 char * kwnames[] = {
16583 (char *) "self",(char *) "state", NULL
16584 };
16585
16586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16588 if (!SWIG_IsOK(res1)) {
16589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16590 }
16591 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16592 ecode2 = SWIG_AsVal_int(obj1, &val2);
16593 if (!SWIG_IsOK(ecode2)) {
16594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16595 }
16596 arg2 = static_cast< int >(val2);
16597 {
16598 PyThreadState* __tstate = wxPyBeginAllowThreads();
16599 (arg1)->SetButtonState(arg2);
16600 wxPyEndAllowThreads(__tstate);
16601 if (PyErr_Occurred()) SWIG_fail;
16602 }
16603 resultobj = SWIG_Py_Void();
16604 return resultobj;
16605 fail:
16606 return NULL;
16607 }
16608
16609
16610 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16611 PyObject *resultobj = 0;
16612 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16613 int arg2 ;
16614 void *argp1 = 0 ;
16615 int res1 = 0 ;
16616 int val2 ;
16617 int ecode2 = 0 ;
16618 PyObject * obj0 = 0 ;
16619 PyObject * obj1 = 0 ;
16620 char * kwnames[] = {
16621 (char *) "self",(char *) "change", NULL
16622 };
16623
16624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16626 if (!SWIG_IsOK(res1)) {
16627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16628 }
16629 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16630 ecode2 = SWIG_AsVal_int(obj1, &val2);
16631 if (!SWIG_IsOK(ecode2)) {
16632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16633 }
16634 arg2 = static_cast< int >(val2);
16635 {
16636 PyThreadState* __tstate = wxPyBeginAllowThreads();
16637 (arg1)->SetButtonChange(arg2);
16638 wxPyEndAllowThreads(__tstate);
16639 if (PyErr_Occurred()) SWIG_fail;
16640 }
16641 resultobj = SWIG_Py_Void();
16642 return resultobj;
16643 fail:
16644 return NULL;
16645 }
16646
16647
16648 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16649 PyObject *resultobj = 0;
16650 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16651 wxPoint *arg2 = 0 ;
16652 void *argp1 = 0 ;
16653 int res1 = 0 ;
16654 wxPoint temp2 ;
16655 PyObject * obj0 = 0 ;
16656 PyObject * obj1 = 0 ;
16657 char * kwnames[] = {
16658 (char *) "self",(char *) "pos", NULL
16659 };
16660
16661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16663 if (!SWIG_IsOK(res1)) {
16664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16665 }
16666 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16667 {
16668 arg2 = &temp2;
16669 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16670 }
16671 {
16672 PyThreadState* __tstate = wxPyBeginAllowThreads();
16673 (arg1)->SetPosition((wxPoint const &)*arg2);
16674 wxPyEndAllowThreads(__tstate);
16675 if (PyErr_Occurred()) SWIG_fail;
16676 }
16677 resultobj = SWIG_Py_Void();
16678 return resultobj;
16679 fail:
16680 return NULL;
16681 }
16682
16683
16684 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16685 PyObject *resultobj = 0;
16686 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16687 int arg2 ;
16688 void *argp1 = 0 ;
16689 int res1 = 0 ;
16690 int val2 ;
16691 int ecode2 = 0 ;
16692 PyObject * obj0 = 0 ;
16693 PyObject * obj1 = 0 ;
16694 char * kwnames[] = {
16695 (char *) "self",(char *) "zPos", NULL
16696 };
16697
16698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16700 if (!SWIG_IsOK(res1)) {
16701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16702 }
16703 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16704 ecode2 = SWIG_AsVal_int(obj1, &val2);
16705 if (!SWIG_IsOK(ecode2)) {
16706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16707 }
16708 arg2 = static_cast< int >(val2);
16709 {
16710 PyThreadState* __tstate = wxPyBeginAllowThreads();
16711 (arg1)->SetZPosition(arg2);
16712 wxPyEndAllowThreads(__tstate);
16713 if (PyErr_Occurred()) SWIG_fail;
16714 }
16715 resultobj = SWIG_Py_Void();
16716 return resultobj;
16717 fail:
16718 return NULL;
16719 }
16720
16721
16722 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16723 PyObject *resultobj = 0;
16724 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16725 bool result;
16726 void *argp1 = 0 ;
16727 int res1 = 0 ;
16728 PyObject *swig_obj[1] ;
16729
16730 if (!args) SWIG_fail;
16731 swig_obj[0] = args;
16732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16733 if (!SWIG_IsOK(res1)) {
16734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16735 }
16736 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16737 {
16738 PyThreadState* __tstate = wxPyBeginAllowThreads();
16739 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16740 wxPyEndAllowThreads(__tstate);
16741 if (PyErr_Occurred()) SWIG_fail;
16742 }
16743 {
16744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16745 }
16746 return resultobj;
16747 fail:
16748 return NULL;
16749 }
16750
16751
16752 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16753 PyObject *resultobj = 0;
16754 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16755 bool result;
16756 void *argp1 = 0 ;
16757 int res1 = 0 ;
16758 PyObject *swig_obj[1] ;
16759
16760 if (!args) SWIG_fail;
16761 swig_obj[0] = args;
16762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16763 if (!SWIG_IsOK(res1)) {
16764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16765 }
16766 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16767 {
16768 PyThreadState* __tstate = wxPyBeginAllowThreads();
16769 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16770 wxPyEndAllowThreads(__tstate);
16771 if (PyErr_Occurred()) SWIG_fail;
16772 }
16773 {
16774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16775 }
16776 return resultobj;
16777 fail:
16778 return NULL;
16779 }
16780
16781
16782 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16783 PyObject *resultobj = 0;
16784 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16785 bool result;
16786 void *argp1 = 0 ;
16787 int res1 = 0 ;
16788 PyObject *swig_obj[1] ;
16789
16790 if (!args) SWIG_fail;
16791 swig_obj[0] = args;
16792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16793 if (!SWIG_IsOK(res1)) {
16794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16795 }
16796 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16797 {
16798 PyThreadState* __tstate = wxPyBeginAllowThreads();
16799 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
16800 wxPyEndAllowThreads(__tstate);
16801 if (PyErr_Occurred()) SWIG_fail;
16802 }
16803 {
16804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16805 }
16806 return resultobj;
16807 fail:
16808 return NULL;
16809 }
16810
16811
16812 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16813 PyObject *resultobj = 0;
16814 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16815 int arg2 = (int) wxJOY_BUTTON_ANY ;
16816 bool result;
16817 void *argp1 = 0 ;
16818 int res1 = 0 ;
16819 int val2 ;
16820 int ecode2 = 0 ;
16821 PyObject * obj0 = 0 ;
16822 PyObject * obj1 = 0 ;
16823 char * kwnames[] = {
16824 (char *) "self",(char *) "but", NULL
16825 };
16826
16827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
16828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16829 if (!SWIG_IsOK(res1)) {
16830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16831 }
16832 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16833 if (obj1) {
16834 ecode2 = SWIG_AsVal_int(obj1, &val2);
16835 if (!SWIG_IsOK(ecode2)) {
16836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
16837 }
16838 arg2 = static_cast< int >(val2);
16839 }
16840 {
16841 PyThreadState* __tstate = wxPyBeginAllowThreads();
16842 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
16843 wxPyEndAllowThreads(__tstate);
16844 if (PyErr_Occurred()) SWIG_fail;
16845 }
16846 {
16847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16848 }
16849 return resultobj;
16850 fail:
16851 return NULL;
16852 }
16853
16854
16855 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16856 PyObject *resultobj = 0;
16857 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16858 int arg2 = (int) wxJOY_BUTTON_ANY ;
16859 bool result;
16860 void *argp1 = 0 ;
16861 int res1 = 0 ;
16862 int val2 ;
16863 int ecode2 = 0 ;
16864 PyObject * obj0 = 0 ;
16865 PyObject * obj1 = 0 ;
16866 char * kwnames[] = {
16867 (char *) "self",(char *) "but", NULL
16868 };
16869
16870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
16871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16872 if (!SWIG_IsOK(res1)) {
16873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16874 }
16875 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16876 if (obj1) {
16877 ecode2 = SWIG_AsVal_int(obj1, &val2);
16878 if (!SWIG_IsOK(ecode2)) {
16879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
16880 }
16881 arg2 = static_cast< int >(val2);
16882 }
16883 {
16884 PyThreadState* __tstate = wxPyBeginAllowThreads();
16885 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
16886 wxPyEndAllowThreads(__tstate);
16887 if (PyErr_Occurred()) SWIG_fail;
16888 }
16889 {
16890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16891 }
16892 return resultobj;
16893 fail:
16894 return NULL;
16895 }
16896
16897
16898 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16899 PyObject *resultobj = 0;
16900 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16901 int arg2 = (int) wxJOY_BUTTON_ANY ;
16902 bool result;
16903 void *argp1 = 0 ;
16904 int res1 = 0 ;
16905 int val2 ;
16906 int ecode2 = 0 ;
16907 PyObject * obj0 = 0 ;
16908 PyObject * obj1 = 0 ;
16909 char * kwnames[] = {
16910 (char *) "self",(char *) "but", NULL
16911 };
16912
16913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
16914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16915 if (!SWIG_IsOK(res1)) {
16916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16917 }
16918 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16919 if (obj1) {
16920 ecode2 = SWIG_AsVal_int(obj1, &val2);
16921 if (!SWIG_IsOK(ecode2)) {
16922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
16923 }
16924 arg2 = static_cast< int >(val2);
16925 }
16926 {
16927 PyThreadState* __tstate = wxPyBeginAllowThreads();
16928 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
16929 wxPyEndAllowThreads(__tstate);
16930 if (PyErr_Occurred()) SWIG_fail;
16931 }
16932 {
16933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16934 }
16935 return resultobj;
16936 fail:
16937 return NULL;
16938 }
16939
16940
16941 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16942 PyObject *obj;
16943 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16944 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
16945 return SWIG_Py_Void();
16946 }
16947
16948 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16949 return SWIG_Python_InitShadowInstance(args);
16950 }
16951
16952 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16953 PyObject *resultobj = 0;
16954 wxString const &arg1_defvalue = wxPyEmptyString ;
16955 wxString *arg1 = (wxString *) &arg1_defvalue ;
16956 wxSound *result = 0 ;
16957 bool temp1 = false ;
16958 PyObject * obj0 = 0 ;
16959 char * kwnames[] = {
16960 (char *) "fileName", NULL
16961 };
16962
16963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
16964 if (obj0) {
16965 {
16966 arg1 = wxString_in_helper(obj0);
16967 if (arg1 == NULL) SWIG_fail;
16968 temp1 = true;
16969 }
16970 }
16971 {
16972 if (!wxPyCheckForApp()) SWIG_fail;
16973 PyThreadState* __tstate = wxPyBeginAllowThreads();
16974 result = (wxSound *)new_wxSound((wxString const &)*arg1);
16975 wxPyEndAllowThreads(__tstate);
16976 if (PyErr_Occurred()) SWIG_fail;
16977 }
16978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
16979 {
16980 if (temp1)
16981 delete arg1;
16982 }
16983 return resultobj;
16984 fail:
16985 {
16986 if (temp1)
16987 delete arg1;
16988 }
16989 return NULL;
16990 }
16991
16992
16993 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16994 PyObject *resultobj = 0;
16995 PyObject *arg1 = (PyObject *) 0 ;
16996 wxSound *result = 0 ;
16997 PyObject * obj0 = 0 ;
16998 char * kwnames[] = {
16999 (char *) "data", NULL
17000 };
17001
17002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17003 arg1 = obj0;
17004 {
17005 if (!wxPyCheckForApp()) SWIG_fail;
17006 PyThreadState* __tstate = wxPyBeginAllowThreads();
17007 result = (wxSound *)new_wxSound(arg1);
17008 wxPyEndAllowThreads(__tstate);
17009 if (PyErr_Occurred()) SWIG_fail;
17010 }
17011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17012 return resultobj;
17013 fail:
17014 return NULL;
17015 }
17016
17017
17018 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17019 PyObject *resultobj = 0;
17020 wxSound *arg1 = (wxSound *) 0 ;
17021 void *argp1 = 0 ;
17022 int res1 = 0 ;
17023 PyObject *swig_obj[1] ;
17024
17025 if (!args) SWIG_fail;
17026 swig_obj[0] = args;
17027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17028 if (!SWIG_IsOK(res1)) {
17029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17030 }
17031 arg1 = reinterpret_cast< wxSound * >(argp1);
17032 {
17033 PyThreadState* __tstate = wxPyBeginAllowThreads();
17034 delete arg1;
17035
17036 wxPyEndAllowThreads(__tstate);
17037 if (PyErr_Occurred()) SWIG_fail;
17038 }
17039 resultobj = SWIG_Py_Void();
17040 return resultobj;
17041 fail:
17042 return NULL;
17043 }
17044
17045
17046 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17047 PyObject *resultobj = 0;
17048 wxSound *arg1 = (wxSound *) 0 ;
17049 wxString *arg2 = 0 ;
17050 bool result;
17051 void *argp1 = 0 ;
17052 int res1 = 0 ;
17053 bool temp2 = false ;
17054 PyObject * obj0 = 0 ;
17055 PyObject * obj1 = 0 ;
17056 char * kwnames[] = {
17057 (char *) "self",(char *) "fileName", NULL
17058 };
17059
17060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17062 if (!SWIG_IsOK(res1)) {
17063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17064 }
17065 arg1 = reinterpret_cast< wxSound * >(argp1);
17066 {
17067 arg2 = wxString_in_helper(obj1);
17068 if (arg2 == NULL) SWIG_fail;
17069 temp2 = true;
17070 }
17071 {
17072 PyThreadState* __tstate = wxPyBeginAllowThreads();
17073 result = (bool)(arg1)->Create((wxString const &)*arg2);
17074 wxPyEndAllowThreads(__tstate);
17075 if (PyErr_Occurred()) SWIG_fail;
17076 }
17077 {
17078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17079 }
17080 {
17081 if (temp2)
17082 delete arg2;
17083 }
17084 return resultobj;
17085 fail:
17086 {
17087 if (temp2)
17088 delete arg2;
17089 }
17090 return NULL;
17091 }
17092
17093
17094 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17095 PyObject *resultobj = 0;
17096 wxSound *arg1 = (wxSound *) 0 ;
17097 PyObject *arg2 = (PyObject *) 0 ;
17098 bool result;
17099 void *argp1 = 0 ;
17100 int res1 = 0 ;
17101 PyObject * obj0 = 0 ;
17102 PyObject * obj1 = 0 ;
17103 char * kwnames[] = {
17104 (char *) "self",(char *) "data", NULL
17105 };
17106
17107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17109 if (!SWIG_IsOK(res1)) {
17110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17111 }
17112 arg1 = reinterpret_cast< wxSound * >(argp1);
17113 arg2 = obj1;
17114 {
17115 PyThreadState* __tstate = wxPyBeginAllowThreads();
17116 result = (bool)wxSound_CreateFromData(arg1,arg2);
17117 wxPyEndAllowThreads(__tstate);
17118 if (PyErr_Occurred()) SWIG_fail;
17119 }
17120 {
17121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17122 }
17123 return resultobj;
17124 fail:
17125 return NULL;
17126 }
17127
17128
17129 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17130 PyObject *resultobj = 0;
17131 wxSound *arg1 = (wxSound *) 0 ;
17132 bool result;
17133 void *argp1 = 0 ;
17134 int res1 = 0 ;
17135 PyObject *swig_obj[1] ;
17136
17137 if (!args) SWIG_fail;
17138 swig_obj[0] = args;
17139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17140 if (!SWIG_IsOK(res1)) {
17141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17142 }
17143 arg1 = reinterpret_cast< wxSound * >(argp1);
17144 {
17145 PyThreadState* __tstate = wxPyBeginAllowThreads();
17146 result = (bool)(arg1)->IsOk();
17147 wxPyEndAllowThreads(__tstate);
17148 if (PyErr_Occurred()) SWIG_fail;
17149 }
17150 {
17151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17152 }
17153 return resultobj;
17154 fail:
17155 return NULL;
17156 }
17157
17158
17159 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17160 PyObject *resultobj = 0;
17161 wxSound *arg1 = (wxSound *) 0 ;
17162 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17163 bool result;
17164 void *argp1 = 0 ;
17165 int res1 = 0 ;
17166 unsigned int val2 ;
17167 int ecode2 = 0 ;
17168 PyObject * obj0 = 0 ;
17169 PyObject * obj1 = 0 ;
17170 char * kwnames[] = {
17171 (char *) "self",(char *) "flags", NULL
17172 };
17173
17174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17176 if (!SWIG_IsOK(res1)) {
17177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17178 }
17179 arg1 = reinterpret_cast< wxSound * >(argp1);
17180 if (obj1) {
17181 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17182 if (!SWIG_IsOK(ecode2)) {
17183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17184 }
17185 arg2 = static_cast< unsigned int >(val2);
17186 }
17187 {
17188 if (!wxPyCheckForApp()) SWIG_fail;
17189 PyThreadState* __tstate = wxPyBeginAllowThreads();
17190 result = (bool)((wxSound const *)arg1)->Play(arg2);
17191 wxPyEndAllowThreads(__tstate);
17192 if (PyErr_Occurred()) SWIG_fail;
17193 }
17194 {
17195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17196 }
17197 return resultobj;
17198 fail:
17199 return NULL;
17200 }
17201
17202
17203 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17204 PyObject *resultobj = 0;
17205 wxString *arg1 = 0 ;
17206 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17207 bool result;
17208 bool temp1 = false ;
17209 unsigned int val2 ;
17210 int ecode2 = 0 ;
17211 PyObject * obj0 = 0 ;
17212 PyObject * obj1 = 0 ;
17213 char * kwnames[] = {
17214 (char *) "filename",(char *) "flags", NULL
17215 };
17216
17217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17218 {
17219 arg1 = wxString_in_helper(obj0);
17220 if (arg1 == NULL) SWIG_fail;
17221 temp1 = true;
17222 }
17223 if (obj1) {
17224 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17225 if (!SWIG_IsOK(ecode2)) {
17226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17227 }
17228 arg2 = static_cast< unsigned int >(val2);
17229 }
17230 {
17231 if (!wxPyCheckForApp()) SWIG_fail;
17232 PyThreadState* __tstate = wxPyBeginAllowThreads();
17233 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17234 wxPyEndAllowThreads(__tstate);
17235 if (PyErr_Occurred()) SWIG_fail;
17236 }
17237 {
17238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17239 }
17240 {
17241 if (temp1)
17242 delete arg1;
17243 }
17244 return resultobj;
17245 fail:
17246 {
17247 if (temp1)
17248 delete arg1;
17249 }
17250 return NULL;
17251 }
17252
17253
17254 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17255 PyObject *resultobj = 0;
17256
17257 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17258 {
17259 if (!wxPyCheckForApp()) SWIG_fail;
17260 PyThreadState* __tstate = wxPyBeginAllowThreads();
17261 wxSound::Stop();
17262 wxPyEndAllowThreads(__tstate);
17263 if (PyErr_Occurred()) SWIG_fail;
17264 }
17265 resultobj = SWIG_Py_Void();
17266 return resultobj;
17267 fail:
17268 return NULL;
17269 }
17270
17271
17272 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17273 PyObject *obj;
17274 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17275 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17276 return SWIG_Py_Void();
17277 }
17278
17279 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17280 return SWIG_Python_InitShadowInstance(args);
17281 }
17282
17283 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17284 PyObject *resultobj = 0;
17285 wxString *arg1 = 0 ;
17286 wxString *arg2 = 0 ;
17287 wxString *arg3 = 0 ;
17288 wxString *arg4 = 0 ;
17289 wxFileTypeInfo *result = 0 ;
17290 bool temp1 = false ;
17291 bool temp2 = false ;
17292 bool temp3 = false ;
17293 bool temp4 = false ;
17294 PyObject * obj0 = 0 ;
17295 PyObject * obj1 = 0 ;
17296 PyObject * obj2 = 0 ;
17297 PyObject * obj3 = 0 ;
17298 char * kwnames[] = {
17299 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17300 };
17301
17302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17303 {
17304 arg1 = wxString_in_helper(obj0);
17305 if (arg1 == NULL) SWIG_fail;
17306 temp1 = true;
17307 }
17308 {
17309 arg2 = wxString_in_helper(obj1);
17310 if (arg2 == NULL) SWIG_fail;
17311 temp2 = true;
17312 }
17313 {
17314 arg3 = wxString_in_helper(obj2);
17315 if (arg3 == NULL) SWIG_fail;
17316 temp3 = true;
17317 }
17318 {
17319 arg4 = wxString_in_helper(obj3);
17320 if (arg4 == NULL) SWIG_fail;
17321 temp4 = true;
17322 }
17323 {
17324 PyThreadState* __tstate = wxPyBeginAllowThreads();
17325 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17326 wxPyEndAllowThreads(__tstate);
17327 if (PyErr_Occurred()) SWIG_fail;
17328 }
17329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17330 {
17331 if (temp1)
17332 delete arg1;
17333 }
17334 {
17335 if (temp2)
17336 delete arg2;
17337 }
17338 {
17339 if (temp3)
17340 delete arg3;
17341 }
17342 {
17343 if (temp4)
17344 delete arg4;
17345 }
17346 return resultobj;
17347 fail:
17348 {
17349 if (temp1)
17350 delete arg1;
17351 }
17352 {
17353 if (temp2)
17354 delete arg2;
17355 }
17356 {
17357 if (temp3)
17358 delete arg3;
17359 }
17360 {
17361 if (temp4)
17362 delete arg4;
17363 }
17364 return NULL;
17365 }
17366
17367
17368 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17369 PyObject *resultobj = 0;
17370 wxArrayString *arg1 = 0 ;
17371 wxFileTypeInfo *result = 0 ;
17372 bool temp1 = false ;
17373 PyObject * obj0 = 0 ;
17374 char * kwnames[] = {
17375 (char *) "sArray", NULL
17376 };
17377
17378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17379 {
17380 if (! PySequence_Check(obj0)) {
17381 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17382 SWIG_fail;
17383 }
17384 arg1 = new wxArrayString;
17385 temp1 = true;
17386 int i, len=PySequence_Length(obj0);
17387 for (i=0; i<len; i++) {
17388 PyObject* item = PySequence_GetItem(obj0, i);
17389 wxString* s = wxString_in_helper(item);
17390 if (PyErr_Occurred()) SWIG_fail;
17391 arg1->Add(*s);
17392 delete s;
17393 Py_DECREF(item);
17394 }
17395 }
17396 {
17397 PyThreadState* __tstate = wxPyBeginAllowThreads();
17398 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17399 wxPyEndAllowThreads(__tstate);
17400 if (PyErr_Occurred()) SWIG_fail;
17401 }
17402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17403 {
17404 if (temp1) delete arg1;
17405 }
17406 return resultobj;
17407 fail:
17408 {
17409 if (temp1) delete arg1;
17410 }
17411 return NULL;
17412 }
17413
17414
17415 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17416 PyObject *resultobj = 0;
17417 wxFileTypeInfo *result = 0 ;
17418
17419 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17420 {
17421 PyThreadState* __tstate = wxPyBeginAllowThreads();
17422 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17423 wxPyEndAllowThreads(__tstate);
17424 if (PyErr_Occurred()) SWIG_fail;
17425 }
17426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17427 return resultobj;
17428 fail:
17429 return NULL;
17430 }
17431
17432
17433 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17434 PyObject *resultobj = 0;
17435 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17436 bool result;
17437 void *argp1 = 0 ;
17438 int res1 = 0 ;
17439 PyObject *swig_obj[1] ;
17440
17441 if (!args) SWIG_fail;
17442 swig_obj[0] = args;
17443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17444 if (!SWIG_IsOK(res1)) {
17445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17446 }
17447 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17448 {
17449 PyThreadState* __tstate = wxPyBeginAllowThreads();
17450 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17451 wxPyEndAllowThreads(__tstate);
17452 if (PyErr_Occurred()) SWIG_fail;
17453 }
17454 {
17455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17456 }
17457 return resultobj;
17458 fail:
17459 return NULL;
17460 }
17461
17462
17463 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17464 PyObject *resultobj = 0;
17465 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17466 wxString *arg2 = 0 ;
17467 int arg3 = (int) 0 ;
17468 void *argp1 = 0 ;
17469 int res1 = 0 ;
17470 bool temp2 = false ;
17471 int val3 ;
17472 int ecode3 = 0 ;
17473 PyObject * obj0 = 0 ;
17474 PyObject * obj1 = 0 ;
17475 PyObject * obj2 = 0 ;
17476 char * kwnames[] = {
17477 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17478 };
17479
17480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17482 if (!SWIG_IsOK(res1)) {
17483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17484 }
17485 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17486 {
17487 arg2 = wxString_in_helper(obj1);
17488 if (arg2 == NULL) SWIG_fail;
17489 temp2 = true;
17490 }
17491 if (obj2) {
17492 ecode3 = SWIG_AsVal_int(obj2, &val3);
17493 if (!SWIG_IsOK(ecode3)) {
17494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17495 }
17496 arg3 = static_cast< int >(val3);
17497 }
17498 {
17499 PyThreadState* __tstate = wxPyBeginAllowThreads();
17500 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17501 wxPyEndAllowThreads(__tstate);
17502 if (PyErr_Occurred()) SWIG_fail;
17503 }
17504 resultobj = SWIG_Py_Void();
17505 {
17506 if (temp2)
17507 delete arg2;
17508 }
17509 return resultobj;
17510 fail:
17511 {
17512 if (temp2)
17513 delete arg2;
17514 }
17515 return NULL;
17516 }
17517
17518
17519 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17520 PyObject *resultobj = 0;
17521 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17522 wxString *arg2 = 0 ;
17523 void *argp1 = 0 ;
17524 int res1 = 0 ;
17525 bool temp2 = false ;
17526 PyObject * obj0 = 0 ;
17527 PyObject * obj1 = 0 ;
17528 char * kwnames[] = {
17529 (char *) "self",(char *) "shortDesc", NULL
17530 };
17531
17532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17534 if (!SWIG_IsOK(res1)) {
17535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17536 }
17537 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17538 {
17539 arg2 = wxString_in_helper(obj1);
17540 if (arg2 == NULL) SWIG_fail;
17541 temp2 = true;
17542 }
17543 {
17544 PyThreadState* __tstate = wxPyBeginAllowThreads();
17545 (arg1)->SetShortDesc((wxString const &)*arg2);
17546 wxPyEndAllowThreads(__tstate);
17547 if (PyErr_Occurred()) SWIG_fail;
17548 }
17549 resultobj = SWIG_Py_Void();
17550 {
17551 if (temp2)
17552 delete arg2;
17553 }
17554 return resultobj;
17555 fail:
17556 {
17557 if (temp2)
17558 delete arg2;
17559 }
17560 return NULL;
17561 }
17562
17563
17564 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17565 PyObject *resultobj = 0;
17566 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17567 wxString *result = 0 ;
17568 void *argp1 = 0 ;
17569 int res1 = 0 ;
17570 PyObject *swig_obj[1] ;
17571
17572 if (!args) SWIG_fail;
17573 swig_obj[0] = args;
17574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17575 if (!SWIG_IsOK(res1)) {
17576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17577 }
17578 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17579 {
17580 PyThreadState* __tstate = wxPyBeginAllowThreads();
17581 {
17582 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17583 result = (wxString *) &_result_ref;
17584 }
17585 wxPyEndAllowThreads(__tstate);
17586 if (PyErr_Occurred()) SWIG_fail;
17587 }
17588 {
17589 #if wxUSE_UNICODE
17590 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17591 #else
17592 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17593 #endif
17594 }
17595 return resultobj;
17596 fail:
17597 return NULL;
17598 }
17599
17600
17601 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17602 PyObject *resultobj = 0;
17603 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17604 wxString *result = 0 ;
17605 void *argp1 = 0 ;
17606 int res1 = 0 ;
17607 PyObject *swig_obj[1] ;
17608
17609 if (!args) SWIG_fail;
17610 swig_obj[0] = args;
17611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17612 if (!SWIG_IsOK(res1)) {
17613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17614 }
17615 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17616 {
17617 PyThreadState* __tstate = wxPyBeginAllowThreads();
17618 {
17619 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17620 result = (wxString *) &_result_ref;
17621 }
17622 wxPyEndAllowThreads(__tstate);
17623 if (PyErr_Occurred()) SWIG_fail;
17624 }
17625 {
17626 #if wxUSE_UNICODE
17627 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17628 #else
17629 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17630 #endif
17631 }
17632 return resultobj;
17633 fail:
17634 return NULL;
17635 }
17636
17637
17638 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17639 PyObject *resultobj = 0;
17640 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17641 wxString *result = 0 ;
17642 void *argp1 = 0 ;
17643 int res1 = 0 ;
17644 PyObject *swig_obj[1] ;
17645
17646 if (!args) SWIG_fail;
17647 swig_obj[0] = args;
17648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17649 if (!SWIG_IsOK(res1)) {
17650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17651 }
17652 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17653 {
17654 PyThreadState* __tstate = wxPyBeginAllowThreads();
17655 {
17656 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17657 result = (wxString *) &_result_ref;
17658 }
17659 wxPyEndAllowThreads(__tstate);
17660 if (PyErr_Occurred()) SWIG_fail;
17661 }
17662 {
17663 #if wxUSE_UNICODE
17664 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17665 #else
17666 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17667 #endif
17668 }
17669 return resultobj;
17670 fail:
17671 return NULL;
17672 }
17673
17674
17675 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17676 PyObject *resultobj = 0;
17677 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17678 wxString *result = 0 ;
17679 void *argp1 = 0 ;
17680 int res1 = 0 ;
17681 PyObject *swig_obj[1] ;
17682
17683 if (!args) SWIG_fail;
17684 swig_obj[0] = args;
17685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17686 if (!SWIG_IsOK(res1)) {
17687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17688 }
17689 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17690 {
17691 PyThreadState* __tstate = wxPyBeginAllowThreads();
17692 {
17693 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17694 result = (wxString *) &_result_ref;
17695 }
17696 wxPyEndAllowThreads(__tstate);
17697 if (PyErr_Occurred()) SWIG_fail;
17698 }
17699 {
17700 #if wxUSE_UNICODE
17701 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17702 #else
17703 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17704 #endif
17705 }
17706 return resultobj;
17707 fail:
17708 return NULL;
17709 }
17710
17711
17712 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17713 PyObject *resultobj = 0;
17714 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17715 wxString *result = 0 ;
17716 void *argp1 = 0 ;
17717 int res1 = 0 ;
17718 PyObject *swig_obj[1] ;
17719
17720 if (!args) SWIG_fail;
17721 swig_obj[0] = args;
17722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17723 if (!SWIG_IsOK(res1)) {
17724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17725 }
17726 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17727 {
17728 PyThreadState* __tstate = wxPyBeginAllowThreads();
17729 {
17730 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17731 result = (wxString *) &_result_ref;
17732 }
17733 wxPyEndAllowThreads(__tstate);
17734 if (PyErr_Occurred()) SWIG_fail;
17735 }
17736 {
17737 #if wxUSE_UNICODE
17738 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17739 #else
17740 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17741 #endif
17742 }
17743 return resultobj;
17744 fail:
17745 return NULL;
17746 }
17747
17748
17749 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17750 PyObject *resultobj = 0;
17751 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17752 wxArrayString *result = 0 ;
17753 void *argp1 = 0 ;
17754 int res1 = 0 ;
17755 PyObject *swig_obj[1] ;
17756
17757 if (!args) SWIG_fail;
17758 swig_obj[0] = args;
17759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17760 if (!SWIG_IsOK(res1)) {
17761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17762 }
17763 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17764 {
17765 PyThreadState* __tstate = wxPyBeginAllowThreads();
17766 {
17767 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17768 result = (wxArrayString *) &_result_ref;
17769 }
17770 wxPyEndAllowThreads(__tstate);
17771 if (PyErr_Occurred()) SWIG_fail;
17772 }
17773 {
17774 resultobj = wxArrayString2PyList_helper(*result);
17775 }
17776 return resultobj;
17777 fail:
17778 return NULL;
17779 }
17780
17781
17782 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17783 PyObject *resultobj = 0;
17784 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17785 size_t result;
17786 void *argp1 = 0 ;
17787 int res1 = 0 ;
17788 PyObject *swig_obj[1] ;
17789
17790 if (!args) SWIG_fail;
17791 swig_obj[0] = args;
17792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17793 if (!SWIG_IsOK(res1)) {
17794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17795 }
17796 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17797 {
17798 PyThreadState* __tstate = wxPyBeginAllowThreads();
17799 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
17800 wxPyEndAllowThreads(__tstate);
17801 if (PyErr_Occurred()) SWIG_fail;
17802 }
17803 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
17804 return resultobj;
17805 fail:
17806 return NULL;
17807 }
17808
17809
17810 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17811 PyObject *resultobj = 0;
17812 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17813 wxString *result = 0 ;
17814 void *argp1 = 0 ;
17815 int res1 = 0 ;
17816 PyObject *swig_obj[1] ;
17817
17818 if (!args) SWIG_fail;
17819 swig_obj[0] = args;
17820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17821 if (!SWIG_IsOK(res1)) {
17822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17823 }
17824 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17825 {
17826 PyThreadState* __tstate = wxPyBeginAllowThreads();
17827 {
17828 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
17829 result = (wxString *) &_result_ref;
17830 }
17831 wxPyEndAllowThreads(__tstate);
17832 if (PyErr_Occurred()) SWIG_fail;
17833 }
17834 {
17835 #if wxUSE_UNICODE
17836 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17837 #else
17838 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17839 #endif
17840 }
17841 return resultobj;
17842 fail:
17843 return NULL;
17844 }
17845
17846
17847 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17848 PyObject *resultobj = 0;
17849 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17850 int result;
17851 void *argp1 = 0 ;
17852 int res1 = 0 ;
17853 PyObject *swig_obj[1] ;
17854
17855 if (!args) SWIG_fail;
17856 swig_obj[0] = args;
17857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17858 if (!SWIG_IsOK(res1)) {
17859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17860 }
17861 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17862 {
17863 PyThreadState* __tstate = wxPyBeginAllowThreads();
17864 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
17865 wxPyEndAllowThreads(__tstate);
17866 if (PyErr_Occurred()) SWIG_fail;
17867 }
17868 resultobj = SWIG_From_int(static_cast< int >(result));
17869 return resultobj;
17870 fail:
17871 return NULL;
17872 }
17873
17874
17875 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17876 PyObject *obj;
17877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17878 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
17879 return SWIG_Py_Void();
17880 }
17881
17882 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17883 return SWIG_Python_InitShadowInstance(args);
17884 }
17885
17886 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17887 PyObject *resultobj = 0;
17888 wxFileTypeInfo *arg1 = 0 ;
17889 wxFileType *result = 0 ;
17890 void *argp1 = 0 ;
17891 int res1 = 0 ;
17892 PyObject * obj0 = 0 ;
17893 char * kwnames[] = {
17894 (char *) "ftInfo", NULL
17895 };
17896
17897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
17898 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17899 if (!SWIG_IsOK(res1)) {
17900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
17901 }
17902 if (!argp1) {
17903 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
17904 }
17905 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17906 {
17907 PyThreadState* __tstate = wxPyBeginAllowThreads();
17908 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
17909 wxPyEndAllowThreads(__tstate);
17910 if (PyErr_Occurred()) SWIG_fail;
17911 }
17912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
17913 return resultobj;
17914 fail:
17915 return NULL;
17916 }
17917
17918
17919 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17920 PyObject *resultobj = 0;
17921 wxFileType *arg1 = (wxFileType *) 0 ;
17922 void *argp1 = 0 ;
17923 int res1 = 0 ;
17924 PyObject *swig_obj[1] ;
17925
17926 if (!args) SWIG_fail;
17927 swig_obj[0] = args;
17928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
17929 if (!SWIG_IsOK(res1)) {
17930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
17931 }
17932 arg1 = reinterpret_cast< wxFileType * >(argp1);
17933 {
17934 PyThreadState* __tstate = wxPyBeginAllowThreads();
17935 delete arg1;
17936
17937 wxPyEndAllowThreads(__tstate);
17938 if (PyErr_Occurred()) SWIG_fail;
17939 }
17940 resultobj = SWIG_Py_Void();
17941 return resultobj;
17942 fail:
17943 return NULL;
17944 }
17945
17946
17947 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17948 PyObject *resultobj = 0;
17949 wxFileType *arg1 = (wxFileType *) 0 ;
17950 PyObject *result = 0 ;
17951 void *argp1 = 0 ;
17952 int res1 = 0 ;
17953 PyObject *swig_obj[1] ;
17954
17955 if (!args) SWIG_fail;
17956 swig_obj[0] = args;
17957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17958 if (!SWIG_IsOK(res1)) {
17959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
17960 }
17961 arg1 = reinterpret_cast< wxFileType * >(argp1);
17962 {
17963 PyThreadState* __tstate = wxPyBeginAllowThreads();
17964 result = (PyObject *)wxFileType_GetMimeType(arg1);
17965 wxPyEndAllowThreads(__tstate);
17966 if (PyErr_Occurred()) SWIG_fail;
17967 }
17968 resultobj = result;
17969 return resultobj;
17970 fail:
17971 return NULL;
17972 }
17973
17974
17975 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17976 PyObject *resultobj = 0;
17977 wxFileType *arg1 = (wxFileType *) 0 ;
17978 PyObject *result = 0 ;
17979 void *argp1 = 0 ;
17980 int res1 = 0 ;
17981 PyObject *swig_obj[1] ;
17982
17983 if (!args) SWIG_fail;
17984 swig_obj[0] = args;
17985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17986 if (!SWIG_IsOK(res1)) {
17987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
17988 }
17989 arg1 = reinterpret_cast< wxFileType * >(argp1);
17990 {
17991 PyThreadState* __tstate = wxPyBeginAllowThreads();
17992 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
17993 wxPyEndAllowThreads(__tstate);
17994 if (PyErr_Occurred()) SWIG_fail;
17995 }
17996 resultobj = result;
17997 return resultobj;
17998 fail:
17999 return NULL;
18000 }
18001
18002
18003 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18004 PyObject *resultobj = 0;
18005 wxFileType *arg1 = (wxFileType *) 0 ;
18006 PyObject *result = 0 ;
18007 void *argp1 = 0 ;
18008 int res1 = 0 ;
18009 PyObject *swig_obj[1] ;
18010
18011 if (!args) SWIG_fail;
18012 swig_obj[0] = args;
18013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18014 if (!SWIG_IsOK(res1)) {
18015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18016 }
18017 arg1 = reinterpret_cast< wxFileType * >(argp1);
18018 {
18019 PyThreadState* __tstate = wxPyBeginAllowThreads();
18020 result = (PyObject *)wxFileType_GetExtensions(arg1);
18021 wxPyEndAllowThreads(__tstate);
18022 if (PyErr_Occurred()) SWIG_fail;
18023 }
18024 resultobj = result;
18025 return resultobj;
18026 fail:
18027 return NULL;
18028 }
18029
18030
18031 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18032 PyObject *resultobj = 0;
18033 wxFileType *arg1 = (wxFileType *) 0 ;
18034 wxIcon *result = 0 ;
18035 void *argp1 = 0 ;
18036 int res1 = 0 ;
18037 PyObject *swig_obj[1] ;
18038
18039 if (!args) SWIG_fail;
18040 swig_obj[0] = args;
18041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18042 if (!SWIG_IsOK(res1)) {
18043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18044 }
18045 arg1 = reinterpret_cast< wxFileType * >(argp1);
18046 {
18047 PyThreadState* __tstate = wxPyBeginAllowThreads();
18048 result = (wxIcon *)wxFileType_GetIcon(arg1);
18049 wxPyEndAllowThreads(__tstate);
18050 if (PyErr_Occurred()) SWIG_fail;
18051 }
18052 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18053 return resultobj;
18054 fail:
18055 return NULL;
18056 }
18057
18058
18059 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18060 PyObject *resultobj = 0;
18061 wxFileType *arg1 = (wxFileType *) 0 ;
18062 PyObject *result = 0 ;
18063 void *argp1 = 0 ;
18064 int res1 = 0 ;
18065 PyObject *swig_obj[1] ;
18066
18067 if (!args) SWIG_fail;
18068 swig_obj[0] = args;
18069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18070 if (!SWIG_IsOK(res1)) {
18071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18072 }
18073 arg1 = reinterpret_cast< wxFileType * >(argp1);
18074 {
18075 PyThreadState* __tstate = wxPyBeginAllowThreads();
18076 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18077 wxPyEndAllowThreads(__tstate);
18078 if (PyErr_Occurred()) SWIG_fail;
18079 }
18080 resultobj = result;
18081 return resultobj;
18082 fail:
18083 return NULL;
18084 }
18085
18086
18087 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18088 PyObject *resultobj = 0;
18089 wxFileType *arg1 = (wxFileType *) 0 ;
18090 PyObject *result = 0 ;
18091 void *argp1 = 0 ;
18092 int res1 = 0 ;
18093 PyObject *swig_obj[1] ;
18094
18095 if (!args) SWIG_fail;
18096 swig_obj[0] = args;
18097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18098 if (!SWIG_IsOK(res1)) {
18099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18100 }
18101 arg1 = reinterpret_cast< wxFileType * >(argp1);
18102 {
18103 PyThreadState* __tstate = wxPyBeginAllowThreads();
18104 result = (PyObject *)wxFileType_GetDescription(arg1);
18105 wxPyEndAllowThreads(__tstate);
18106 if (PyErr_Occurred()) SWIG_fail;
18107 }
18108 resultobj = result;
18109 return resultobj;
18110 fail:
18111 return NULL;
18112 }
18113
18114
18115 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18116 PyObject *resultobj = 0;
18117 wxFileType *arg1 = (wxFileType *) 0 ;
18118 wxString *arg2 = 0 ;
18119 wxString const &arg3_defvalue = wxPyEmptyString ;
18120 wxString *arg3 = (wxString *) &arg3_defvalue ;
18121 PyObject *result = 0 ;
18122 void *argp1 = 0 ;
18123 int res1 = 0 ;
18124 bool temp2 = false ;
18125 bool temp3 = false ;
18126 PyObject * obj0 = 0 ;
18127 PyObject * obj1 = 0 ;
18128 PyObject * obj2 = 0 ;
18129 char * kwnames[] = {
18130 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18131 };
18132
18133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18135 if (!SWIG_IsOK(res1)) {
18136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18137 }
18138 arg1 = reinterpret_cast< wxFileType * >(argp1);
18139 {
18140 arg2 = wxString_in_helper(obj1);
18141 if (arg2 == NULL) SWIG_fail;
18142 temp2 = true;
18143 }
18144 if (obj2) {
18145 {
18146 arg3 = wxString_in_helper(obj2);
18147 if (arg3 == NULL) SWIG_fail;
18148 temp3 = true;
18149 }
18150 }
18151 {
18152 PyThreadState* __tstate = wxPyBeginAllowThreads();
18153 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18154 wxPyEndAllowThreads(__tstate);
18155 if (PyErr_Occurred()) SWIG_fail;
18156 }
18157 resultobj = result;
18158 {
18159 if (temp2)
18160 delete arg2;
18161 }
18162 {
18163 if (temp3)
18164 delete arg3;
18165 }
18166 return resultobj;
18167 fail:
18168 {
18169 if (temp2)
18170 delete arg2;
18171 }
18172 {
18173 if (temp3)
18174 delete arg3;
18175 }
18176 return NULL;
18177 }
18178
18179
18180 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18181 PyObject *resultobj = 0;
18182 wxFileType *arg1 = (wxFileType *) 0 ;
18183 wxString *arg2 = 0 ;
18184 wxString const &arg3_defvalue = wxPyEmptyString ;
18185 wxString *arg3 = (wxString *) &arg3_defvalue ;
18186 PyObject *result = 0 ;
18187 void *argp1 = 0 ;
18188 int res1 = 0 ;
18189 bool temp2 = false ;
18190 bool temp3 = false ;
18191 PyObject * obj0 = 0 ;
18192 PyObject * obj1 = 0 ;
18193 PyObject * obj2 = 0 ;
18194 char * kwnames[] = {
18195 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18196 };
18197
18198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18200 if (!SWIG_IsOK(res1)) {
18201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18202 }
18203 arg1 = reinterpret_cast< wxFileType * >(argp1);
18204 {
18205 arg2 = wxString_in_helper(obj1);
18206 if (arg2 == NULL) SWIG_fail;
18207 temp2 = true;
18208 }
18209 if (obj2) {
18210 {
18211 arg3 = wxString_in_helper(obj2);
18212 if (arg3 == NULL) SWIG_fail;
18213 temp3 = true;
18214 }
18215 }
18216 {
18217 PyThreadState* __tstate = wxPyBeginAllowThreads();
18218 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18219 wxPyEndAllowThreads(__tstate);
18220 if (PyErr_Occurred()) SWIG_fail;
18221 }
18222 resultobj = result;
18223 {
18224 if (temp2)
18225 delete arg2;
18226 }
18227 {
18228 if (temp3)
18229 delete arg3;
18230 }
18231 return resultobj;
18232 fail:
18233 {
18234 if (temp2)
18235 delete arg2;
18236 }
18237 {
18238 if (temp3)
18239 delete arg3;
18240 }
18241 return NULL;
18242 }
18243
18244
18245 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18246 PyObject *resultobj = 0;
18247 wxFileType *arg1 = (wxFileType *) 0 ;
18248 wxString *arg2 = 0 ;
18249 wxString const &arg3_defvalue = wxPyEmptyString ;
18250 wxString *arg3 = (wxString *) &arg3_defvalue ;
18251 PyObject *result = 0 ;
18252 void *argp1 = 0 ;
18253 int res1 = 0 ;
18254 bool temp2 = false ;
18255 bool temp3 = false ;
18256 PyObject * obj0 = 0 ;
18257 PyObject * obj1 = 0 ;
18258 PyObject * obj2 = 0 ;
18259 char * kwnames[] = {
18260 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18261 };
18262
18263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18265 if (!SWIG_IsOK(res1)) {
18266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18267 }
18268 arg1 = reinterpret_cast< wxFileType * >(argp1);
18269 {
18270 arg2 = wxString_in_helper(obj1);
18271 if (arg2 == NULL) SWIG_fail;
18272 temp2 = true;
18273 }
18274 if (obj2) {
18275 {
18276 arg3 = wxString_in_helper(obj2);
18277 if (arg3 == NULL) SWIG_fail;
18278 temp3 = true;
18279 }
18280 }
18281 {
18282 PyThreadState* __tstate = wxPyBeginAllowThreads();
18283 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18284 wxPyEndAllowThreads(__tstate);
18285 if (PyErr_Occurred()) SWIG_fail;
18286 }
18287 resultobj = result;
18288 {
18289 if (temp2)
18290 delete arg2;
18291 }
18292 {
18293 if (temp3)
18294 delete arg3;
18295 }
18296 return resultobj;
18297 fail:
18298 {
18299 if (temp2)
18300 delete arg2;
18301 }
18302 {
18303 if (temp3)
18304 delete arg3;
18305 }
18306 return NULL;
18307 }
18308
18309
18310 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18311 PyObject *resultobj = 0;
18312 wxFileType *arg1 = (wxFileType *) 0 ;
18313 wxString *arg2 = 0 ;
18314 wxString *arg3 = 0 ;
18315 bool arg4 = (bool) true ;
18316 bool result;
18317 void *argp1 = 0 ;
18318 int res1 = 0 ;
18319 bool temp2 = false ;
18320 bool temp3 = false ;
18321 bool val4 ;
18322 int ecode4 = 0 ;
18323 PyObject * obj0 = 0 ;
18324 PyObject * obj1 = 0 ;
18325 PyObject * obj2 = 0 ;
18326 PyObject * obj3 = 0 ;
18327 char * kwnames[] = {
18328 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18329 };
18330
18331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18333 if (!SWIG_IsOK(res1)) {
18334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18335 }
18336 arg1 = reinterpret_cast< wxFileType * >(argp1);
18337 {
18338 arg2 = wxString_in_helper(obj1);
18339 if (arg2 == NULL) SWIG_fail;
18340 temp2 = true;
18341 }
18342 {
18343 arg3 = wxString_in_helper(obj2);
18344 if (arg3 == NULL) SWIG_fail;
18345 temp3 = true;
18346 }
18347 if (obj3) {
18348 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18349 if (!SWIG_IsOK(ecode4)) {
18350 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18351 }
18352 arg4 = static_cast< bool >(val4);
18353 }
18354 {
18355 PyThreadState* __tstate = wxPyBeginAllowThreads();
18356 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18357 wxPyEndAllowThreads(__tstate);
18358 if (PyErr_Occurred()) SWIG_fail;
18359 }
18360 {
18361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18362 }
18363 {
18364 if (temp2)
18365 delete arg2;
18366 }
18367 {
18368 if (temp3)
18369 delete arg3;
18370 }
18371 return resultobj;
18372 fail:
18373 {
18374 if (temp2)
18375 delete arg2;
18376 }
18377 {
18378 if (temp3)
18379 delete arg3;
18380 }
18381 return NULL;
18382 }
18383
18384
18385 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18386 PyObject *resultobj = 0;
18387 wxFileType *arg1 = (wxFileType *) 0 ;
18388 wxString const &arg2_defvalue = wxPyEmptyString ;
18389 wxString *arg2 = (wxString *) &arg2_defvalue ;
18390 int arg3 = (int) 0 ;
18391 bool result;
18392 void *argp1 = 0 ;
18393 int res1 = 0 ;
18394 bool temp2 = false ;
18395 int val3 ;
18396 int ecode3 = 0 ;
18397 PyObject * obj0 = 0 ;
18398 PyObject * obj1 = 0 ;
18399 PyObject * obj2 = 0 ;
18400 char * kwnames[] = {
18401 (char *) "self",(char *) "cmd",(char *) "index", NULL
18402 };
18403
18404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18406 if (!SWIG_IsOK(res1)) {
18407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18408 }
18409 arg1 = reinterpret_cast< wxFileType * >(argp1);
18410 if (obj1) {
18411 {
18412 arg2 = wxString_in_helper(obj1);
18413 if (arg2 == NULL) SWIG_fail;
18414 temp2 = true;
18415 }
18416 }
18417 if (obj2) {
18418 ecode3 = SWIG_AsVal_int(obj2, &val3);
18419 if (!SWIG_IsOK(ecode3)) {
18420 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18421 }
18422 arg3 = static_cast< int >(val3);
18423 }
18424 {
18425 PyThreadState* __tstate = wxPyBeginAllowThreads();
18426 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18427 wxPyEndAllowThreads(__tstate);
18428 if (PyErr_Occurred()) SWIG_fail;
18429 }
18430 {
18431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18432 }
18433 {
18434 if (temp2)
18435 delete arg2;
18436 }
18437 return resultobj;
18438 fail:
18439 {
18440 if (temp2)
18441 delete arg2;
18442 }
18443 return NULL;
18444 }
18445
18446
18447 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18448 PyObject *resultobj = 0;
18449 wxFileType *arg1 = (wxFileType *) 0 ;
18450 bool result;
18451 void *argp1 = 0 ;
18452 int res1 = 0 ;
18453 PyObject *swig_obj[1] ;
18454
18455 if (!args) SWIG_fail;
18456 swig_obj[0] = args;
18457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18458 if (!SWIG_IsOK(res1)) {
18459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18460 }
18461 arg1 = reinterpret_cast< wxFileType * >(argp1);
18462 {
18463 PyThreadState* __tstate = wxPyBeginAllowThreads();
18464 result = (bool)(arg1)->Unassociate();
18465 wxPyEndAllowThreads(__tstate);
18466 if (PyErr_Occurred()) SWIG_fail;
18467 }
18468 {
18469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18470 }
18471 return resultobj;
18472 fail:
18473 return NULL;
18474 }
18475
18476
18477 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18478 PyObject *resultobj = 0;
18479 wxString *arg1 = 0 ;
18480 wxString *arg2 = 0 ;
18481 wxString const &arg3_defvalue = wxPyEmptyString ;
18482 wxString *arg3 = (wxString *) &arg3_defvalue ;
18483 wxString result;
18484 bool temp1 = false ;
18485 bool temp2 = false ;
18486 bool temp3 = false ;
18487 PyObject * obj0 = 0 ;
18488 PyObject * obj1 = 0 ;
18489 PyObject * obj2 = 0 ;
18490 char * kwnames[] = {
18491 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18492 };
18493
18494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18495 {
18496 arg1 = wxString_in_helper(obj0);
18497 if (arg1 == NULL) SWIG_fail;
18498 temp1 = true;
18499 }
18500 {
18501 arg2 = wxString_in_helper(obj1);
18502 if (arg2 == NULL) SWIG_fail;
18503 temp2 = true;
18504 }
18505 if (obj2) {
18506 {
18507 arg3 = wxString_in_helper(obj2);
18508 if (arg3 == NULL) SWIG_fail;
18509 temp3 = true;
18510 }
18511 }
18512 {
18513 PyThreadState* __tstate = wxPyBeginAllowThreads();
18514 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18515 wxPyEndAllowThreads(__tstate);
18516 if (PyErr_Occurred()) SWIG_fail;
18517 }
18518 {
18519 #if wxUSE_UNICODE
18520 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18521 #else
18522 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18523 #endif
18524 }
18525 {
18526 if (temp1)
18527 delete arg1;
18528 }
18529 {
18530 if (temp2)
18531 delete arg2;
18532 }
18533 {
18534 if (temp3)
18535 delete arg3;
18536 }
18537 return resultobj;
18538 fail:
18539 {
18540 if (temp1)
18541 delete arg1;
18542 }
18543 {
18544 if (temp2)
18545 delete arg2;
18546 }
18547 {
18548 if (temp3)
18549 delete arg3;
18550 }
18551 return NULL;
18552 }
18553
18554
18555 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18556 PyObject *obj;
18557 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18558 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18559 return SWIG_Py_Void();
18560 }
18561
18562 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18563 return SWIG_Python_InitShadowInstance(args);
18564 }
18565
18566 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18567 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18568 return 1;
18569 }
18570
18571
18572 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18573 PyObject *pyobj = 0;
18574
18575 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18576 return pyobj;
18577 }
18578
18579
18580 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18581 PyObject *resultobj = 0;
18582 wxString *arg1 = 0 ;
18583 wxString *arg2 = 0 ;
18584 bool result;
18585 bool temp1 = false ;
18586 bool temp2 = false ;
18587 PyObject * obj0 = 0 ;
18588 PyObject * obj1 = 0 ;
18589 char * kwnames[] = {
18590 (char *) "mimeType",(char *) "wildcard", NULL
18591 };
18592
18593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18594 {
18595 arg1 = wxString_in_helper(obj0);
18596 if (arg1 == NULL) SWIG_fail;
18597 temp1 = true;
18598 }
18599 {
18600 arg2 = wxString_in_helper(obj1);
18601 if (arg2 == NULL) SWIG_fail;
18602 temp2 = true;
18603 }
18604 {
18605 PyThreadState* __tstate = wxPyBeginAllowThreads();
18606 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18607 wxPyEndAllowThreads(__tstate);
18608 if (PyErr_Occurred()) SWIG_fail;
18609 }
18610 {
18611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18612 }
18613 {
18614 if (temp1)
18615 delete arg1;
18616 }
18617 {
18618 if (temp2)
18619 delete arg2;
18620 }
18621 return resultobj;
18622 fail:
18623 {
18624 if (temp1)
18625 delete arg1;
18626 }
18627 {
18628 if (temp2)
18629 delete arg2;
18630 }
18631 return NULL;
18632 }
18633
18634
18635 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18636 PyObject *resultobj = 0;
18637 wxMimeTypesManager *result = 0 ;
18638
18639 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18640 {
18641 PyThreadState* __tstate = wxPyBeginAllowThreads();
18642 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18643 wxPyEndAllowThreads(__tstate);
18644 if (PyErr_Occurred()) SWIG_fail;
18645 }
18646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18647 return resultobj;
18648 fail:
18649 return NULL;
18650 }
18651
18652
18653 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18654 PyObject *resultobj = 0;
18655 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18656 int arg2 = (int) wxMAILCAP_ALL ;
18657 wxString const &arg3_defvalue = wxPyEmptyString ;
18658 wxString *arg3 = (wxString *) &arg3_defvalue ;
18659 void *argp1 = 0 ;
18660 int res1 = 0 ;
18661 int val2 ;
18662 int ecode2 = 0 ;
18663 bool temp3 = false ;
18664 PyObject * obj0 = 0 ;
18665 PyObject * obj1 = 0 ;
18666 PyObject * obj2 = 0 ;
18667 char * kwnames[] = {
18668 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18669 };
18670
18671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18673 if (!SWIG_IsOK(res1)) {
18674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18675 }
18676 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18677 if (obj1) {
18678 ecode2 = SWIG_AsVal_int(obj1, &val2);
18679 if (!SWIG_IsOK(ecode2)) {
18680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18681 }
18682 arg2 = static_cast< int >(val2);
18683 }
18684 if (obj2) {
18685 {
18686 arg3 = wxString_in_helper(obj2);
18687 if (arg3 == NULL) SWIG_fail;
18688 temp3 = true;
18689 }
18690 }
18691 {
18692 PyThreadState* __tstate = wxPyBeginAllowThreads();
18693 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18694 wxPyEndAllowThreads(__tstate);
18695 if (PyErr_Occurred()) SWIG_fail;
18696 }
18697 resultobj = SWIG_Py_Void();
18698 {
18699 if (temp3)
18700 delete arg3;
18701 }
18702 return resultobj;
18703 fail:
18704 {
18705 if (temp3)
18706 delete arg3;
18707 }
18708 return NULL;
18709 }
18710
18711
18712 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18713 PyObject *resultobj = 0;
18714 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18715 void *argp1 = 0 ;
18716 int res1 = 0 ;
18717 PyObject *swig_obj[1] ;
18718
18719 if (!args) SWIG_fail;
18720 swig_obj[0] = args;
18721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18722 if (!SWIG_IsOK(res1)) {
18723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18724 }
18725 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18726 {
18727 PyThreadState* __tstate = wxPyBeginAllowThreads();
18728 (arg1)->ClearData();
18729 wxPyEndAllowThreads(__tstate);
18730 if (PyErr_Occurred()) SWIG_fail;
18731 }
18732 resultobj = SWIG_Py_Void();
18733 return resultobj;
18734 fail:
18735 return NULL;
18736 }
18737
18738
18739 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18740 PyObject *resultobj = 0;
18741 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18742 wxString *arg2 = 0 ;
18743 wxFileType *result = 0 ;
18744 void *argp1 = 0 ;
18745 int res1 = 0 ;
18746 bool temp2 = false ;
18747 PyObject * obj0 = 0 ;
18748 PyObject * obj1 = 0 ;
18749 char * kwnames[] = {
18750 (char *) "self",(char *) "ext", NULL
18751 };
18752
18753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18755 if (!SWIG_IsOK(res1)) {
18756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18757 }
18758 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18759 {
18760 arg2 = wxString_in_helper(obj1);
18761 if (arg2 == NULL) SWIG_fail;
18762 temp2 = true;
18763 }
18764 {
18765 PyThreadState* __tstate = wxPyBeginAllowThreads();
18766 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18767 wxPyEndAllowThreads(__tstate);
18768 if (PyErr_Occurred()) SWIG_fail;
18769 }
18770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18771 {
18772 if (temp2)
18773 delete arg2;
18774 }
18775 return resultobj;
18776 fail:
18777 {
18778 if (temp2)
18779 delete arg2;
18780 }
18781 return NULL;
18782 }
18783
18784
18785 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18786 PyObject *resultobj = 0;
18787 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18788 wxString *arg2 = 0 ;
18789 wxFileType *result = 0 ;
18790 void *argp1 = 0 ;
18791 int res1 = 0 ;
18792 bool temp2 = false ;
18793 PyObject * obj0 = 0 ;
18794 PyObject * obj1 = 0 ;
18795 char * kwnames[] = {
18796 (char *) "self",(char *) "mimeType", NULL
18797 };
18798
18799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
18800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18801 if (!SWIG_IsOK(res1)) {
18802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18803 }
18804 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18805 {
18806 arg2 = wxString_in_helper(obj1);
18807 if (arg2 == NULL) SWIG_fail;
18808 temp2 = true;
18809 }
18810 {
18811 PyThreadState* __tstate = wxPyBeginAllowThreads();
18812 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
18813 wxPyEndAllowThreads(__tstate);
18814 if (PyErr_Occurred()) SWIG_fail;
18815 }
18816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18817 {
18818 if (temp2)
18819 delete arg2;
18820 }
18821 return resultobj;
18822 fail:
18823 {
18824 if (temp2)
18825 delete arg2;
18826 }
18827 return NULL;
18828 }
18829
18830
18831 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18832 PyObject *resultobj = 0;
18833 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18834 wxString *arg2 = 0 ;
18835 bool arg3 = (bool) false ;
18836 bool result;
18837 void *argp1 = 0 ;
18838 int res1 = 0 ;
18839 bool temp2 = false ;
18840 bool val3 ;
18841 int ecode3 = 0 ;
18842 PyObject * obj0 = 0 ;
18843 PyObject * obj1 = 0 ;
18844 PyObject * obj2 = 0 ;
18845 char * kwnames[] = {
18846 (char *) "self",(char *) "filename",(char *) "fallback", NULL
18847 };
18848
18849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18851 if (!SWIG_IsOK(res1)) {
18852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18853 }
18854 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18855 {
18856 arg2 = wxString_in_helper(obj1);
18857 if (arg2 == NULL) SWIG_fail;
18858 temp2 = true;
18859 }
18860 if (obj2) {
18861 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18862 if (!SWIG_IsOK(ecode3)) {
18863 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
18864 }
18865 arg3 = static_cast< bool >(val3);
18866 }
18867 {
18868 PyThreadState* __tstate = wxPyBeginAllowThreads();
18869 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
18870 wxPyEndAllowThreads(__tstate);
18871 if (PyErr_Occurred()) SWIG_fail;
18872 }
18873 {
18874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18875 }
18876 {
18877 if (temp2)
18878 delete arg2;
18879 }
18880 return resultobj;
18881 fail:
18882 {
18883 if (temp2)
18884 delete arg2;
18885 }
18886 return NULL;
18887 }
18888
18889
18890 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18891 PyObject *resultobj = 0;
18892 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18893 wxString *arg2 = 0 ;
18894 bool result;
18895 void *argp1 = 0 ;
18896 int res1 = 0 ;
18897 bool temp2 = false ;
18898 PyObject * obj0 = 0 ;
18899 PyObject * obj1 = 0 ;
18900 char * kwnames[] = {
18901 (char *) "self",(char *) "filename", NULL
18902 };
18903
18904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
18905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18906 if (!SWIG_IsOK(res1)) {
18907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18908 }
18909 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18910 {
18911 arg2 = wxString_in_helper(obj1);
18912 if (arg2 == NULL) SWIG_fail;
18913 temp2 = true;
18914 }
18915 {
18916 PyThreadState* __tstate = wxPyBeginAllowThreads();
18917 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
18918 wxPyEndAllowThreads(__tstate);
18919 if (PyErr_Occurred()) SWIG_fail;
18920 }
18921 {
18922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18923 }
18924 {
18925 if (temp2)
18926 delete arg2;
18927 }
18928 return resultobj;
18929 fail:
18930 {
18931 if (temp2)
18932 delete arg2;
18933 }
18934 return NULL;
18935 }
18936
18937
18938 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18939 PyObject *resultobj = 0;
18940 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18941 PyObject *result = 0 ;
18942 void *argp1 = 0 ;
18943 int res1 = 0 ;
18944 PyObject *swig_obj[1] ;
18945
18946 if (!args) SWIG_fail;
18947 swig_obj[0] = args;
18948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18949 if (!SWIG_IsOK(res1)) {
18950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18951 }
18952 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18953 {
18954 PyThreadState* __tstate = wxPyBeginAllowThreads();
18955 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
18956 wxPyEndAllowThreads(__tstate);
18957 if (PyErr_Occurred()) SWIG_fail;
18958 }
18959 resultobj = result;
18960 return resultobj;
18961 fail:
18962 return NULL;
18963 }
18964
18965
18966 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18967 PyObject *resultobj = 0;
18968 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18969 wxFileTypeInfo *arg2 = 0 ;
18970 void *argp1 = 0 ;
18971 int res1 = 0 ;
18972 void *argp2 = 0 ;
18973 int res2 = 0 ;
18974 PyObject * obj0 = 0 ;
18975 PyObject * obj1 = 0 ;
18976 char * kwnames[] = {
18977 (char *) "self",(char *) "ft", NULL
18978 };
18979
18980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
18981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18982 if (!SWIG_IsOK(res1)) {
18983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18984 }
18985 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18986 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18987 if (!SWIG_IsOK(res2)) {
18988 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18989 }
18990 if (!argp2) {
18991 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18992 }
18993 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
18994 {
18995 PyThreadState* __tstate = wxPyBeginAllowThreads();
18996 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
18997 wxPyEndAllowThreads(__tstate);
18998 if (PyErr_Occurred()) SWIG_fail;
18999 }
19000 resultobj = SWIG_Py_Void();
19001 return resultobj;
19002 fail:
19003 return NULL;
19004 }
19005
19006
19007 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19008 PyObject *resultobj = 0;
19009 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19010 wxFileTypeInfo *arg2 = 0 ;
19011 wxFileType *result = 0 ;
19012 void *argp1 = 0 ;
19013 int res1 = 0 ;
19014 void *argp2 = 0 ;
19015 int res2 = 0 ;
19016 PyObject * obj0 = 0 ;
19017 PyObject * obj1 = 0 ;
19018 char * kwnames[] = {
19019 (char *) "self",(char *) "ftInfo", NULL
19020 };
19021
19022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19024 if (!SWIG_IsOK(res1)) {
19025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19026 }
19027 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19028 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19029 if (!SWIG_IsOK(res2)) {
19030 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19031 }
19032 if (!argp2) {
19033 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19034 }
19035 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19036 {
19037 PyThreadState* __tstate = wxPyBeginAllowThreads();
19038 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19039 wxPyEndAllowThreads(__tstate);
19040 if (PyErr_Occurred()) SWIG_fail;
19041 }
19042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19043 return resultobj;
19044 fail:
19045 return NULL;
19046 }
19047
19048
19049 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19050 PyObject *resultobj = 0;
19051 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19052 wxFileType *arg2 = (wxFileType *) 0 ;
19053 bool result;
19054 void *argp1 = 0 ;
19055 int res1 = 0 ;
19056 void *argp2 = 0 ;
19057 int res2 = 0 ;
19058 PyObject * obj0 = 0 ;
19059 PyObject * obj1 = 0 ;
19060 char * kwnames[] = {
19061 (char *) "self",(char *) "ft", NULL
19062 };
19063
19064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19066 if (!SWIG_IsOK(res1)) {
19067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19068 }
19069 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19070 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19071 if (!SWIG_IsOK(res2)) {
19072 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19073 }
19074 arg2 = reinterpret_cast< wxFileType * >(argp2);
19075 {
19076 PyThreadState* __tstate = wxPyBeginAllowThreads();
19077 result = (bool)(arg1)->Unassociate(arg2);
19078 wxPyEndAllowThreads(__tstate);
19079 if (PyErr_Occurred()) SWIG_fail;
19080 }
19081 {
19082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19083 }
19084 return resultobj;
19085 fail:
19086 return NULL;
19087 }
19088
19089
19090 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19091 PyObject *resultobj = 0;
19092 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19093 void *argp1 = 0 ;
19094 int res1 = 0 ;
19095 PyObject *swig_obj[1] ;
19096
19097 if (!args) SWIG_fail;
19098 swig_obj[0] = args;
19099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19100 if (!SWIG_IsOK(res1)) {
19101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19102 }
19103 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19104 {
19105 PyThreadState* __tstate = wxPyBeginAllowThreads();
19106 delete arg1;
19107
19108 wxPyEndAllowThreads(__tstate);
19109 if (PyErr_Occurred()) SWIG_fail;
19110 }
19111 resultobj = SWIG_Py_Void();
19112 return resultobj;
19113 fail:
19114 return NULL;
19115 }
19116
19117
19118 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19119 PyObject *obj;
19120 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19121 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19122 return SWIG_Py_Void();
19123 }
19124
19125 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19126 return SWIG_Python_InitShadowInstance(args);
19127 }
19128
19129 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19130 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19131 return 1;
19132 }
19133
19134
19135 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19136 PyObject *pyobj = 0;
19137
19138 {
19139 #if wxUSE_UNICODE
19140 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19141 #else
19142 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19143 #endif
19144 }
19145 return pyobj;
19146 }
19147
19148
19149 SWIGINTERN int ART_MENU_set(PyObject *) {
19150 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19151 return 1;
19152 }
19153
19154
19155 SWIGINTERN PyObject *ART_MENU_get(void) {
19156 PyObject *pyobj = 0;
19157
19158 {
19159 #if wxUSE_UNICODE
19160 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19161 #else
19162 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19163 #endif
19164 }
19165 return pyobj;
19166 }
19167
19168
19169 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19170 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19171 return 1;
19172 }
19173
19174
19175 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19176 PyObject *pyobj = 0;
19177
19178 {
19179 #if wxUSE_UNICODE
19180 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19181 #else
19182 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19183 #endif
19184 }
19185 return pyobj;
19186 }
19187
19188
19189 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19190 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19191 return 1;
19192 }
19193
19194
19195 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19196 PyObject *pyobj = 0;
19197
19198 {
19199 #if wxUSE_UNICODE
19200 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19201 #else
19202 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19203 #endif
19204 }
19205 return pyobj;
19206 }
19207
19208
19209 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19210 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19211 return 1;
19212 }
19213
19214
19215 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19216 PyObject *pyobj = 0;
19217
19218 {
19219 #if wxUSE_UNICODE
19220 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19221 #else
19222 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19223 #endif
19224 }
19225 return pyobj;
19226 }
19227
19228
19229 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19230 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19231 return 1;
19232 }
19233
19234
19235 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19236 PyObject *pyobj = 0;
19237
19238 {
19239 #if wxUSE_UNICODE
19240 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19241 #else
19242 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19243 #endif
19244 }
19245 return pyobj;
19246 }
19247
19248
19249 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19250 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19251 return 1;
19252 }
19253
19254
19255 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19256 PyObject *pyobj = 0;
19257
19258 {
19259 #if wxUSE_UNICODE
19260 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19261 #else
19262 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19263 #endif
19264 }
19265 return pyobj;
19266 }
19267
19268
19269 SWIGINTERN int ART_OTHER_set(PyObject *) {
19270 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19271 return 1;
19272 }
19273
19274
19275 SWIGINTERN PyObject *ART_OTHER_get(void) {
19276 PyObject *pyobj = 0;
19277
19278 {
19279 #if wxUSE_UNICODE
19280 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19281 #else
19282 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19283 #endif
19284 }
19285 return pyobj;
19286 }
19287
19288
19289 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19290 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19291 return 1;
19292 }
19293
19294
19295 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19296 PyObject *pyobj = 0;
19297
19298 {
19299 #if wxUSE_UNICODE
19300 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19301 #else
19302 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19303 #endif
19304 }
19305 return pyobj;
19306 }
19307
19308
19309 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19310 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19311 return 1;
19312 }
19313
19314
19315 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19316 PyObject *pyobj = 0;
19317
19318 {
19319 #if wxUSE_UNICODE
19320 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19321 #else
19322 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19323 #endif
19324 }
19325 return pyobj;
19326 }
19327
19328
19329 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19330 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19331 return 1;
19332 }
19333
19334
19335 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19336 PyObject *pyobj = 0;
19337
19338 {
19339 #if wxUSE_UNICODE
19340 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19341 #else
19342 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19343 #endif
19344 }
19345 return pyobj;
19346 }
19347
19348
19349 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19350 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19351 return 1;
19352 }
19353
19354
19355 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19356 PyObject *pyobj = 0;
19357
19358 {
19359 #if wxUSE_UNICODE
19360 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19361 #else
19362 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19363 #endif
19364 }
19365 return pyobj;
19366 }
19367
19368
19369 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19370 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19371 return 1;
19372 }
19373
19374
19375 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19376 PyObject *pyobj = 0;
19377
19378 {
19379 #if wxUSE_UNICODE
19380 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19381 #else
19382 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19383 #endif
19384 }
19385 return pyobj;
19386 }
19387
19388
19389 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19390 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19391 return 1;
19392 }
19393
19394
19395 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19396 PyObject *pyobj = 0;
19397
19398 {
19399 #if wxUSE_UNICODE
19400 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19401 #else
19402 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19403 #endif
19404 }
19405 return pyobj;
19406 }
19407
19408
19409 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19410 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19411 return 1;
19412 }
19413
19414
19415 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19416 PyObject *pyobj = 0;
19417
19418 {
19419 #if wxUSE_UNICODE
19420 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19421 #else
19422 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19423 #endif
19424 }
19425 return pyobj;
19426 }
19427
19428
19429 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19430 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19431 return 1;
19432 }
19433
19434
19435 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19436 PyObject *pyobj = 0;
19437
19438 {
19439 #if wxUSE_UNICODE
19440 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19441 #else
19442 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19443 #endif
19444 }
19445 return pyobj;
19446 }
19447
19448
19449 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19450 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19451 return 1;
19452 }
19453
19454
19455 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19456 PyObject *pyobj = 0;
19457
19458 {
19459 #if wxUSE_UNICODE
19460 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19461 #else
19462 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19463 #endif
19464 }
19465 return pyobj;
19466 }
19467
19468
19469 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19470 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19471 return 1;
19472 }
19473
19474
19475 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19476 PyObject *pyobj = 0;
19477
19478 {
19479 #if wxUSE_UNICODE
19480 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19481 #else
19482 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19483 #endif
19484 }
19485 return pyobj;
19486 }
19487
19488
19489 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19490 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19491 return 1;
19492 }
19493
19494
19495 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19496 PyObject *pyobj = 0;
19497
19498 {
19499 #if wxUSE_UNICODE
19500 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19501 #else
19502 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19503 #endif
19504 }
19505 return pyobj;
19506 }
19507
19508
19509 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19510 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19511 return 1;
19512 }
19513
19514
19515 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19516 PyObject *pyobj = 0;
19517
19518 {
19519 #if wxUSE_UNICODE
19520 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19521 #else
19522 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19523 #endif
19524 }
19525 return pyobj;
19526 }
19527
19528
19529 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19530 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19531 return 1;
19532 }
19533
19534
19535 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19536 PyObject *pyobj = 0;
19537
19538 {
19539 #if wxUSE_UNICODE
19540 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19541 #else
19542 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19543 #endif
19544 }
19545 return pyobj;
19546 }
19547
19548
19549 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19550 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19551 return 1;
19552 }
19553
19554
19555 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19556 PyObject *pyobj = 0;
19557
19558 {
19559 #if wxUSE_UNICODE
19560 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19561 #else
19562 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19563 #endif
19564 }
19565 return pyobj;
19566 }
19567
19568
19569 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19570 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19571 return 1;
19572 }
19573
19574
19575 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19576 PyObject *pyobj = 0;
19577
19578 {
19579 #if wxUSE_UNICODE
19580 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19581 #else
19582 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19583 #endif
19584 }
19585 return pyobj;
19586 }
19587
19588
19589 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19590 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19591 return 1;
19592 }
19593
19594
19595 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19596 PyObject *pyobj = 0;
19597
19598 {
19599 #if wxUSE_UNICODE
19600 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19601 #else
19602 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19603 #endif
19604 }
19605 return pyobj;
19606 }
19607
19608
19609 SWIGINTERN int ART_PRINT_set(PyObject *) {
19610 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19611 return 1;
19612 }
19613
19614
19615 SWIGINTERN PyObject *ART_PRINT_get(void) {
19616 PyObject *pyobj = 0;
19617
19618 {
19619 #if wxUSE_UNICODE
19620 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19621 #else
19622 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19623 #endif
19624 }
19625 return pyobj;
19626 }
19627
19628
19629 SWIGINTERN int ART_HELP_set(PyObject *) {
19630 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19631 return 1;
19632 }
19633
19634
19635 SWIGINTERN PyObject *ART_HELP_get(void) {
19636 PyObject *pyobj = 0;
19637
19638 {
19639 #if wxUSE_UNICODE
19640 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19641 #else
19642 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19643 #endif
19644 }
19645 return pyobj;
19646 }
19647
19648
19649 SWIGINTERN int ART_TIP_set(PyObject *) {
19650 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19651 return 1;
19652 }
19653
19654
19655 SWIGINTERN PyObject *ART_TIP_get(void) {
19656 PyObject *pyobj = 0;
19657
19658 {
19659 #if wxUSE_UNICODE
19660 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19661 #else
19662 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19663 #endif
19664 }
19665 return pyobj;
19666 }
19667
19668
19669 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19670 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19671 return 1;
19672 }
19673
19674
19675 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19676 PyObject *pyobj = 0;
19677
19678 {
19679 #if wxUSE_UNICODE
19680 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19681 #else
19682 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19683 #endif
19684 }
19685 return pyobj;
19686 }
19687
19688
19689 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19690 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19691 return 1;
19692 }
19693
19694
19695 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19696 PyObject *pyobj = 0;
19697
19698 {
19699 #if wxUSE_UNICODE
19700 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19701 #else
19702 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19703 #endif
19704 }
19705 return pyobj;
19706 }
19707
19708
19709 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19710 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19711 return 1;
19712 }
19713
19714
19715 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19716 PyObject *pyobj = 0;
19717
19718 {
19719 #if wxUSE_UNICODE
19720 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19721 #else
19722 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19723 #endif
19724 }
19725 return pyobj;
19726 }
19727
19728
19729 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19730 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19731 return 1;
19732 }
19733
19734
19735 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19736 PyObject *pyobj = 0;
19737
19738 {
19739 #if wxUSE_UNICODE
19740 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19741 #else
19742 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19743 #endif
19744 }
19745 return pyobj;
19746 }
19747
19748
19749 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19750 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19751 return 1;
19752 }
19753
19754
19755 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19756 PyObject *pyobj = 0;
19757
19758 {
19759 #if wxUSE_UNICODE
19760 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19761 #else
19762 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19763 #endif
19764 }
19765 return pyobj;
19766 }
19767
19768
19769 SWIGINTERN int ART_CDROM_set(PyObject *) {
19770 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19771 return 1;
19772 }
19773
19774
19775 SWIGINTERN PyObject *ART_CDROM_get(void) {
19776 PyObject *pyobj = 0;
19777
19778 {
19779 #if wxUSE_UNICODE
19780 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19781 #else
19782 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19783 #endif
19784 }
19785 return pyobj;
19786 }
19787
19788
19789 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19790 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19791 return 1;
19792 }
19793
19794
19795 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
19796 PyObject *pyobj = 0;
19797
19798 {
19799 #if wxUSE_UNICODE
19800 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19801 #else
19802 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19803 #endif
19804 }
19805 return pyobj;
19806 }
19807
19808
19809 SWIGINTERN int ART_FOLDER_set(PyObject *) {
19810 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
19811 return 1;
19812 }
19813
19814
19815 SWIGINTERN PyObject *ART_FOLDER_get(void) {
19816 PyObject *pyobj = 0;
19817
19818 {
19819 #if wxUSE_UNICODE
19820 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19821 #else
19822 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19823 #endif
19824 }
19825 return pyobj;
19826 }
19827
19828
19829 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
19830 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
19831 return 1;
19832 }
19833
19834
19835 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
19836 PyObject *pyobj = 0;
19837
19838 {
19839 #if wxUSE_UNICODE
19840 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
19841 #else
19842 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
19843 #endif
19844 }
19845 return pyobj;
19846 }
19847
19848
19849 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
19850 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
19851 return 1;
19852 }
19853
19854
19855 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
19856 PyObject *pyobj = 0;
19857
19858 {
19859 #if wxUSE_UNICODE
19860 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
19861 #else
19862 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
19863 #endif
19864 }
19865 return pyobj;
19866 }
19867
19868
19869 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
19870 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
19871 return 1;
19872 }
19873
19874
19875 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
19876 PyObject *pyobj = 0;
19877
19878 {
19879 #if wxUSE_UNICODE
19880 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
19881 #else
19882 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
19883 #endif
19884 }
19885 return pyobj;
19886 }
19887
19888
19889 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
19890 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
19891 return 1;
19892 }
19893
19894
19895 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
19896 PyObject *pyobj = 0;
19897
19898 {
19899 #if wxUSE_UNICODE
19900 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
19901 #else
19902 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
19903 #endif
19904 }
19905 return pyobj;
19906 }
19907
19908
19909 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
19910 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
19911 return 1;
19912 }
19913
19914
19915 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
19916 PyObject *pyobj = 0;
19917
19918 {
19919 #if wxUSE_UNICODE
19920 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
19921 #else
19922 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
19923 #endif
19924 }
19925 return pyobj;
19926 }
19927
19928
19929 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
19930 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
19931 return 1;
19932 }
19933
19934
19935 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
19936 PyObject *pyobj = 0;
19937
19938 {
19939 #if wxUSE_UNICODE
19940 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
19941 #else
19942 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
19943 #endif
19944 }
19945 return pyobj;
19946 }
19947
19948
19949 SWIGINTERN int ART_ERROR_set(PyObject *) {
19950 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
19951 return 1;
19952 }
19953
19954
19955 SWIGINTERN PyObject *ART_ERROR_get(void) {
19956 PyObject *pyobj = 0;
19957
19958 {
19959 #if wxUSE_UNICODE
19960 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
19961 #else
19962 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
19963 #endif
19964 }
19965 return pyobj;
19966 }
19967
19968
19969 SWIGINTERN int ART_QUESTION_set(PyObject *) {
19970 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
19971 return 1;
19972 }
19973
19974
19975 SWIGINTERN PyObject *ART_QUESTION_get(void) {
19976 PyObject *pyobj = 0;
19977
19978 {
19979 #if wxUSE_UNICODE
19980 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19981 #else
19982 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19983 #endif
19984 }
19985 return pyobj;
19986 }
19987
19988
19989 SWIGINTERN int ART_WARNING_set(PyObject *) {
19990 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
19991 return 1;
19992 }
19993
19994
19995 SWIGINTERN PyObject *ART_WARNING_get(void) {
19996 PyObject *pyobj = 0;
19997
19998 {
19999 #if wxUSE_UNICODE
20000 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20001 #else
20002 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20003 #endif
20004 }
20005 return pyobj;
20006 }
20007
20008
20009 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20010 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20011 return 1;
20012 }
20013
20014
20015 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20016 PyObject *pyobj = 0;
20017
20018 {
20019 #if wxUSE_UNICODE
20020 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20021 #else
20022 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20023 #endif
20024 }
20025 return pyobj;
20026 }
20027
20028
20029 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20030 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20031 return 1;
20032 }
20033
20034
20035 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20036 PyObject *pyobj = 0;
20037
20038 {
20039 #if wxUSE_UNICODE
20040 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20041 #else
20042 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20043 #endif
20044 }
20045 return pyobj;
20046 }
20047
20048
20049 SWIGINTERN int ART_COPY_set(PyObject *) {
20050 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20051 return 1;
20052 }
20053
20054
20055 SWIGINTERN PyObject *ART_COPY_get(void) {
20056 PyObject *pyobj = 0;
20057
20058 {
20059 #if wxUSE_UNICODE
20060 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20061 #else
20062 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20063 #endif
20064 }
20065 return pyobj;
20066 }
20067
20068
20069 SWIGINTERN int ART_CUT_set(PyObject *) {
20070 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20071 return 1;
20072 }
20073
20074
20075 SWIGINTERN PyObject *ART_CUT_get(void) {
20076 PyObject *pyobj = 0;
20077
20078 {
20079 #if wxUSE_UNICODE
20080 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20081 #else
20082 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20083 #endif
20084 }
20085 return pyobj;
20086 }
20087
20088
20089 SWIGINTERN int ART_PASTE_set(PyObject *) {
20090 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20091 return 1;
20092 }
20093
20094
20095 SWIGINTERN PyObject *ART_PASTE_get(void) {
20096 PyObject *pyobj = 0;
20097
20098 {
20099 #if wxUSE_UNICODE
20100 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20101 #else
20102 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20103 #endif
20104 }
20105 return pyobj;
20106 }
20107
20108
20109 SWIGINTERN int ART_DELETE_set(PyObject *) {
20110 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20111 return 1;
20112 }
20113
20114
20115 SWIGINTERN PyObject *ART_DELETE_get(void) {
20116 PyObject *pyobj = 0;
20117
20118 {
20119 #if wxUSE_UNICODE
20120 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20121 #else
20122 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20123 #endif
20124 }
20125 return pyobj;
20126 }
20127
20128
20129 SWIGINTERN int ART_NEW_set(PyObject *) {
20130 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20131 return 1;
20132 }
20133
20134
20135 SWIGINTERN PyObject *ART_NEW_get(void) {
20136 PyObject *pyobj = 0;
20137
20138 {
20139 #if wxUSE_UNICODE
20140 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20141 #else
20142 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20143 #endif
20144 }
20145 return pyobj;
20146 }
20147
20148
20149 SWIGINTERN int ART_UNDO_set(PyObject *) {
20150 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20151 return 1;
20152 }
20153
20154
20155 SWIGINTERN PyObject *ART_UNDO_get(void) {
20156 PyObject *pyobj = 0;
20157
20158 {
20159 #if wxUSE_UNICODE
20160 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20161 #else
20162 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20163 #endif
20164 }
20165 return pyobj;
20166 }
20167
20168
20169 SWIGINTERN int ART_REDO_set(PyObject *) {
20170 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20171 return 1;
20172 }
20173
20174
20175 SWIGINTERN PyObject *ART_REDO_get(void) {
20176 PyObject *pyobj = 0;
20177
20178 {
20179 #if wxUSE_UNICODE
20180 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20181 #else
20182 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20183 #endif
20184 }
20185 return pyobj;
20186 }
20187
20188
20189 SWIGINTERN int ART_QUIT_set(PyObject *) {
20190 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20191 return 1;
20192 }
20193
20194
20195 SWIGINTERN PyObject *ART_QUIT_get(void) {
20196 PyObject *pyobj = 0;
20197
20198 {
20199 #if wxUSE_UNICODE
20200 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20201 #else
20202 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20203 #endif
20204 }
20205 return pyobj;
20206 }
20207
20208
20209 SWIGINTERN int ART_FIND_set(PyObject *) {
20210 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20211 return 1;
20212 }
20213
20214
20215 SWIGINTERN PyObject *ART_FIND_get(void) {
20216 PyObject *pyobj = 0;
20217
20218 {
20219 #if wxUSE_UNICODE
20220 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20221 #else
20222 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20223 #endif
20224 }
20225 return pyobj;
20226 }
20227
20228
20229 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20230 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20231 return 1;
20232 }
20233
20234
20235 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20236 PyObject *pyobj = 0;
20237
20238 {
20239 #if wxUSE_UNICODE
20240 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20241 #else
20242 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20243 #endif
20244 }
20245 return pyobj;
20246 }
20247
20248
20249 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20250 PyObject *resultobj = 0;
20251 wxPyArtProvider *result = 0 ;
20252
20253 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20254 {
20255 if (!wxPyCheckForApp()) SWIG_fail;
20256 PyThreadState* __tstate = wxPyBeginAllowThreads();
20257 result = (wxPyArtProvider *)new wxPyArtProvider();
20258 wxPyEndAllowThreads(__tstate);
20259 if (PyErr_Occurred()) SWIG_fail;
20260 }
20261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20262 return resultobj;
20263 fail:
20264 return NULL;
20265 }
20266
20267
20268 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20269 PyObject *resultobj = 0;
20270 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20271 void *argp1 = 0 ;
20272 int res1 = 0 ;
20273 PyObject *swig_obj[1] ;
20274
20275 if (!args) SWIG_fail;
20276 swig_obj[0] = args;
20277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20278 if (!SWIG_IsOK(res1)) {
20279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20280 }
20281 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20282 {
20283 PyThreadState* __tstate = wxPyBeginAllowThreads();
20284 delete arg1;
20285
20286 wxPyEndAllowThreads(__tstate);
20287 if (PyErr_Occurred()) SWIG_fail;
20288 }
20289 resultobj = SWIG_Py_Void();
20290 return resultobj;
20291 fail:
20292 return NULL;
20293 }
20294
20295
20296 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20297 PyObject *resultobj = 0;
20298 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20299 PyObject *arg2 = (PyObject *) 0 ;
20300 PyObject *arg3 = (PyObject *) 0 ;
20301 void *argp1 = 0 ;
20302 int res1 = 0 ;
20303 PyObject * obj0 = 0 ;
20304 PyObject * obj1 = 0 ;
20305 PyObject * obj2 = 0 ;
20306 char * kwnames[] = {
20307 (char *) "self",(char *) "self",(char *) "_class", NULL
20308 };
20309
20310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20312 if (!SWIG_IsOK(res1)) {
20313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20314 }
20315 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20316 arg2 = obj1;
20317 arg3 = obj2;
20318 {
20319 PyThreadState* __tstate = wxPyBeginAllowThreads();
20320 (arg1)->_setCallbackInfo(arg2,arg3);
20321 wxPyEndAllowThreads(__tstate);
20322 if (PyErr_Occurred()) SWIG_fail;
20323 }
20324 resultobj = SWIG_Py_Void();
20325 return resultobj;
20326 fail:
20327 return NULL;
20328 }
20329
20330
20331 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20332 PyObject *resultobj = 0;
20333 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20334 int res1 = 0 ;
20335 PyObject * obj0 = 0 ;
20336 char * kwnames[] = {
20337 (char *) "provider", NULL
20338 };
20339
20340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
20341 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20342 if (!SWIG_IsOK(res1)) {
20343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20344 }
20345 {
20346 PyThreadState* __tstate = wxPyBeginAllowThreads();
20347 wxPyArtProvider::PushProvider(arg1);
20348 wxPyEndAllowThreads(__tstate);
20349 if (PyErr_Occurred()) SWIG_fail;
20350 }
20351 resultobj = SWIG_Py_Void();
20352 return resultobj;
20353 fail:
20354 return NULL;
20355 }
20356
20357
20358 SWIGINTERN PyObject *_wrap_ArtProvider_InsertProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20359 PyObject *resultobj = 0;
20360 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20361 int res1 = 0 ;
20362 PyObject * obj0 = 0 ;
20363 char * kwnames[] = {
20364 (char *) "provider", NULL
20365 };
20366
20367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_InsertProvider",kwnames,&obj0)) SWIG_fail;
20368 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20369 if (!SWIG_IsOK(res1)) {
20370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_InsertProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20371 }
20372 {
20373 PyThreadState* __tstate = wxPyBeginAllowThreads();
20374 wxPyArtProvider::InsertProvider(arg1);
20375 wxPyEndAllowThreads(__tstate);
20376 if (PyErr_Occurred()) SWIG_fail;
20377 }
20378 resultobj = SWIG_Py_Void();
20379 return resultobj;
20380 fail:
20381 return NULL;
20382 }
20383
20384
20385 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20386 PyObject *resultobj = 0;
20387 bool result;
20388
20389 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
20390 {
20391 PyThreadState* __tstate = wxPyBeginAllowThreads();
20392 result = (bool)wxPyArtProvider::PopProvider();
20393 wxPyEndAllowThreads(__tstate);
20394 if (PyErr_Occurred()) SWIG_fail;
20395 }
20396 {
20397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20398 }
20399 return resultobj;
20400 fail:
20401 return NULL;
20402 }
20403
20404
20405 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20406 PyObject *resultobj = 0;
20407 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20408 bool result;
20409 void *argp1 = 0 ;
20410 int res1 = 0 ;
20411 PyObject * obj0 = 0 ;
20412 char * kwnames[] = {
20413 (char *) "provider", NULL
20414 };
20415
20416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
20417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20418 if (!SWIG_IsOK(res1)) {
20419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20420 }
20421 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20422 {
20423 PyThreadState* __tstate = wxPyBeginAllowThreads();
20424 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
20425 wxPyEndAllowThreads(__tstate);
20426 if (PyErr_Occurred()) SWIG_fail;
20427 }
20428 {
20429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20430 }
20431 return resultobj;
20432 fail:
20433 return NULL;
20434 }
20435
20436
20437 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20438 PyObject *resultobj = 0;
20439 wxString *arg1 = 0 ;
20440 wxString const &arg2_defvalue = wxPyART_OTHER ;
20441 wxString *arg2 = (wxString *) &arg2_defvalue ;
20442 wxSize const &arg3_defvalue = wxDefaultSize ;
20443 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20444 wxBitmap result;
20445 bool temp1 = false ;
20446 bool temp2 = false ;
20447 wxSize temp3 ;
20448 PyObject * obj0 = 0 ;
20449 PyObject * obj1 = 0 ;
20450 PyObject * obj2 = 0 ;
20451 char * kwnames[] = {
20452 (char *) "id",(char *) "client",(char *) "size", NULL
20453 };
20454
20455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20456 {
20457 arg1 = wxString_in_helper(obj0);
20458 if (arg1 == NULL) SWIG_fail;
20459 temp1 = true;
20460 }
20461 if (obj1) {
20462 {
20463 arg2 = wxString_in_helper(obj1);
20464 if (arg2 == NULL) SWIG_fail;
20465 temp2 = true;
20466 }
20467 }
20468 if (obj2) {
20469 {
20470 arg3 = &temp3;
20471 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20472 }
20473 }
20474 {
20475 if (!wxPyCheckForApp()) SWIG_fail;
20476 PyThreadState* __tstate = wxPyBeginAllowThreads();
20477 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20478 wxPyEndAllowThreads(__tstate);
20479 if (PyErr_Occurred()) SWIG_fail;
20480 }
20481 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20482 {
20483 if (temp1)
20484 delete arg1;
20485 }
20486 {
20487 if (temp2)
20488 delete arg2;
20489 }
20490 return resultobj;
20491 fail:
20492 {
20493 if (temp1)
20494 delete arg1;
20495 }
20496 {
20497 if (temp2)
20498 delete arg2;
20499 }
20500 return NULL;
20501 }
20502
20503
20504 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20505 PyObject *resultobj = 0;
20506 wxString *arg1 = 0 ;
20507 wxString const &arg2_defvalue = wxPyART_OTHER ;
20508 wxString *arg2 = (wxString *) &arg2_defvalue ;
20509 wxSize const &arg3_defvalue = wxDefaultSize ;
20510 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20511 wxIcon result;
20512 bool temp1 = false ;
20513 bool temp2 = false ;
20514 wxSize temp3 ;
20515 PyObject * obj0 = 0 ;
20516 PyObject * obj1 = 0 ;
20517 PyObject * obj2 = 0 ;
20518 char * kwnames[] = {
20519 (char *) "id",(char *) "client",(char *) "size", NULL
20520 };
20521
20522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20523 {
20524 arg1 = wxString_in_helper(obj0);
20525 if (arg1 == NULL) SWIG_fail;
20526 temp1 = true;
20527 }
20528 if (obj1) {
20529 {
20530 arg2 = wxString_in_helper(obj1);
20531 if (arg2 == NULL) SWIG_fail;
20532 temp2 = true;
20533 }
20534 }
20535 if (obj2) {
20536 {
20537 arg3 = &temp3;
20538 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20539 }
20540 }
20541 {
20542 if (!wxPyCheckForApp()) SWIG_fail;
20543 PyThreadState* __tstate = wxPyBeginAllowThreads();
20544 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20545 wxPyEndAllowThreads(__tstate);
20546 if (PyErr_Occurred()) SWIG_fail;
20547 }
20548 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20549 {
20550 if (temp1)
20551 delete arg1;
20552 }
20553 {
20554 if (temp2)
20555 delete arg2;
20556 }
20557 return resultobj;
20558 fail:
20559 {
20560 if (temp1)
20561 delete arg1;
20562 }
20563 {
20564 if (temp2)
20565 delete arg2;
20566 }
20567 return NULL;
20568 }
20569
20570
20571 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20572 PyObject *resultobj = 0;
20573 wxString *arg1 = 0 ;
20574 bool arg2 = (bool) false ;
20575 wxSize result;
20576 bool temp1 = false ;
20577 bool val2 ;
20578 int ecode2 = 0 ;
20579 PyObject * obj0 = 0 ;
20580 PyObject * obj1 = 0 ;
20581 char * kwnames[] = {
20582 (char *) "client",(char *) "platform_dependent", NULL
20583 };
20584
20585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20586 {
20587 arg1 = wxString_in_helper(obj0);
20588 if (arg1 == NULL) SWIG_fail;
20589 temp1 = true;
20590 }
20591 if (obj1) {
20592 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20593 if (!SWIG_IsOK(ecode2)) {
20594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20595 }
20596 arg2 = static_cast< bool >(val2);
20597 }
20598 {
20599 PyThreadState* __tstate = wxPyBeginAllowThreads();
20600 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20601 wxPyEndAllowThreads(__tstate);
20602 if (PyErr_Occurred()) SWIG_fail;
20603 }
20604 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20605 {
20606 if (temp1)
20607 delete arg1;
20608 }
20609 return resultobj;
20610 fail:
20611 {
20612 if (temp1)
20613 delete arg1;
20614 }
20615 return NULL;
20616 }
20617
20618
20619 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20620 PyObject *resultobj = 0;
20621 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20622 void *argp1 = 0 ;
20623 int res1 = 0 ;
20624 PyObject *swig_obj[1] ;
20625
20626 if (!args) SWIG_fail;
20627 swig_obj[0] = args;
20628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20629 if (!SWIG_IsOK(res1)) {
20630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20631 }
20632 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20633 {
20634 PyThreadState* __tstate = wxPyBeginAllowThreads();
20635 wxPyArtProvider_Destroy(arg1);
20636 wxPyEndAllowThreads(__tstate);
20637 if (PyErr_Occurred()) SWIG_fail;
20638 }
20639 resultobj = SWIG_Py_Void();
20640 return resultobj;
20641 fail:
20642 return NULL;
20643 }
20644
20645
20646 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20647 PyObject *obj;
20648 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20649 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20650 return SWIG_Py_Void();
20651 }
20652
20653 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20654 return SWIG_Python_InitShadowInstance(args);
20655 }
20656
20657 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20658 PyObject *resultobj = 0;
20659 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20660 void *argp1 = 0 ;
20661 int res1 = 0 ;
20662 PyObject *swig_obj[1] ;
20663
20664 if (!args) SWIG_fail;
20665 swig_obj[0] = args;
20666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20667 if (!SWIG_IsOK(res1)) {
20668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20669 }
20670 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20671 {
20672 PyThreadState* __tstate = wxPyBeginAllowThreads();
20673 delete arg1;
20674
20675 wxPyEndAllowThreads(__tstate);
20676 if (PyErr_Occurred()) SWIG_fail;
20677 }
20678 resultobj = SWIG_Py_Void();
20679 return resultobj;
20680 fail:
20681 return NULL;
20682 }
20683
20684
20685 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20686 PyObject *resultobj = 0;
20687 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20688 wxConfigBase *result = 0 ;
20689 int res1 = 0 ;
20690 PyObject * obj0 = 0 ;
20691 char * kwnames[] = {
20692 (char *) "config", NULL
20693 };
20694
20695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20696 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20697 if (!SWIG_IsOK(res1)) {
20698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20699 }
20700 {
20701 PyThreadState* __tstate = wxPyBeginAllowThreads();
20702 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20703 wxPyEndAllowThreads(__tstate);
20704 if (PyErr_Occurred()) SWIG_fail;
20705 }
20706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20707 return resultobj;
20708 fail:
20709 return NULL;
20710 }
20711
20712
20713 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20714 PyObject *resultobj = 0;
20715 bool arg1 = (bool) true ;
20716 wxConfigBase *result = 0 ;
20717 bool val1 ;
20718 int ecode1 = 0 ;
20719 PyObject * obj0 = 0 ;
20720 char * kwnames[] = {
20721 (char *) "createOnDemand", NULL
20722 };
20723
20724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20725 if (obj0) {
20726 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20727 if (!SWIG_IsOK(ecode1)) {
20728 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20729 }
20730 arg1 = static_cast< bool >(val1);
20731 }
20732 {
20733 PyThreadState* __tstate = wxPyBeginAllowThreads();
20734 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20735 wxPyEndAllowThreads(__tstate);
20736 if (PyErr_Occurred()) SWIG_fail;
20737 }
20738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20739 return resultobj;
20740 fail:
20741 return NULL;
20742 }
20743
20744
20745 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20746 PyObject *resultobj = 0;
20747 wxConfigBase *result = 0 ;
20748
20749 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20750 {
20751 PyThreadState* __tstate = wxPyBeginAllowThreads();
20752 result = (wxConfigBase *)wxConfigBase::Create();
20753 wxPyEndAllowThreads(__tstate);
20754 if (PyErr_Occurred()) SWIG_fail;
20755 }
20756 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20757 return resultobj;
20758 fail:
20759 return NULL;
20760 }
20761
20762
20763 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20764 PyObject *resultobj = 0;
20765
20766 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20767 {
20768 PyThreadState* __tstate = wxPyBeginAllowThreads();
20769 wxConfigBase::DontCreateOnDemand();
20770 wxPyEndAllowThreads(__tstate);
20771 if (PyErr_Occurred()) SWIG_fail;
20772 }
20773 resultobj = SWIG_Py_Void();
20774 return resultobj;
20775 fail:
20776 return NULL;
20777 }
20778
20779
20780 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20781 PyObject *resultobj = 0;
20782 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20783 wxString *arg2 = 0 ;
20784 void *argp1 = 0 ;
20785 int res1 = 0 ;
20786 bool temp2 = false ;
20787 PyObject * obj0 = 0 ;
20788 PyObject * obj1 = 0 ;
20789 char * kwnames[] = {
20790 (char *) "self",(char *) "path", NULL
20791 };
20792
20793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
20794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20795 if (!SWIG_IsOK(res1)) {
20796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20797 }
20798 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20799 {
20800 arg2 = wxString_in_helper(obj1);
20801 if (arg2 == NULL) SWIG_fail;
20802 temp2 = true;
20803 }
20804 {
20805 PyThreadState* __tstate = wxPyBeginAllowThreads();
20806 (arg1)->SetPath((wxString const &)*arg2);
20807 wxPyEndAllowThreads(__tstate);
20808 if (PyErr_Occurred()) SWIG_fail;
20809 }
20810 resultobj = SWIG_Py_Void();
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_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20826 PyObject *resultobj = 0;
20827 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20828 wxString *result = 0 ;
20829 void *argp1 = 0 ;
20830 int res1 = 0 ;
20831 PyObject *swig_obj[1] ;
20832
20833 if (!args) SWIG_fail;
20834 swig_obj[0] = args;
20835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20836 if (!SWIG_IsOK(res1)) {
20837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20838 }
20839 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20840 {
20841 PyThreadState* __tstate = wxPyBeginAllowThreads();
20842 {
20843 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
20844 result = (wxString *) &_result_ref;
20845 }
20846 wxPyEndAllowThreads(__tstate);
20847 if (PyErr_Occurred()) SWIG_fail;
20848 }
20849 {
20850 #if wxUSE_UNICODE
20851 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
20852 #else
20853 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
20854 #endif
20855 }
20856 return resultobj;
20857 fail:
20858 return NULL;
20859 }
20860
20861
20862 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20863 PyObject *resultobj = 0;
20864 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20865 PyObject *result = 0 ;
20866 void *argp1 = 0 ;
20867 int res1 = 0 ;
20868 PyObject *swig_obj[1] ;
20869
20870 if (!args) SWIG_fail;
20871 swig_obj[0] = args;
20872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20873 if (!SWIG_IsOK(res1)) {
20874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20875 }
20876 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20877 {
20878 PyThreadState* __tstate = wxPyBeginAllowThreads();
20879 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
20880 wxPyEndAllowThreads(__tstate);
20881 if (PyErr_Occurred()) SWIG_fail;
20882 }
20883 resultobj = result;
20884 return resultobj;
20885 fail:
20886 return NULL;
20887 }
20888
20889
20890 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20891 PyObject *resultobj = 0;
20892 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20893 long arg2 ;
20894 PyObject *result = 0 ;
20895 void *argp1 = 0 ;
20896 int res1 = 0 ;
20897 long val2 ;
20898 int ecode2 = 0 ;
20899 PyObject * obj0 = 0 ;
20900 PyObject * obj1 = 0 ;
20901 char * kwnames[] = {
20902 (char *) "self",(char *) "index", NULL
20903 };
20904
20905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20907 if (!SWIG_IsOK(res1)) {
20908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20909 }
20910 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20911 ecode2 = SWIG_AsVal_long(obj1, &val2);
20912 if (!SWIG_IsOK(ecode2)) {
20913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
20914 }
20915 arg2 = static_cast< long >(val2);
20916 {
20917 PyThreadState* __tstate = wxPyBeginAllowThreads();
20918 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
20919 wxPyEndAllowThreads(__tstate);
20920 if (PyErr_Occurred()) SWIG_fail;
20921 }
20922 resultobj = result;
20923 return resultobj;
20924 fail:
20925 return NULL;
20926 }
20927
20928
20929 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20930 PyObject *resultobj = 0;
20931 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20932 PyObject *result = 0 ;
20933 void *argp1 = 0 ;
20934 int res1 = 0 ;
20935 PyObject *swig_obj[1] ;
20936
20937 if (!args) SWIG_fail;
20938 swig_obj[0] = args;
20939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20940 if (!SWIG_IsOK(res1)) {
20941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20942 }
20943 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20944 {
20945 PyThreadState* __tstate = wxPyBeginAllowThreads();
20946 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
20947 wxPyEndAllowThreads(__tstate);
20948 if (PyErr_Occurred()) SWIG_fail;
20949 }
20950 resultobj = result;
20951 return resultobj;
20952 fail:
20953 return NULL;
20954 }
20955
20956
20957 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20958 PyObject *resultobj = 0;
20959 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20960 long arg2 ;
20961 PyObject *result = 0 ;
20962 void *argp1 = 0 ;
20963 int res1 = 0 ;
20964 long val2 ;
20965 int ecode2 = 0 ;
20966 PyObject * obj0 = 0 ;
20967 PyObject * obj1 = 0 ;
20968 char * kwnames[] = {
20969 (char *) "self",(char *) "index", NULL
20970 };
20971
20972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20974 if (!SWIG_IsOK(res1)) {
20975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20976 }
20977 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20978 ecode2 = SWIG_AsVal_long(obj1, &val2);
20979 if (!SWIG_IsOK(ecode2)) {
20980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
20981 }
20982 arg2 = static_cast< long >(val2);
20983 {
20984 PyThreadState* __tstate = wxPyBeginAllowThreads();
20985 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
20986 wxPyEndAllowThreads(__tstate);
20987 if (PyErr_Occurred()) SWIG_fail;
20988 }
20989 resultobj = result;
20990 return resultobj;
20991 fail:
20992 return NULL;
20993 }
20994
20995
20996 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20997 PyObject *resultobj = 0;
20998 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20999 bool arg2 = (bool) false ;
21000 size_t result;
21001 void *argp1 = 0 ;
21002 int res1 = 0 ;
21003 bool val2 ;
21004 int ecode2 = 0 ;
21005 PyObject * obj0 = 0 ;
21006 PyObject * obj1 = 0 ;
21007 char * kwnames[] = {
21008 (char *) "self",(char *) "recursive", NULL
21009 };
21010
21011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21013 if (!SWIG_IsOK(res1)) {
21014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21015 }
21016 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21017 if (obj1) {
21018 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21019 if (!SWIG_IsOK(ecode2)) {
21020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21021 }
21022 arg2 = static_cast< bool >(val2);
21023 }
21024 {
21025 PyThreadState* __tstate = wxPyBeginAllowThreads();
21026 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21027 wxPyEndAllowThreads(__tstate);
21028 if (PyErr_Occurred()) SWIG_fail;
21029 }
21030 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21031 return resultobj;
21032 fail:
21033 return NULL;
21034 }
21035
21036
21037 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21038 PyObject *resultobj = 0;
21039 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21040 bool arg2 = (bool) false ;
21041 size_t result;
21042 void *argp1 = 0 ;
21043 int res1 = 0 ;
21044 bool val2 ;
21045 int ecode2 = 0 ;
21046 PyObject * obj0 = 0 ;
21047 PyObject * obj1 = 0 ;
21048 char * kwnames[] = {
21049 (char *) "self",(char *) "recursive", NULL
21050 };
21051
21052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21054 if (!SWIG_IsOK(res1)) {
21055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21056 }
21057 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21058 if (obj1) {
21059 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21060 if (!SWIG_IsOK(ecode2)) {
21061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21062 }
21063 arg2 = static_cast< bool >(val2);
21064 }
21065 {
21066 PyThreadState* __tstate = wxPyBeginAllowThreads();
21067 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21068 wxPyEndAllowThreads(__tstate);
21069 if (PyErr_Occurred()) SWIG_fail;
21070 }
21071 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21072 return resultobj;
21073 fail:
21074 return NULL;
21075 }
21076
21077
21078 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21079 PyObject *resultobj = 0;
21080 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21081 wxString *arg2 = 0 ;
21082 bool result;
21083 void *argp1 = 0 ;
21084 int res1 = 0 ;
21085 bool temp2 = false ;
21086 PyObject * obj0 = 0 ;
21087 PyObject * obj1 = 0 ;
21088 char * kwnames[] = {
21089 (char *) "self",(char *) "name", NULL
21090 };
21091
21092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21094 if (!SWIG_IsOK(res1)) {
21095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21096 }
21097 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21098 {
21099 arg2 = wxString_in_helper(obj1);
21100 if (arg2 == NULL) SWIG_fail;
21101 temp2 = true;
21102 }
21103 {
21104 PyThreadState* __tstate = wxPyBeginAllowThreads();
21105 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21106 wxPyEndAllowThreads(__tstate);
21107 if (PyErr_Occurred()) SWIG_fail;
21108 }
21109 {
21110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21111 }
21112 {
21113 if (temp2)
21114 delete arg2;
21115 }
21116 return resultobj;
21117 fail:
21118 {
21119 if (temp2)
21120 delete arg2;
21121 }
21122 return NULL;
21123 }
21124
21125
21126 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21127 PyObject *resultobj = 0;
21128 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21129 wxString *arg2 = 0 ;
21130 bool result;
21131 void *argp1 = 0 ;
21132 int res1 = 0 ;
21133 bool temp2 = false ;
21134 PyObject * obj0 = 0 ;
21135 PyObject * obj1 = 0 ;
21136 char * kwnames[] = {
21137 (char *) "self",(char *) "name", NULL
21138 };
21139
21140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21142 if (!SWIG_IsOK(res1)) {
21143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21144 }
21145 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21146 {
21147 arg2 = wxString_in_helper(obj1);
21148 if (arg2 == NULL) SWIG_fail;
21149 temp2 = true;
21150 }
21151 {
21152 PyThreadState* __tstate = wxPyBeginAllowThreads();
21153 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21154 wxPyEndAllowThreads(__tstate);
21155 if (PyErr_Occurred()) SWIG_fail;
21156 }
21157 {
21158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21159 }
21160 {
21161 if (temp2)
21162 delete arg2;
21163 }
21164 return resultobj;
21165 fail:
21166 {
21167 if (temp2)
21168 delete arg2;
21169 }
21170 return NULL;
21171 }
21172
21173
21174 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21175 PyObject *resultobj = 0;
21176 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21177 wxString *arg2 = 0 ;
21178 bool result;
21179 void *argp1 = 0 ;
21180 int res1 = 0 ;
21181 bool temp2 = false ;
21182 PyObject * obj0 = 0 ;
21183 PyObject * obj1 = 0 ;
21184 char * kwnames[] = {
21185 (char *) "self",(char *) "name", NULL
21186 };
21187
21188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21190 if (!SWIG_IsOK(res1)) {
21191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21192 }
21193 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21194 {
21195 arg2 = wxString_in_helper(obj1);
21196 if (arg2 == NULL) SWIG_fail;
21197 temp2 = true;
21198 }
21199 {
21200 PyThreadState* __tstate = wxPyBeginAllowThreads();
21201 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21202 wxPyEndAllowThreads(__tstate);
21203 if (PyErr_Occurred()) SWIG_fail;
21204 }
21205 {
21206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21207 }
21208 {
21209 if (temp2)
21210 delete arg2;
21211 }
21212 return resultobj;
21213 fail:
21214 {
21215 if (temp2)
21216 delete arg2;
21217 }
21218 return NULL;
21219 }
21220
21221
21222 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21223 PyObject *resultobj = 0;
21224 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21225 wxString *arg2 = 0 ;
21226 wxConfigBase::EntryType result;
21227 void *argp1 = 0 ;
21228 int res1 = 0 ;
21229 bool temp2 = false ;
21230 PyObject * obj0 = 0 ;
21231 PyObject * obj1 = 0 ;
21232 char * kwnames[] = {
21233 (char *) "self",(char *) "name", NULL
21234 };
21235
21236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21238 if (!SWIG_IsOK(res1)) {
21239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21240 }
21241 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21242 {
21243 arg2 = wxString_in_helper(obj1);
21244 if (arg2 == NULL) SWIG_fail;
21245 temp2 = true;
21246 }
21247 {
21248 PyThreadState* __tstate = wxPyBeginAllowThreads();
21249 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21250 wxPyEndAllowThreads(__tstate);
21251 if (PyErr_Occurred()) SWIG_fail;
21252 }
21253 resultobj = SWIG_From_int(static_cast< int >(result));
21254 {
21255 if (temp2)
21256 delete arg2;
21257 }
21258 return resultobj;
21259 fail:
21260 {
21261 if (temp2)
21262 delete arg2;
21263 }
21264 return NULL;
21265 }
21266
21267
21268 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21269 PyObject *resultobj = 0;
21270 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21271 wxString *arg2 = 0 ;
21272 wxString const &arg3_defvalue = wxPyEmptyString ;
21273 wxString *arg3 = (wxString *) &arg3_defvalue ;
21274 wxString result;
21275 void *argp1 = 0 ;
21276 int res1 = 0 ;
21277 bool temp2 = false ;
21278 bool temp3 = false ;
21279 PyObject * obj0 = 0 ;
21280 PyObject * obj1 = 0 ;
21281 PyObject * obj2 = 0 ;
21282 char * kwnames[] = {
21283 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21284 };
21285
21286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21288 if (!SWIG_IsOK(res1)) {
21289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21290 }
21291 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21292 {
21293 arg2 = wxString_in_helper(obj1);
21294 if (arg2 == NULL) SWIG_fail;
21295 temp2 = true;
21296 }
21297 if (obj2) {
21298 {
21299 arg3 = wxString_in_helper(obj2);
21300 if (arg3 == NULL) SWIG_fail;
21301 temp3 = true;
21302 }
21303 }
21304 {
21305 PyThreadState* __tstate = wxPyBeginAllowThreads();
21306 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21307 wxPyEndAllowThreads(__tstate);
21308 if (PyErr_Occurred()) SWIG_fail;
21309 }
21310 {
21311 #if wxUSE_UNICODE
21312 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21313 #else
21314 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21315 #endif
21316 }
21317 {
21318 if (temp2)
21319 delete arg2;
21320 }
21321 {
21322 if (temp3)
21323 delete arg3;
21324 }
21325 return resultobj;
21326 fail:
21327 {
21328 if (temp2)
21329 delete arg2;
21330 }
21331 {
21332 if (temp3)
21333 delete arg3;
21334 }
21335 return NULL;
21336 }
21337
21338
21339 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21340 PyObject *resultobj = 0;
21341 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21342 wxString *arg2 = 0 ;
21343 long arg3 = (long) 0 ;
21344 long result;
21345 void *argp1 = 0 ;
21346 int res1 = 0 ;
21347 bool temp2 = false ;
21348 long val3 ;
21349 int ecode3 = 0 ;
21350 PyObject * obj0 = 0 ;
21351 PyObject * obj1 = 0 ;
21352 PyObject * obj2 = 0 ;
21353 char * kwnames[] = {
21354 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21355 };
21356
21357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21359 if (!SWIG_IsOK(res1)) {
21360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21361 }
21362 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21363 {
21364 arg2 = wxString_in_helper(obj1);
21365 if (arg2 == NULL) SWIG_fail;
21366 temp2 = true;
21367 }
21368 if (obj2) {
21369 ecode3 = SWIG_AsVal_long(obj2, &val3);
21370 if (!SWIG_IsOK(ecode3)) {
21371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21372 }
21373 arg3 = static_cast< long >(val3);
21374 }
21375 {
21376 PyThreadState* __tstate = wxPyBeginAllowThreads();
21377 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21378 wxPyEndAllowThreads(__tstate);
21379 if (PyErr_Occurred()) SWIG_fail;
21380 }
21381 resultobj = SWIG_From_long(static_cast< long >(result));
21382 {
21383 if (temp2)
21384 delete arg2;
21385 }
21386 return resultobj;
21387 fail:
21388 {
21389 if (temp2)
21390 delete arg2;
21391 }
21392 return NULL;
21393 }
21394
21395
21396 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21397 PyObject *resultobj = 0;
21398 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21399 wxString *arg2 = 0 ;
21400 double arg3 = (double) 0.0 ;
21401 double result;
21402 void *argp1 = 0 ;
21403 int res1 = 0 ;
21404 bool temp2 = false ;
21405 double val3 ;
21406 int ecode3 = 0 ;
21407 PyObject * obj0 = 0 ;
21408 PyObject * obj1 = 0 ;
21409 PyObject * obj2 = 0 ;
21410 char * kwnames[] = {
21411 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21412 };
21413
21414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21416 if (!SWIG_IsOK(res1)) {
21417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21418 }
21419 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21420 {
21421 arg2 = wxString_in_helper(obj1);
21422 if (arg2 == NULL) SWIG_fail;
21423 temp2 = true;
21424 }
21425 if (obj2) {
21426 ecode3 = SWIG_AsVal_double(obj2, &val3);
21427 if (!SWIG_IsOK(ecode3)) {
21428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21429 }
21430 arg3 = static_cast< double >(val3);
21431 }
21432 {
21433 PyThreadState* __tstate = wxPyBeginAllowThreads();
21434 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21435 wxPyEndAllowThreads(__tstate);
21436 if (PyErr_Occurred()) SWIG_fail;
21437 }
21438 resultobj = SWIG_From_double(static_cast< double >(result));
21439 {
21440 if (temp2)
21441 delete arg2;
21442 }
21443 return resultobj;
21444 fail:
21445 {
21446 if (temp2)
21447 delete arg2;
21448 }
21449 return NULL;
21450 }
21451
21452
21453 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21454 PyObject *resultobj = 0;
21455 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21456 wxString *arg2 = 0 ;
21457 bool arg3 = (bool) false ;
21458 bool result;
21459 void *argp1 = 0 ;
21460 int res1 = 0 ;
21461 bool temp2 = false ;
21462 bool val3 ;
21463 int ecode3 = 0 ;
21464 PyObject * obj0 = 0 ;
21465 PyObject * obj1 = 0 ;
21466 PyObject * obj2 = 0 ;
21467 char * kwnames[] = {
21468 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21469 };
21470
21471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21473 if (!SWIG_IsOK(res1)) {
21474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21475 }
21476 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21477 {
21478 arg2 = wxString_in_helper(obj1);
21479 if (arg2 == NULL) SWIG_fail;
21480 temp2 = true;
21481 }
21482 if (obj2) {
21483 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21484 if (!SWIG_IsOK(ecode3)) {
21485 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21486 }
21487 arg3 = static_cast< bool >(val3);
21488 }
21489 {
21490 PyThreadState* __tstate = wxPyBeginAllowThreads();
21491 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21492 wxPyEndAllowThreads(__tstate);
21493 if (PyErr_Occurred()) SWIG_fail;
21494 }
21495 {
21496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21497 }
21498 {
21499 if (temp2)
21500 delete arg2;
21501 }
21502 return resultobj;
21503 fail:
21504 {
21505 if (temp2)
21506 delete arg2;
21507 }
21508 return NULL;
21509 }
21510
21511
21512 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21513 PyObject *resultobj = 0;
21514 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21515 wxString *arg2 = 0 ;
21516 wxString *arg3 = 0 ;
21517 bool result;
21518 void *argp1 = 0 ;
21519 int res1 = 0 ;
21520 bool temp2 = false ;
21521 bool temp3 = false ;
21522 PyObject * obj0 = 0 ;
21523 PyObject * obj1 = 0 ;
21524 PyObject * obj2 = 0 ;
21525 char * kwnames[] = {
21526 (char *) "self",(char *) "key",(char *) "value", NULL
21527 };
21528
21529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21531 if (!SWIG_IsOK(res1)) {
21532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21533 }
21534 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21535 {
21536 arg2 = wxString_in_helper(obj1);
21537 if (arg2 == NULL) SWIG_fail;
21538 temp2 = true;
21539 }
21540 {
21541 arg3 = wxString_in_helper(obj2);
21542 if (arg3 == NULL) SWIG_fail;
21543 temp3 = true;
21544 }
21545 {
21546 PyThreadState* __tstate = wxPyBeginAllowThreads();
21547 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21548 wxPyEndAllowThreads(__tstate);
21549 if (PyErr_Occurred()) SWIG_fail;
21550 }
21551 {
21552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21553 }
21554 {
21555 if (temp2)
21556 delete arg2;
21557 }
21558 {
21559 if (temp3)
21560 delete arg3;
21561 }
21562 return resultobj;
21563 fail:
21564 {
21565 if (temp2)
21566 delete arg2;
21567 }
21568 {
21569 if (temp3)
21570 delete arg3;
21571 }
21572 return NULL;
21573 }
21574
21575
21576 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21577 PyObject *resultobj = 0;
21578 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21579 wxString *arg2 = 0 ;
21580 long arg3 ;
21581 bool result;
21582 void *argp1 = 0 ;
21583 int res1 = 0 ;
21584 bool temp2 = false ;
21585 long val3 ;
21586 int ecode3 = 0 ;
21587 PyObject * obj0 = 0 ;
21588 PyObject * obj1 = 0 ;
21589 PyObject * obj2 = 0 ;
21590 char * kwnames[] = {
21591 (char *) "self",(char *) "key",(char *) "value", NULL
21592 };
21593
21594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21596 if (!SWIG_IsOK(res1)) {
21597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21598 }
21599 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21600 {
21601 arg2 = wxString_in_helper(obj1);
21602 if (arg2 == NULL) SWIG_fail;
21603 temp2 = true;
21604 }
21605 ecode3 = SWIG_AsVal_long(obj2, &val3);
21606 if (!SWIG_IsOK(ecode3)) {
21607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21608 }
21609 arg3 = static_cast< long >(val3);
21610 {
21611 PyThreadState* __tstate = wxPyBeginAllowThreads();
21612 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21613 wxPyEndAllowThreads(__tstate);
21614 if (PyErr_Occurred()) SWIG_fail;
21615 }
21616 {
21617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21618 }
21619 {
21620 if (temp2)
21621 delete arg2;
21622 }
21623 return resultobj;
21624 fail:
21625 {
21626 if (temp2)
21627 delete arg2;
21628 }
21629 return NULL;
21630 }
21631
21632
21633 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21634 PyObject *resultobj = 0;
21635 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21636 wxString *arg2 = 0 ;
21637 double arg3 ;
21638 bool result;
21639 void *argp1 = 0 ;
21640 int res1 = 0 ;
21641 bool temp2 = false ;
21642 double val3 ;
21643 int ecode3 = 0 ;
21644 PyObject * obj0 = 0 ;
21645 PyObject * obj1 = 0 ;
21646 PyObject * obj2 = 0 ;
21647 char * kwnames[] = {
21648 (char *) "self",(char *) "key",(char *) "value", NULL
21649 };
21650
21651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21653 if (!SWIG_IsOK(res1)) {
21654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21655 }
21656 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21657 {
21658 arg2 = wxString_in_helper(obj1);
21659 if (arg2 == NULL) SWIG_fail;
21660 temp2 = true;
21661 }
21662 ecode3 = SWIG_AsVal_double(obj2, &val3);
21663 if (!SWIG_IsOK(ecode3)) {
21664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21665 }
21666 arg3 = static_cast< double >(val3);
21667 {
21668 PyThreadState* __tstate = wxPyBeginAllowThreads();
21669 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21670 wxPyEndAllowThreads(__tstate);
21671 if (PyErr_Occurred()) SWIG_fail;
21672 }
21673 {
21674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21675 }
21676 {
21677 if (temp2)
21678 delete arg2;
21679 }
21680 return resultobj;
21681 fail:
21682 {
21683 if (temp2)
21684 delete arg2;
21685 }
21686 return NULL;
21687 }
21688
21689
21690 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21691 PyObject *resultobj = 0;
21692 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21693 wxString *arg2 = 0 ;
21694 bool arg3 ;
21695 bool result;
21696 void *argp1 = 0 ;
21697 int res1 = 0 ;
21698 bool temp2 = false ;
21699 bool val3 ;
21700 int ecode3 = 0 ;
21701 PyObject * obj0 = 0 ;
21702 PyObject * obj1 = 0 ;
21703 PyObject * obj2 = 0 ;
21704 char * kwnames[] = {
21705 (char *) "self",(char *) "key",(char *) "value", NULL
21706 };
21707
21708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21710 if (!SWIG_IsOK(res1)) {
21711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21712 }
21713 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21714 {
21715 arg2 = wxString_in_helper(obj1);
21716 if (arg2 == NULL) SWIG_fail;
21717 temp2 = true;
21718 }
21719 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21720 if (!SWIG_IsOK(ecode3)) {
21721 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21722 }
21723 arg3 = static_cast< bool >(val3);
21724 {
21725 PyThreadState* __tstate = wxPyBeginAllowThreads();
21726 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21727 wxPyEndAllowThreads(__tstate);
21728 if (PyErr_Occurred()) SWIG_fail;
21729 }
21730 {
21731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21732 }
21733 {
21734 if (temp2)
21735 delete arg2;
21736 }
21737 return resultobj;
21738 fail:
21739 {
21740 if (temp2)
21741 delete arg2;
21742 }
21743 return NULL;
21744 }
21745
21746
21747 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21748 PyObject *resultobj = 0;
21749 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21750 bool arg2 = (bool) false ;
21751 bool result;
21752 void *argp1 = 0 ;
21753 int res1 = 0 ;
21754 bool val2 ;
21755 int ecode2 = 0 ;
21756 PyObject * obj0 = 0 ;
21757 PyObject * obj1 = 0 ;
21758 char * kwnames[] = {
21759 (char *) "self",(char *) "currentOnly", NULL
21760 };
21761
21762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21764 if (!SWIG_IsOK(res1)) {
21765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21766 }
21767 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21768 if (obj1) {
21769 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21770 if (!SWIG_IsOK(ecode2)) {
21771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21772 }
21773 arg2 = static_cast< bool >(val2);
21774 }
21775 {
21776 PyThreadState* __tstate = wxPyBeginAllowThreads();
21777 result = (bool)(arg1)->Flush(arg2);
21778 wxPyEndAllowThreads(__tstate);
21779 if (PyErr_Occurred()) SWIG_fail;
21780 }
21781 {
21782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21783 }
21784 return resultobj;
21785 fail:
21786 return NULL;
21787 }
21788
21789
21790 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21791 PyObject *resultobj = 0;
21792 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21793 wxString *arg2 = 0 ;
21794 wxString *arg3 = 0 ;
21795 bool result;
21796 void *argp1 = 0 ;
21797 int res1 = 0 ;
21798 bool temp2 = false ;
21799 bool temp3 = false ;
21800 PyObject * obj0 = 0 ;
21801 PyObject * obj1 = 0 ;
21802 PyObject * obj2 = 0 ;
21803 char * kwnames[] = {
21804 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21805 };
21806
21807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21809 if (!SWIG_IsOK(res1)) {
21810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21811 }
21812 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21813 {
21814 arg2 = wxString_in_helper(obj1);
21815 if (arg2 == NULL) SWIG_fail;
21816 temp2 = true;
21817 }
21818 {
21819 arg3 = wxString_in_helper(obj2);
21820 if (arg3 == NULL) SWIG_fail;
21821 temp3 = true;
21822 }
21823 {
21824 PyThreadState* __tstate = wxPyBeginAllowThreads();
21825 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
21826 wxPyEndAllowThreads(__tstate);
21827 if (PyErr_Occurred()) SWIG_fail;
21828 }
21829 {
21830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21831 }
21832 {
21833 if (temp2)
21834 delete arg2;
21835 }
21836 {
21837 if (temp3)
21838 delete arg3;
21839 }
21840 return resultobj;
21841 fail:
21842 {
21843 if (temp2)
21844 delete arg2;
21845 }
21846 {
21847 if (temp3)
21848 delete arg3;
21849 }
21850 return NULL;
21851 }
21852
21853
21854 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21855 PyObject *resultobj = 0;
21856 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21857 wxString *arg2 = 0 ;
21858 wxString *arg3 = 0 ;
21859 bool result;
21860 void *argp1 = 0 ;
21861 int res1 = 0 ;
21862 bool temp2 = false ;
21863 bool temp3 = false ;
21864 PyObject * obj0 = 0 ;
21865 PyObject * obj1 = 0 ;
21866 PyObject * obj2 = 0 ;
21867 char * kwnames[] = {
21868 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21869 };
21870
21871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21873 if (!SWIG_IsOK(res1)) {
21874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21875 }
21876 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21877 {
21878 arg2 = wxString_in_helper(obj1);
21879 if (arg2 == NULL) SWIG_fail;
21880 temp2 = true;
21881 }
21882 {
21883 arg3 = wxString_in_helper(obj2);
21884 if (arg3 == NULL) SWIG_fail;
21885 temp3 = true;
21886 }
21887 {
21888 PyThreadState* __tstate = wxPyBeginAllowThreads();
21889 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
21890 wxPyEndAllowThreads(__tstate);
21891 if (PyErr_Occurred()) SWIG_fail;
21892 }
21893 {
21894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21895 }
21896 {
21897 if (temp2)
21898 delete arg2;
21899 }
21900 {
21901 if (temp3)
21902 delete arg3;
21903 }
21904 return resultobj;
21905 fail:
21906 {
21907 if (temp2)
21908 delete arg2;
21909 }
21910 {
21911 if (temp3)
21912 delete arg3;
21913 }
21914 return NULL;
21915 }
21916
21917
21918 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21919 PyObject *resultobj = 0;
21920 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21921 wxString *arg2 = 0 ;
21922 bool arg3 = (bool) true ;
21923 bool result;
21924 void *argp1 = 0 ;
21925 int res1 = 0 ;
21926 bool temp2 = false ;
21927 bool val3 ;
21928 int ecode3 = 0 ;
21929 PyObject * obj0 = 0 ;
21930 PyObject * obj1 = 0 ;
21931 PyObject * obj2 = 0 ;
21932 char * kwnames[] = {
21933 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
21934 };
21935
21936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21938 if (!SWIG_IsOK(res1)) {
21939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21940 }
21941 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21942 {
21943 arg2 = wxString_in_helper(obj1);
21944 if (arg2 == NULL) SWIG_fail;
21945 temp2 = true;
21946 }
21947 if (obj2) {
21948 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21949 if (!SWIG_IsOK(ecode3)) {
21950 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
21951 }
21952 arg3 = static_cast< bool >(val3);
21953 }
21954 {
21955 PyThreadState* __tstate = wxPyBeginAllowThreads();
21956 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
21957 wxPyEndAllowThreads(__tstate);
21958 if (PyErr_Occurred()) SWIG_fail;
21959 }
21960 {
21961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21962 }
21963 {
21964 if (temp2)
21965 delete arg2;
21966 }
21967 return resultobj;
21968 fail:
21969 {
21970 if (temp2)
21971 delete arg2;
21972 }
21973 return NULL;
21974 }
21975
21976
21977 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21978 PyObject *resultobj = 0;
21979 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21980 wxString *arg2 = 0 ;
21981 bool result;
21982 void *argp1 = 0 ;
21983 int res1 = 0 ;
21984 bool temp2 = false ;
21985 PyObject * obj0 = 0 ;
21986 PyObject * obj1 = 0 ;
21987 char * kwnames[] = {
21988 (char *) "self",(char *) "key", NULL
21989 };
21990
21991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21993 if (!SWIG_IsOK(res1)) {
21994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21995 }
21996 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21997 {
21998 arg2 = wxString_in_helper(obj1);
21999 if (arg2 == NULL) SWIG_fail;
22000 temp2 = true;
22001 }
22002 {
22003 PyThreadState* __tstate = wxPyBeginAllowThreads();
22004 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22005 wxPyEndAllowThreads(__tstate);
22006 if (PyErr_Occurred()) SWIG_fail;
22007 }
22008 {
22009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22010 }
22011 {
22012 if (temp2)
22013 delete arg2;
22014 }
22015 return resultobj;
22016 fail:
22017 {
22018 if (temp2)
22019 delete arg2;
22020 }
22021 return NULL;
22022 }
22023
22024
22025 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22026 PyObject *resultobj = 0;
22027 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22028 bool result;
22029 void *argp1 = 0 ;
22030 int res1 = 0 ;
22031 PyObject *swig_obj[1] ;
22032
22033 if (!args) SWIG_fail;
22034 swig_obj[0] = args;
22035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22036 if (!SWIG_IsOK(res1)) {
22037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22038 }
22039 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22040 {
22041 PyThreadState* __tstate = wxPyBeginAllowThreads();
22042 result = (bool)(arg1)->DeleteAll();
22043 wxPyEndAllowThreads(__tstate);
22044 if (PyErr_Occurred()) SWIG_fail;
22045 }
22046 {
22047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22048 }
22049 return resultobj;
22050 fail:
22051 return NULL;
22052 }
22053
22054
22055 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22056 PyObject *resultobj = 0;
22057 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22058 bool arg2 = (bool) true ;
22059 void *argp1 = 0 ;
22060 int res1 = 0 ;
22061 bool val2 ;
22062 int ecode2 = 0 ;
22063 PyObject * obj0 = 0 ;
22064 PyObject * obj1 = 0 ;
22065 char * kwnames[] = {
22066 (char *) "self",(char *) "doIt", NULL
22067 };
22068
22069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22071 if (!SWIG_IsOK(res1)) {
22072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22073 }
22074 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22075 if (obj1) {
22076 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22077 if (!SWIG_IsOK(ecode2)) {
22078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22079 }
22080 arg2 = static_cast< bool >(val2);
22081 }
22082 {
22083 PyThreadState* __tstate = wxPyBeginAllowThreads();
22084 (arg1)->SetExpandEnvVars(arg2);
22085 wxPyEndAllowThreads(__tstate);
22086 if (PyErr_Occurred()) SWIG_fail;
22087 }
22088 resultobj = SWIG_Py_Void();
22089 return resultobj;
22090 fail:
22091 return NULL;
22092 }
22093
22094
22095 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22096 PyObject *resultobj = 0;
22097 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22098 bool result;
22099 void *argp1 = 0 ;
22100 int res1 = 0 ;
22101 PyObject *swig_obj[1] ;
22102
22103 if (!args) SWIG_fail;
22104 swig_obj[0] = args;
22105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22106 if (!SWIG_IsOK(res1)) {
22107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22108 }
22109 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22110 {
22111 PyThreadState* __tstate = wxPyBeginAllowThreads();
22112 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22113 wxPyEndAllowThreads(__tstate);
22114 if (PyErr_Occurred()) SWIG_fail;
22115 }
22116 {
22117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22118 }
22119 return resultobj;
22120 fail:
22121 return NULL;
22122 }
22123
22124
22125 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22126 PyObject *resultobj = 0;
22127 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22128 bool arg2 = (bool) true ;
22129 void *argp1 = 0 ;
22130 int res1 = 0 ;
22131 bool val2 ;
22132 int ecode2 = 0 ;
22133 PyObject * obj0 = 0 ;
22134 PyObject * obj1 = 0 ;
22135 char * kwnames[] = {
22136 (char *) "self",(char *) "doIt", NULL
22137 };
22138
22139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22141 if (!SWIG_IsOK(res1)) {
22142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22143 }
22144 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22145 if (obj1) {
22146 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22147 if (!SWIG_IsOK(ecode2)) {
22148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22149 }
22150 arg2 = static_cast< bool >(val2);
22151 }
22152 {
22153 PyThreadState* __tstate = wxPyBeginAllowThreads();
22154 (arg1)->SetRecordDefaults(arg2);
22155 wxPyEndAllowThreads(__tstate);
22156 if (PyErr_Occurred()) SWIG_fail;
22157 }
22158 resultobj = SWIG_Py_Void();
22159 return resultobj;
22160 fail:
22161 return NULL;
22162 }
22163
22164
22165 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22166 PyObject *resultobj = 0;
22167 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22168 bool result;
22169 void *argp1 = 0 ;
22170 int res1 = 0 ;
22171 PyObject *swig_obj[1] ;
22172
22173 if (!args) SWIG_fail;
22174 swig_obj[0] = args;
22175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22176 if (!SWIG_IsOK(res1)) {
22177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22178 }
22179 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22180 {
22181 PyThreadState* __tstate = wxPyBeginAllowThreads();
22182 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22183 wxPyEndAllowThreads(__tstate);
22184 if (PyErr_Occurred()) SWIG_fail;
22185 }
22186 {
22187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22188 }
22189 return resultobj;
22190 fail:
22191 return NULL;
22192 }
22193
22194
22195 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22196 PyObject *resultobj = 0;
22197 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22198 wxString *arg2 = 0 ;
22199 wxString result;
22200 void *argp1 = 0 ;
22201 int res1 = 0 ;
22202 bool temp2 = false ;
22203 PyObject * obj0 = 0 ;
22204 PyObject * obj1 = 0 ;
22205 char * kwnames[] = {
22206 (char *) "self",(char *) "str", NULL
22207 };
22208
22209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22211 if (!SWIG_IsOK(res1)) {
22212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22213 }
22214 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22215 {
22216 arg2 = wxString_in_helper(obj1);
22217 if (arg2 == NULL) SWIG_fail;
22218 temp2 = true;
22219 }
22220 {
22221 PyThreadState* __tstate = wxPyBeginAllowThreads();
22222 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22223 wxPyEndAllowThreads(__tstate);
22224 if (PyErr_Occurred()) SWIG_fail;
22225 }
22226 {
22227 #if wxUSE_UNICODE
22228 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22229 #else
22230 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22231 #endif
22232 }
22233 {
22234 if (temp2)
22235 delete arg2;
22236 }
22237 return resultobj;
22238 fail:
22239 {
22240 if (temp2)
22241 delete arg2;
22242 }
22243 return NULL;
22244 }
22245
22246
22247 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22248 PyObject *resultobj = 0;
22249 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22250 wxString result;
22251 void *argp1 = 0 ;
22252 int res1 = 0 ;
22253 PyObject *swig_obj[1] ;
22254
22255 if (!args) SWIG_fail;
22256 swig_obj[0] = args;
22257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22258 if (!SWIG_IsOK(res1)) {
22259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22260 }
22261 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22262 {
22263 PyThreadState* __tstate = wxPyBeginAllowThreads();
22264 result = ((wxConfigBase const *)arg1)->GetAppName();
22265 wxPyEndAllowThreads(__tstate);
22266 if (PyErr_Occurred()) SWIG_fail;
22267 }
22268 {
22269 #if wxUSE_UNICODE
22270 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22271 #else
22272 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22273 #endif
22274 }
22275 return resultobj;
22276 fail:
22277 return NULL;
22278 }
22279
22280
22281 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22282 PyObject *resultobj = 0;
22283 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22284 wxString result;
22285 void *argp1 = 0 ;
22286 int res1 = 0 ;
22287 PyObject *swig_obj[1] ;
22288
22289 if (!args) SWIG_fail;
22290 swig_obj[0] = args;
22291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22292 if (!SWIG_IsOK(res1)) {
22293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22294 }
22295 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22296 {
22297 PyThreadState* __tstate = wxPyBeginAllowThreads();
22298 result = ((wxConfigBase const *)arg1)->GetVendorName();
22299 wxPyEndAllowThreads(__tstate);
22300 if (PyErr_Occurred()) SWIG_fail;
22301 }
22302 {
22303 #if wxUSE_UNICODE
22304 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22305 #else
22306 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22307 #endif
22308 }
22309 return resultobj;
22310 fail:
22311 return NULL;
22312 }
22313
22314
22315 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22316 PyObject *resultobj = 0;
22317 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22318 wxString *arg2 = 0 ;
22319 void *argp1 = 0 ;
22320 int res1 = 0 ;
22321 bool temp2 = false ;
22322 PyObject * obj0 = 0 ;
22323 PyObject * obj1 = 0 ;
22324 char * kwnames[] = {
22325 (char *) "self",(char *) "appName", NULL
22326 };
22327
22328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22330 if (!SWIG_IsOK(res1)) {
22331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22332 }
22333 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22334 {
22335 arg2 = wxString_in_helper(obj1);
22336 if (arg2 == NULL) SWIG_fail;
22337 temp2 = true;
22338 }
22339 {
22340 PyThreadState* __tstate = wxPyBeginAllowThreads();
22341 (arg1)->SetAppName((wxString const &)*arg2);
22342 wxPyEndAllowThreads(__tstate);
22343 if (PyErr_Occurred()) SWIG_fail;
22344 }
22345 resultobj = SWIG_Py_Void();
22346 {
22347 if (temp2)
22348 delete arg2;
22349 }
22350 return resultobj;
22351 fail:
22352 {
22353 if (temp2)
22354 delete arg2;
22355 }
22356 return NULL;
22357 }
22358
22359
22360 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22361 PyObject *resultobj = 0;
22362 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22363 wxString *arg2 = 0 ;
22364 void *argp1 = 0 ;
22365 int res1 = 0 ;
22366 bool temp2 = false ;
22367 PyObject * obj0 = 0 ;
22368 PyObject * obj1 = 0 ;
22369 char * kwnames[] = {
22370 (char *) "self",(char *) "vendorName", NULL
22371 };
22372
22373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22375 if (!SWIG_IsOK(res1)) {
22376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22377 }
22378 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22379 {
22380 arg2 = wxString_in_helper(obj1);
22381 if (arg2 == NULL) SWIG_fail;
22382 temp2 = true;
22383 }
22384 {
22385 PyThreadState* __tstate = wxPyBeginAllowThreads();
22386 (arg1)->SetVendorName((wxString const &)*arg2);
22387 wxPyEndAllowThreads(__tstate);
22388 if (PyErr_Occurred()) SWIG_fail;
22389 }
22390 resultobj = SWIG_Py_Void();
22391 {
22392 if (temp2)
22393 delete arg2;
22394 }
22395 return resultobj;
22396 fail:
22397 {
22398 if (temp2)
22399 delete arg2;
22400 }
22401 return NULL;
22402 }
22403
22404
22405 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22406 PyObject *resultobj = 0;
22407 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22408 long arg2 ;
22409 void *argp1 = 0 ;
22410 int res1 = 0 ;
22411 long val2 ;
22412 int ecode2 = 0 ;
22413 PyObject * obj0 = 0 ;
22414 PyObject * obj1 = 0 ;
22415 char * kwnames[] = {
22416 (char *) "self",(char *) "style", NULL
22417 };
22418
22419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22421 if (!SWIG_IsOK(res1)) {
22422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22423 }
22424 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22425 ecode2 = SWIG_AsVal_long(obj1, &val2);
22426 if (!SWIG_IsOK(ecode2)) {
22427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22428 }
22429 arg2 = static_cast< long >(val2);
22430 {
22431 PyThreadState* __tstate = wxPyBeginAllowThreads();
22432 (arg1)->SetStyle(arg2);
22433 wxPyEndAllowThreads(__tstate);
22434 if (PyErr_Occurred()) SWIG_fail;
22435 }
22436 resultobj = SWIG_Py_Void();
22437 return resultobj;
22438 fail:
22439 return NULL;
22440 }
22441
22442
22443 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22444 PyObject *resultobj = 0;
22445 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22446 long result;
22447 void *argp1 = 0 ;
22448 int res1 = 0 ;
22449 PyObject *swig_obj[1] ;
22450
22451 if (!args) SWIG_fail;
22452 swig_obj[0] = args;
22453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22454 if (!SWIG_IsOK(res1)) {
22455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22456 }
22457 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22458 {
22459 PyThreadState* __tstate = wxPyBeginAllowThreads();
22460 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22461 wxPyEndAllowThreads(__tstate);
22462 if (PyErr_Occurred()) SWIG_fail;
22463 }
22464 resultobj = SWIG_From_long(static_cast< long >(result));
22465 return resultobj;
22466 fail:
22467 return NULL;
22468 }
22469
22470
22471 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22472 PyObject *obj;
22473 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22474 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22475 return SWIG_Py_Void();
22476 }
22477
22478 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22479 PyObject *resultobj = 0;
22480 wxString const &arg1_defvalue = wxPyEmptyString ;
22481 wxString *arg1 = (wxString *) &arg1_defvalue ;
22482 wxString const &arg2_defvalue = wxPyEmptyString ;
22483 wxString *arg2 = (wxString *) &arg2_defvalue ;
22484 wxString const &arg3_defvalue = wxPyEmptyString ;
22485 wxString *arg3 = (wxString *) &arg3_defvalue ;
22486 wxString const &arg4_defvalue = wxPyEmptyString ;
22487 wxString *arg4 = (wxString *) &arg4_defvalue ;
22488 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22489 wxConfig *result = 0 ;
22490 bool temp1 = false ;
22491 bool temp2 = false ;
22492 bool temp3 = false ;
22493 bool temp4 = false ;
22494 long val5 ;
22495 int ecode5 = 0 ;
22496 PyObject * obj0 = 0 ;
22497 PyObject * obj1 = 0 ;
22498 PyObject * obj2 = 0 ;
22499 PyObject * obj3 = 0 ;
22500 PyObject * obj4 = 0 ;
22501 char * kwnames[] = {
22502 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22503 };
22504
22505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22506 if (obj0) {
22507 {
22508 arg1 = wxString_in_helper(obj0);
22509 if (arg1 == NULL) SWIG_fail;
22510 temp1 = true;
22511 }
22512 }
22513 if (obj1) {
22514 {
22515 arg2 = wxString_in_helper(obj1);
22516 if (arg2 == NULL) SWIG_fail;
22517 temp2 = true;
22518 }
22519 }
22520 if (obj2) {
22521 {
22522 arg3 = wxString_in_helper(obj2);
22523 if (arg3 == NULL) SWIG_fail;
22524 temp3 = true;
22525 }
22526 }
22527 if (obj3) {
22528 {
22529 arg4 = wxString_in_helper(obj3);
22530 if (arg4 == NULL) SWIG_fail;
22531 temp4 = true;
22532 }
22533 }
22534 if (obj4) {
22535 ecode5 = SWIG_AsVal_long(obj4, &val5);
22536 if (!SWIG_IsOK(ecode5)) {
22537 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22538 }
22539 arg5 = static_cast< long >(val5);
22540 }
22541 {
22542 PyThreadState* __tstate = wxPyBeginAllowThreads();
22543 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22544 wxPyEndAllowThreads(__tstate);
22545 if (PyErr_Occurred()) SWIG_fail;
22546 }
22547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22548 {
22549 if (temp1)
22550 delete arg1;
22551 }
22552 {
22553 if (temp2)
22554 delete arg2;
22555 }
22556 {
22557 if (temp3)
22558 delete arg3;
22559 }
22560 {
22561 if (temp4)
22562 delete arg4;
22563 }
22564 return resultobj;
22565 fail:
22566 {
22567 if (temp1)
22568 delete arg1;
22569 }
22570 {
22571 if (temp2)
22572 delete arg2;
22573 }
22574 {
22575 if (temp3)
22576 delete arg3;
22577 }
22578 {
22579 if (temp4)
22580 delete arg4;
22581 }
22582 return NULL;
22583 }
22584
22585
22586 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22587 PyObject *resultobj = 0;
22588 wxConfig *arg1 = (wxConfig *) 0 ;
22589 void *argp1 = 0 ;
22590 int res1 = 0 ;
22591 PyObject *swig_obj[1] ;
22592
22593 if (!args) SWIG_fail;
22594 swig_obj[0] = args;
22595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22596 if (!SWIG_IsOK(res1)) {
22597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22598 }
22599 arg1 = reinterpret_cast< wxConfig * >(argp1);
22600 {
22601 PyThreadState* __tstate = wxPyBeginAllowThreads();
22602 delete arg1;
22603
22604 wxPyEndAllowThreads(__tstate);
22605 if (PyErr_Occurred()) SWIG_fail;
22606 }
22607 resultobj = SWIG_Py_Void();
22608 return resultobj;
22609 fail:
22610 return NULL;
22611 }
22612
22613
22614 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22615 PyObject *obj;
22616 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22617 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22618 return SWIG_Py_Void();
22619 }
22620
22621 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22622 return SWIG_Python_InitShadowInstance(args);
22623 }
22624
22625 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22626 PyObject *resultobj = 0;
22627 wxString const &arg1_defvalue = wxPyEmptyString ;
22628 wxString *arg1 = (wxString *) &arg1_defvalue ;
22629 wxString const &arg2_defvalue = wxPyEmptyString ;
22630 wxString *arg2 = (wxString *) &arg2_defvalue ;
22631 wxString const &arg3_defvalue = wxPyEmptyString ;
22632 wxString *arg3 = (wxString *) &arg3_defvalue ;
22633 wxString const &arg4_defvalue = wxPyEmptyString ;
22634 wxString *arg4 = (wxString *) &arg4_defvalue ;
22635 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22636 wxFileConfig *result = 0 ;
22637 bool temp1 = false ;
22638 bool temp2 = false ;
22639 bool temp3 = false ;
22640 bool temp4 = false ;
22641 long val5 ;
22642 int ecode5 = 0 ;
22643 PyObject * obj0 = 0 ;
22644 PyObject * obj1 = 0 ;
22645 PyObject * obj2 = 0 ;
22646 PyObject * obj3 = 0 ;
22647 PyObject * obj4 = 0 ;
22648 char * kwnames[] = {
22649 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22650 };
22651
22652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22653 if (obj0) {
22654 {
22655 arg1 = wxString_in_helper(obj0);
22656 if (arg1 == NULL) SWIG_fail;
22657 temp1 = true;
22658 }
22659 }
22660 if (obj1) {
22661 {
22662 arg2 = wxString_in_helper(obj1);
22663 if (arg2 == NULL) SWIG_fail;
22664 temp2 = true;
22665 }
22666 }
22667 if (obj2) {
22668 {
22669 arg3 = wxString_in_helper(obj2);
22670 if (arg3 == NULL) SWIG_fail;
22671 temp3 = true;
22672 }
22673 }
22674 if (obj3) {
22675 {
22676 arg4 = wxString_in_helper(obj3);
22677 if (arg4 == NULL) SWIG_fail;
22678 temp4 = true;
22679 }
22680 }
22681 if (obj4) {
22682 ecode5 = SWIG_AsVal_long(obj4, &val5);
22683 if (!SWIG_IsOK(ecode5)) {
22684 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22685 }
22686 arg5 = static_cast< long >(val5);
22687 }
22688 {
22689 PyThreadState* __tstate = wxPyBeginAllowThreads();
22690 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22691 wxPyEndAllowThreads(__tstate);
22692 if (PyErr_Occurred()) SWIG_fail;
22693 }
22694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22695 {
22696 if (temp1)
22697 delete arg1;
22698 }
22699 {
22700 if (temp2)
22701 delete arg2;
22702 }
22703 {
22704 if (temp3)
22705 delete arg3;
22706 }
22707 {
22708 if (temp4)
22709 delete arg4;
22710 }
22711 return resultobj;
22712 fail:
22713 {
22714 if (temp1)
22715 delete arg1;
22716 }
22717 {
22718 if (temp2)
22719 delete arg2;
22720 }
22721 {
22722 if (temp3)
22723 delete arg3;
22724 }
22725 {
22726 if (temp4)
22727 delete arg4;
22728 }
22729 return NULL;
22730 }
22731
22732
22733 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22734 PyObject *resultobj = 0;
22735 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22736 void *argp1 = 0 ;
22737 int res1 = 0 ;
22738 PyObject *swig_obj[1] ;
22739
22740 if (!args) SWIG_fail;
22741 swig_obj[0] = args;
22742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22743 if (!SWIG_IsOK(res1)) {
22744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22745 }
22746 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22747 {
22748 PyThreadState* __tstate = wxPyBeginAllowThreads();
22749 delete arg1;
22750
22751 wxPyEndAllowThreads(__tstate);
22752 if (PyErr_Occurred()) SWIG_fail;
22753 }
22754 resultobj = SWIG_Py_Void();
22755 return resultobj;
22756 fail:
22757 return NULL;
22758 }
22759
22760
22761 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22762 PyObject *obj;
22763 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22764 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22765 return SWIG_Py_Void();
22766 }
22767
22768 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22769 return SWIG_Python_InitShadowInstance(args);
22770 }
22771
22772 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22773 PyObject *resultobj = 0;
22774 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22775 wxString *arg2 = 0 ;
22776 wxConfigPathChanger *result = 0 ;
22777 void *argp1 = 0 ;
22778 int res1 = 0 ;
22779 bool temp2 = false ;
22780 PyObject * obj0 = 0 ;
22781 PyObject * obj1 = 0 ;
22782 char * kwnames[] = {
22783 (char *) "config",(char *) "entry", NULL
22784 };
22785
22786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22788 if (!SWIG_IsOK(res1)) {
22789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22790 }
22791 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22792 {
22793 arg2 = wxString_in_helper(obj1);
22794 if (arg2 == NULL) SWIG_fail;
22795 temp2 = true;
22796 }
22797 {
22798 PyThreadState* __tstate = wxPyBeginAllowThreads();
22799 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
22800 wxPyEndAllowThreads(__tstate);
22801 if (PyErr_Occurred()) SWIG_fail;
22802 }
22803 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
22804 {
22805 if (temp2)
22806 delete arg2;
22807 }
22808 return resultobj;
22809 fail:
22810 {
22811 if (temp2)
22812 delete arg2;
22813 }
22814 return NULL;
22815 }
22816
22817
22818 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22819 PyObject *resultobj = 0;
22820 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22821 void *argp1 = 0 ;
22822 int res1 = 0 ;
22823 PyObject *swig_obj[1] ;
22824
22825 if (!args) SWIG_fail;
22826 swig_obj[0] = args;
22827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
22828 if (!SWIG_IsOK(res1)) {
22829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
22830 }
22831 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22832 {
22833 PyThreadState* __tstate = wxPyBeginAllowThreads();
22834 delete arg1;
22835
22836 wxPyEndAllowThreads(__tstate);
22837 if (PyErr_Occurred()) SWIG_fail;
22838 }
22839 resultobj = SWIG_Py_Void();
22840 return resultobj;
22841 fail:
22842 return NULL;
22843 }
22844
22845
22846 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22847 PyObject *resultobj = 0;
22848 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22849 wxString *result = 0 ;
22850 void *argp1 = 0 ;
22851 int res1 = 0 ;
22852 PyObject *swig_obj[1] ;
22853
22854 if (!args) SWIG_fail;
22855 swig_obj[0] = args;
22856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
22857 if (!SWIG_IsOK(res1)) {
22858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
22859 }
22860 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22861 {
22862 PyThreadState* __tstate = wxPyBeginAllowThreads();
22863 {
22864 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
22865 result = (wxString *) &_result_ref;
22866 }
22867 wxPyEndAllowThreads(__tstate);
22868 if (PyErr_Occurred()) SWIG_fail;
22869 }
22870 {
22871 #if wxUSE_UNICODE
22872 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22873 #else
22874 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22875 #endif
22876 }
22877 return resultobj;
22878 fail:
22879 return NULL;
22880 }
22881
22882
22883 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22884 PyObject *obj;
22885 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22886 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
22887 return SWIG_Py_Void();
22888 }
22889
22890 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22891 return SWIG_Python_InitShadowInstance(args);
22892 }
22893
22894 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22895 PyObject *resultobj = 0;
22896 wxString *arg1 = 0 ;
22897 wxString result;
22898 bool temp1 = false ;
22899 PyObject * obj0 = 0 ;
22900 char * kwnames[] = {
22901 (char *) "sz", NULL
22902 };
22903
22904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
22905 {
22906 arg1 = wxString_in_helper(obj0);
22907 if (arg1 == NULL) SWIG_fail;
22908 temp1 = true;
22909 }
22910 {
22911 PyThreadState* __tstate = wxPyBeginAllowThreads();
22912 result = wxExpandEnvVars((wxString const &)*arg1);
22913 wxPyEndAllowThreads(__tstate);
22914 if (PyErr_Occurred()) SWIG_fail;
22915 }
22916 {
22917 #if wxUSE_UNICODE
22918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22919 #else
22920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22921 #endif
22922 }
22923 {
22924 if (temp1)
22925 delete arg1;
22926 }
22927 return resultobj;
22928 fail:
22929 {
22930 if (temp1)
22931 delete arg1;
22932 }
22933 return NULL;
22934 }
22935
22936
22937 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
22938 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
22939 return 1;
22940 }
22941
22942
22943 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
22944 PyObject *pyobj = 0;
22945
22946 {
22947 #if wxUSE_UNICODE
22948 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
22949 #else
22950 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
22951 #endif
22952 }
22953 return pyobj;
22954 }
22955
22956
22957 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
22958 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
22959 return 1;
22960 }
22961
22962
22963 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
22964 PyObject *pyobj = 0;
22965
22966 {
22967 #if wxUSE_UNICODE
22968 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
22969 #else
22970 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
22971 #endif
22972 }
22973 return pyobj;
22974 }
22975
22976
22977 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22978 PyObject *resultobj = 0;
22979 wxDateTime::Country arg1 ;
22980 int val1 ;
22981 int ecode1 = 0 ;
22982 PyObject * obj0 = 0 ;
22983 char * kwnames[] = {
22984 (char *) "country", NULL
22985 };
22986
22987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
22988 ecode1 = SWIG_AsVal_int(obj0, &val1);
22989 if (!SWIG_IsOK(ecode1)) {
22990 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
22991 }
22992 arg1 = static_cast< wxDateTime::Country >(val1);
22993 {
22994 PyThreadState* __tstate = wxPyBeginAllowThreads();
22995 wxDateTime::SetCountry(arg1);
22996 wxPyEndAllowThreads(__tstate);
22997 if (PyErr_Occurred()) SWIG_fail;
22998 }
22999 resultobj = SWIG_Py_Void();
23000 return resultobj;
23001 fail:
23002 return NULL;
23003 }
23004
23005
23006 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23007 PyObject *resultobj = 0;
23008 wxDateTime::Country result;
23009
23010 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23011 {
23012 PyThreadState* __tstate = wxPyBeginAllowThreads();
23013 result = (wxDateTime::Country)wxDateTime::GetCountry();
23014 wxPyEndAllowThreads(__tstate);
23015 if (PyErr_Occurred()) SWIG_fail;
23016 }
23017 resultobj = SWIG_From_int(static_cast< int >(result));
23018 return resultobj;
23019 fail:
23020 return NULL;
23021 }
23022
23023
23024 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23025 PyObject *resultobj = 0;
23026 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23027 bool result;
23028 int val1 ;
23029 int ecode1 = 0 ;
23030 PyObject * obj0 = 0 ;
23031 char * kwnames[] = {
23032 (char *) "country", NULL
23033 };
23034
23035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23036 if (obj0) {
23037 ecode1 = SWIG_AsVal_int(obj0, &val1);
23038 if (!SWIG_IsOK(ecode1)) {
23039 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23040 }
23041 arg1 = static_cast< wxDateTime::Country >(val1);
23042 }
23043 {
23044 PyThreadState* __tstate = wxPyBeginAllowThreads();
23045 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23046 wxPyEndAllowThreads(__tstate);
23047 if (PyErr_Occurred()) SWIG_fail;
23048 }
23049 {
23050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23051 }
23052 return resultobj;
23053 fail:
23054 return NULL;
23055 }
23056
23057
23058 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23059 PyObject *resultobj = 0;
23060 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23061 int result;
23062 int val1 ;
23063 int ecode1 = 0 ;
23064 PyObject * obj0 = 0 ;
23065 char * kwnames[] = {
23066 (char *) "cal", NULL
23067 };
23068
23069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23070 if (obj0) {
23071 ecode1 = SWIG_AsVal_int(obj0, &val1);
23072 if (!SWIG_IsOK(ecode1)) {
23073 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23074 }
23075 arg1 = static_cast< wxDateTime::Calendar >(val1);
23076 }
23077 {
23078 PyThreadState* __tstate = wxPyBeginAllowThreads();
23079 result = (int)wxDateTime::GetCurrentYear(arg1);
23080 wxPyEndAllowThreads(__tstate);
23081 if (PyErr_Occurred()) SWIG_fail;
23082 }
23083 resultobj = SWIG_From_int(static_cast< int >(result));
23084 return resultobj;
23085 fail:
23086 return NULL;
23087 }
23088
23089
23090 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23091 PyObject *resultobj = 0;
23092 int arg1 ;
23093 int result;
23094 int val1 ;
23095 int ecode1 = 0 ;
23096 PyObject * obj0 = 0 ;
23097 char * kwnames[] = {
23098 (char *) "year", NULL
23099 };
23100
23101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23102 ecode1 = SWIG_AsVal_int(obj0, &val1);
23103 if (!SWIG_IsOK(ecode1)) {
23104 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23105 }
23106 arg1 = static_cast< int >(val1);
23107 {
23108 PyThreadState* __tstate = wxPyBeginAllowThreads();
23109 result = (int)wxDateTime::ConvertYearToBC(arg1);
23110 wxPyEndAllowThreads(__tstate);
23111 if (PyErr_Occurred()) SWIG_fail;
23112 }
23113 resultobj = SWIG_From_int(static_cast< int >(result));
23114 return resultobj;
23115 fail:
23116 return NULL;
23117 }
23118
23119
23120 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23121 PyObject *resultobj = 0;
23122 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23123 wxDateTime::Month result;
23124 int val1 ;
23125 int ecode1 = 0 ;
23126 PyObject * obj0 = 0 ;
23127 char * kwnames[] = {
23128 (char *) "cal", NULL
23129 };
23130
23131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23132 if (obj0) {
23133 ecode1 = SWIG_AsVal_int(obj0, &val1);
23134 if (!SWIG_IsOK(ecode1)) {
23135 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23136 }
23137 arg1 = static_cast< wxDateTime::Calendar >(val1);
23138 }
23139 {
23140 PyThreadState* __tstate = wxPyBeginAllowThreads();
23141 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23142 wxPyEndAllowThreads(__tstate);
23143 if (PyErr_Occurred()) SWIG_fail;
23144 }
23145 resultobj = SWIG_From_int(static_cast< int >(result));
23146 return resultobj;
23147 fail:
23148 return NULL;
23149 }
23150
23151
23152 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23153 PyObject *resultobj = 0;
23154 int arg1 = (int) wxDateTime::Inv_Year ;
23155 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23156 bool result;
23157 int val1 ;
23158 int ecode1 = 0 ;
23159 int val2 ;
23160 int ecode2 = 0 ;
23161 PyObject * obj0 = 0 ;
23162 PyObject * obj1 = 0 ;
23163 char * kwnames[] = {
23164 (char *) "year",(char *) "cal", NULL
23165 };
23166
23167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23168 if (obj0) {
23169 ecode1 = SWIG_AsVal_int(obj0, &val1);
23170 if (!SWIG_IsOK(ecode1)) {
23171 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23172 }
23173 arg1 = static_cast< int >(val1);
23174 }
23175 if (obj1) {
23176 ecode2 = SWIG_AsVal_int(obj1, &val2);
23177 if (!SWIG_IsOK(ecode2)) {
23178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23179 }
23180 arg2 = static_cast< wxDateTime::Calendar >(val2);
23181 }
23182 {
23183 PyThreadState* __tstate = wxPyBeginAllowThreads();
23184 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23185 wxPyEndAllowThreads(__tstate);
23186 if (PyErr_Occurred()) SWIG_fail;
23187 }
23188 {
23189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23190 }
23191 return resultobj;
23192 fail:
23193 return NULL;
23194 }
23195
23196
23197 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23198 PyObject *resultobj = 0;
23199 int arg1 = (int) wxDateTime::Inv_Year ;
23200 int result;
23201 int val1 ;
23202 int ecode1 = 0 ;
23203 PyObject * obj0 = 0 ;
23204 char * kwnames[] = {
23205 (char *) "year", NULL
23206 };
23207
23208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23209 if (obj0) {
23210 ecode1 = SWIG_AsVal_int(obj0, &val1);
23211 if (!SWIG_IsOK(ecode1)) {
23212 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23213 }
23214 arg1 = static_cast< int >(val1);
23215 }
23216 {
23217 PyThreadState* __tstate = wxPyBeginAllowThreads();
23218 result = (int)wxDateTime::GetCentury(arg1);
23219 wxPyEndAllowThreads(__tstate);
23220 if (PyErr_Occurred()) SWIG_fail;
23221 }
23222 resultobj = SWIG_From_int(static_cast< int >(result));
23223 return resultobj;
23224 fail:
23225 return NULL;
23226 }
23227
23228
23229 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23230 PyObject *resultobj = 0;
23231 int arg1 ;
23232 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23233 int result;
23234 int val1 ;
23235 int ecode1 = 0 ;
23236 int val2 ;
23237 int ecode2 = 0 ;
23238 PyObject * obj0 = 0 ;
23239 PyObject * obj1 = 0 ;
23240 char * kwnames[] = {
23241 (char *) "year",(char *) "cal", NULL
23242 };
23243
23244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23245 ecode1 = SWIG_AsVal_int(obj0, &val1);
23246 if (!SWIG_IsOK(ecode1)) {
23247 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23248 }
23249 arg1 = static_cast< int >(val1);
23250 if (obj1) {
23251 ecode2 = SWIG_AsVal_int(obj1, &val2);
23252 if (!SWIG_IsOK(ecode2)) {
23253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23254 }
23255 arg2 = static_cast< wxDateTime::Calendar >(val2);
23256 }
23257 {
23258 PyThreadState* __tstate = wxPyBeginAllowThreads();
23259 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23260 wxPyEndAllowThreads(__tstate);
23261 if (PyErr_Occurred()) SWIG_fail;
23262 }
23263 resultobj = SWIG_From_int(static_cast< int >(result));
23264 return resultobj;
23265 fail:
23266 return NULL;
23267 }
23268
23269
23270 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23271 PyObject *resultobj = 0;
23272 wxDateTime::Month arg1 ;
23273 int arg2 = (int) wxDateTime::Inv_Year ;
23274 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23275 int result;
23276 int val1 ;
23277 int ecode1 = 0 ;
23278 int val2 ;
23279 int ecode2 = 0 ;
23280 int val3 ;
23281 int ecode3 = 0 ;
23282 PyObject * obj0 = 0 ;
23283 PyObject * obj1 = 0 ;
23284 PyObject * obj2 = 0 ;
23285 char * kwnames[] = {
23286 (char *) "month",(char *) "year",(char *) "cal", NULL
23287 };
23288
23289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23290 ecode1 = SWIG_AsVal_int(obj0, &val1);
23291 if (!SWIG_IsOK(ecode1)) {
23292 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23293 }
23294 arg1 = static_cast< wxDateTime::Month >(val1);
23295 if (obj1) {
23296 ecode2 = SWIG_AsVal_int(obj1, &val2);
23297 if (!SWIG_IsOK(ecode2)) {
23298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23299 }
23300 arg2 = static_cast< int >(val2);
23301 }
23302 if (obj2) {
23303 ecode3 = SWIG_AsVal_int(obj2, &val3);
23304 if (!SWIG_IsOK(ecode3)) {
23305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23306 }
23307 arg3 = static_cast< wxDateTime::Calendar >(val3);
23308 }
23309 {
23310 PyThreadState* __tstate = wxPyBeginAllowThreads();
23311 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23312 wxPyEndAllowThreads(__tstate);
23313 if (PyErr_Occurred()) SWIG_fail;
23314 }
23315 resultobj = SWIG_From_int(static_cast< int >(result));
23316 return resultobj;
23317 fail:
23318 return NULL;
23319 }
23320
23321
23322 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23323 PyObject *resultobj = 0;
23324 wxDateTime::Month arg1 ;
23325 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23326 wxString result;
23327 int val1 ;
23328 int ecode1 = 0 ;
23329 int val2 ;
23330 int ecode2 = 0 ;
23331 PyObject * obj0 = 0 ;
23332 PyObject * obj1 = 0 ;
23333 char * kwnames[] = {
23334 (char *) "month",(char *) "flags", NULL
23335 };
23336
23337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23338 ecode1 = SWIG_AsVal_int(obj0, &val1);
23339 if (!SWIG_IsOK(ecode1)) {
23340 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23341 }
23342 arg1 = static_cast< wxDateTime::Month >(val1);
23343 if (obj1) {
23344 ecode2 = SWIG_AsVal_int(obj1, &val2);
23345 if (!SWIG_IsOK(ecode2)) {
23346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23347 }
23348 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23349 }
23350 {
23351 PyThreadState* __tstate = wxPyBeginAllowThreads();
23352 result = wxDateTime::GetMonthName(arg1,arg2);
23353 wxPyEndAllowThreads(__tstate);
23354 if (PyErr_Occurred()) SWIG_fail;
23355 }
23356 {
23357 #if wxUSE_UNICODE
23358 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23359 #else
23360 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23361 #endif
23362 }
23363 return resultobj;
23364 fail:
23365 return NULL;
23366 }
23367
23368
23369 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23370 PyObject *resultobj = 0;
23371 wxDateTime::WeekDay arg1 ;
23372 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23373 wxString result;
23374 int val1 ;
23375 int ecode1 = 0 ;
23376 int val2 ;
23377 int ecode2 = 0 ;
23378 PyObject * obj0 = 0 ;
23379 PyObject * obj1 = 0 ;
23380 char * kwnames[] = {
23381 (char *) "weekday",(char *) "flags", NULL
23382 };
23383
23384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23385 ecode1 = SWIG_AsVal_int(obj0, &val1);
23386 if (!SWIG_IsOK(ecode1)) {
23387 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23388 }
23389 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23390 if (obj1) {
23391 ecode2 = SWIG_AsVal_int(obj1, &val2);
23392 if (!SWIG_IsOK(ecode2)) {
23393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23394 }
23395 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23396 }
23397 {
23398 PyThreadState* __tstate = wxPyBeginAllowThreads();
23399 result = wxDateTime::GetWeekDayName(arg1,arg2);
23400 wxPyEndAllowThreads(__tstate);
23401 if (PyErr_Occurred()) SWIG_fail;
23402 }
23403 {
23404 #if wxUSE_UNICODE
23405 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23406 #else
23407 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23408 #endif
23409 }
23410 return resultobj;
23411 fail:
23412 return NULL;
23413 }
23414
23415
23416 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23417 PyObject *resultobj = 0;
23418 PyObject *result = 0 ;
23419
23420 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23421 {
23422 PyThreadState* __tstate = wxPyBeginAllowThreads();
23423 result = (PyObject *)wxDateTime_GetAmPmStrings();
23424 wxPyEndAllowThreads(__tstate);
23425 if (PyErr_Occurred()) SWIG_fail;
23426 }
23427 resultobj = result;
23428 return resultobj;
23429 fail:
23430 return NULL;
23431 }
23432
23433
23434 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23435 PyObject *resultobj = 0;
23436 int arg1 = (int) wxDateTime::Inv_Year ;
23437 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23438 bool result;
23439 int val1 ;
23440 int ecode1 = 0 ;
23441 int val2 ;
23442 int ecode2 = 0 ;
23443 PyObject * obj0 = 0 ;
23444 PyObject * obj1 = 0 ;
23445 char * kwnames[] = {
23446 (char *) "year",(char *) "country", NULL
23447 };
23448
23449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23450 if (obj0) {
23451 ecode1 = SWIG_AsVal_int(obj0, &val1);
23452 if (!SWIG_IsOK(ecode1)) {
23453 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23454 }
23455 arg1 = static_cast< int >(val1);
23456 }
23457 if (obj1) {
23458 ecode2 = SWIG_AsVal_int(obj1, &val2);
23459 if (!SWIG_IsOK(ecode2)) {
23460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23461 }
23462 arg2 = static_cast< wxDateTime::Country >(val2);
23463 }
23464 {
23465 PyThreadState* __tstate = wxPyBeginAllowThreads();
23466 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23467 wxPyEndAllowThreads(__tstate);
23468 if (PyErr_Occurred()) SWIG_fail;
23469 }
23470 {
23471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23472 }
23473 return resultobj;
23474 fail:
23475 return NULL;
23476 }
23477
23478
23479 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23480 PyObject *resultobj = 0;
23481 int arg1 = (int) wxDateTime::Inv_Year ;
23482 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23483 wxDateTime result;
23484 int val1 ;
23485 int ecode1 = 0 ;
23486 int val2 ;
23487 int ecode2 = 0 ;
23488 PyObject * obj0 = 0 ;
23489 PyObject * obj1 = 0 ;
23490 char * kwnames[] = {
23491 (char *) "year",(char *) "country", NULL
23492 };
23493
23494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23495 if (obj0) {
23496 ecode1 = SWIG_AsVal_int(obj0, &val1);
23497 if (!SWIG_IsOK(ecode1)) {
23498 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23499 }
23500 arg1 = static_cast< int >(val1);
23501 }
23502 if (obj1) {
23503 ecode2 = SWIG_AsVal_int(obj1, &val2);
23504 if (!SWIG_IsOK(ecode2)) {
23505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23506 }
23507 arg2 = static_cast< wxDateTime::Country >(val2);
23508 }
23509 {
23510 PyThreadState* __tstate = wxPyBeginAllowThreads();
23511 result = wxDateTime::GetBeginDST(arg1,arg2);
23512 wxPyEndAllowThreads(__tstate);
23513 if (PyErr_Occurred()) SWIG_fail;
23514 }
23515 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23516 return resultobj;
23517 fail:
23518 return NULL;
23519 }
23520
23521
23522 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23523 PyObject *resultobj = 0;
23524 int arg1 = (int) wxDateTime::Inv_Year ;
23525 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23526 wxDateTime result;
23527 int val1 ;
23528 int ecode1 = 0 ;
23529 int val2 ;
23530 int ecode2 = 0 ;
23531 PyObject * obj0 = 0 ;
23532 PyObject * obj1 = 0 ;
23533 char * kwnames[] = {
23534 (char *) "year",(char *) "country", NULL
23535 };
23536
23537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23538 if (obj0) {
23539 ecode1 = SWIG_AsVal_int(obj0, &val1);
23540 if (!SWIG_IsOK(ecode1)) {
23541 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23542 }
23543 arg1 = static_cast< int >(val1);
23544 }
23545 if (obj1) {
23546 ecode2 = SWIG_AsVal_int(obj1, &val2);
23547 if (!SWIG_IsOK(ecode2)) {
23548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23549 }
23550 arg2 = static_cast< wxDateTime::Country >(val2);
23551 }
23552 {
23553 PyThreadState* __tstate = wxPyBeginAllowThreads();
23554 result = wxDateTime::GetEndDST(arg1,arg2);
23555 wxPyEndAllowThreads(__tstate);
23556 if (PyErr_Occurred()) SWIG_fail;
23557 }
23558 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23559 return resultobj;
23560 fail:
23561 return NULL;
23562 }
23563
23564
23565 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23566 PyObject *resultobj = 0;
23567 wxDateTime result;
23568
23569 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23570 {
23571 PyThreadState* __tstate = wxPyBeginAllowThreads();
23572 result = wxDateTime::Now();
23573 wxPyEndAllowThreads(__tstate);
23574 if (PyErr_Occurred()) SWIG_fail;
23575 }
23576 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23577 return resultobj;
23578 fail:
23579 return NULL;
23580 }
23581
23582
23583 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23584 PyObject *resultobj = 0;
23585 wxDateTime result;
23586
23587 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23588 {
23589 PyThreadState* __tstate = wxPyBeginAllowThreads();
23590 result = wxDateTime::UNow();
23591 wxPyEndAllowThreads(__tstate);
23592 if (PyErr_Occurred()) SWIG_fail;
23593 }
23594 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23595 return resultobj;
23596 fail:
23597 return NULL;
23598 }
23599
23600
23601 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23602 PyObject *resultobj = 0;
23603 wxDateTime result;
23604
23605 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23606 {
23607 PyThreadState* __tstate = wxPyBeginAllowThreads();
23608 result = wxDateTime::Today();
23609 wxPyEndAllowThreads(__tstate);
23610 if (PyErr_Occurred()) SWIG_fail;
23611 }
23612 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23613 return resultobj;
23614 fail:
23615 return NULL;
23616 }
23617
23618
23619 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23620 PyObject *resultobj = 0;
23621 wxDateTime *result = 0 ;
23622
23623 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23624 {
23625 PyThreadState* __tstate = wxPyBeginAllowThreads();
23626 result = (wxDateTime *)new wxDateTime();
23627 wxPyEndAllowThreads(__tstate);
23628 if (PyErr_Occurred()) SWIG_fail;
23629 }
23630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23631 return resultobj;
23632 fail:
23633 return NULL;
23634 }
23635
23636
23637 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23638 PyObject *resultobj = 0;
23639 time_t arg1 ;
23640 wxDateTime *result = 0 ;
23641 unsigned int val1 ;
23642 int ecode1 = 0 ;
23643 PyObject * obj0 = 0 ;
23644 char * kwnames[] = {
23645 (char *) "timet", NULL
23646 };
23647
23648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23649 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23650 if (!SWIG_IsOK(ecode1)) {
23651 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23652 }
23653 arg1 = static_cast< time_t >(val1);
23654 {
23655 PyThreadState* __tstate = wxPyBeginAllowThreads();
23656 result = (wxDateTime *)new wxDateTime(arg1);
23657 wxPyEndAllowThreads(__tstate);
23658 if (PyErr_Occurred()) SWIG_fail;
23659 }
23660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23661 return resultobj;
23662 fail:
23663 return NULL;
23664 }
23665
23666
23667 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23668 PyObject *resultobj = 0;
23669 double arg1 ;
23670 wxDateTime *result = 0 ;
23671 double val1 ;
23672 int ecode1 = 0 ;
23673 PyObject * obj0 = 0 ;
23674 char * kwnames[] = {
23675 (char *) "jdn", NULL
23676 };
23677
23678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23679 ecode1 = SWIG_AsVal_double(obj0, &val1);
23680 if (!SWIG_IsOK(ecode1)) {
23681 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23682 }
23683 arg1 = static_cast< double >(val1);
23684 {
23685 PyThreadState* __tstate = wxPyBeginAllowThreads();
23686 result = (wxDateTime *)new wxDateTime(arg1);
23687 wxPyEndAllowThreads(__tstate);
23688 if (PyErr_Occurred()) SWIG_fail;
23689 }
23690 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23691 return resultobj;
23692 fail:
23693 return NULL;
23694 }
23695
23696
23697 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23698 PyObject *resultobj = 0;
23699 int arg1 ;
23700 int arg2 = (int) 0 ;
23701 int arg3 = (int) 0 ;
23702 int arg4 = (int) 0 ;
23703 wxDateTime *result = 0 ;
23704 int val1 ;
23705 int ecode1 = 0 ;
23706 int val2 ;
23707 int ecode2 = 0 ;
23708 int val3 ;
23709 int ecode3 = 0 ;
23710 int val4 ;
23711 int ecode4 = 0 ;
23712 PyObject * obj0 = 0 ;
23713 PyObject * obj1 = 0 ;
23714 PyObject * obj2 = 0 ;
23715 PyObject * obj3 = 0 ;
23716 char * kwnames[] = {
23717 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23718 };
23719
23720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23721 ecode1 = SWIG_AsVal_int(obj0, &val1);
23722 if (!SWIG_IsOK(ecode1)) {
23723 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23724 }
23725 arg1 = static_cast< int >(val1);
23726 if (obj1) {
23727 ecode2 = SWIG_AsVal_int(obj1, &val2);
23728 if (!SWIG_IsOK(ecode2)) {
23729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23730 }
23731 arg2 = static_cast< int >(val2);
23732 }
23733 if (obj2) {
23734 ecode3 = SWIG_AsVal_int(obj2, &val3);
23735 if (!SWIG_IsOK(ecode3)) {
23736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23737 }
23738 arg3 = static_cast< int >(val3);
23739 }
23740 if (obj3) {
23741 ecode4 = SWIG_AsVal_int(obj3, &val4);
23742 if (!SWIG_IsOK(ecode4)) {
23743 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23744 }
23745 arg4 = static_cast< int >(val4);
23746 }
23747 {
23748 PyThreadState* __tstate = wxPyBeginAllowThreads();
23749 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23750 wxPyEndAllowThreads(__tstate);
23751 if (PyErr_Occurred()) SWIG_fail;
23752 }
23753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23754 return resultobj;
23755 fail:
23756 return NULL;
23757 }
23758
23759
23760 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23761 PyObject *resultobj = 0;
23762 int arg1 ;
23763 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23764 int arg3 = (int) wxDateTime::Inv_Year ;
23765 int arg4 = (int) 0 ;
23766 int arg5 = (int) 0 ;
23767 int arg6 = (int) 0 ;
23768 int arg7 = (int) 0 ;
23769 wxDateTime *result = 0 ;
23770 int val1 ;
23771 int ecode1 = 0 ;
23772 int val2 ;
23773 int ecode2 = 0 ;
23774 int val3 ;
23775 int ecode3 = 0 ;
23776 int val4 ;
23777 int ecode4 = 0 ;
23778 int val5 ;
23779 int ecode5 = 0 ;
23780 int val6 ;
23781 int ecode6 = 0 ;
23782 int val7 ;
23783 int ecode7 = 0 ;
23784 PyObject * obj0 = 0 ;
23785 PyObject * obj1 = 0 ;
23786 PyObject * obj2 = 0 ;
23787 PyObject * obj3 = 0 ;
23788 PyObject * obj4 = 0 ;
23789 PyObject * obj5 = 0 ;
23790 PyObject * obj6 = 0 ;
23791 char * kwnames[] = {
23792 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23793 };
23794
23795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23796 ecode1 = SWIG_AsVal_int(obj0, &val1);
23797 if (!SWIG_IsOK(ecode1)) {
23798 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
23799 }
23800 arg1 = static_cast< int >(val1);
23801 if (obj1) {
23802 ecode2 = SWIG_AsVal_int(obj1, &val2);
23803 if (!SWIG_IsOK(ecode2)) {
23804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23805 }
23806 arg2 = static_cast< wxDateTime::Month >(val2);
23807 }
23808 if (obj2) {
23809 ecode3 = SWIG_AsVal_int(obj2, &val3);
23810 if (!SWIG_IsOK(ecode3)) {
23811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
23812 }
23813 arg3 = static_cast< int >(val3);
23814 }
23815 if (obj3) {
23816 ecode4 = SWIG_AsVal_int(obj3, &val4);
23817 if (!SWIG_IsOK(ecode4)) {
23818 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
23819 }
23820 arg4 = static_cast< int >(val4);
23821 }
23822 if (obj4) {
23823 ecode5 = SWIG_AsVal_int(obj4, &val5);
23824 if (!SWIG_IsOK(ecode5)) {
23825 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
23826 }
23827 arg5 = static_cast< int >(val5);
23828 }
23829 if (obj5) {
23830 ecode6 = SWIG_AsVal_int(obj5, &val6);
23831 if (!SWIG_IsOK(ecode6)) {
23832 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
23833 }
23834 arg6 = static_cast< int >(val6);
23835 }
23836 if (obj6) {
23837 ecode7 = SWIG_AsVal_int(obj6, &val7);
23838 if (!SWIG_IsOK(ecode7)) {
23839 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
23840 }
23841 arg7 = static_cast< int >(val7);
23842 }
23843 {
23844 PyThreadState* __tstate = wxPyBeginAllowThreads();
23845 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
23846 wxPyEndAllowThreads(__tstate);
23847 if (PyErr_Occurred()) SWIG_fail;
23848 }
23849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23850 return resultobj;
23851 fail:
23852 return NULL;
23853 }
23854
23855
23856 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23857 PyObject *resultobj = 0;
23858 wxDateTime *arg1 = 0 ;
23859 wxDateTime *result = 0 ;
23860 void *argp1 = 0 ;
23861 int res1 = 0 ;
23862 PyObject * obj0 = 0 ;
23863 char * kwnames[] = {
23864 (char *) "date", NULL
23865 };
23866
23867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
23868 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
23869 if (!SWIG_IsOK(res1)) {
23870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
23871 }
23872 if (!argp1) {
23873 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
23874 }
23875 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23876 {
23877 PyThreadState* __tstate = wxPyBeginAllowThreads();
23878 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
23879 wxPyEndAllowThreads(__tstate);
23880 if (PyErr_Occurred()) SWIG_fail;
23881 }
23882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23883 return resultobj;
23884 fail:
23885 return NULL;
23886 }
23887
23888
23889 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23890 PyObject *resultobj = 0;
23891 wxDateTime *arg1 = (wxDateTime *) 0 ;
23892 void *argp1 = 0 ;
23893 int res1 = 0 ;
23894 PyObject *swig_obj[1] ;
23895
23896 if (!args) SWIG_fail;
23897 swig_obj[0] = args;
23898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
23899 if (!SWIG_IsOK(res1)) {
23900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23901 }
23902 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23903 {
23904 PyThreadState* __tstate = wxPyBeginAllowThreads();
23905 delete arg1;
23906
23907 wxPyEndAllowThreads(__tstate);
23908 if (PyErr_Occurred()) SWIG_fail;
23909 }
23910 resultobj = SWIG_Py_Void();
23911 return resultobj;
23912 fail:
23913 return NULL;
23914 }
23915
23916
23917 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23918 PyObject *resultobj = 0;
23919 wxDateTime *arg1 = (wxDateTime *) 0 ;
23920 wxDateTime *result = 0 ;
23921 void *argp1 = 0 ;
23922 int res1 = 0 ;
23923 PyObject *swig_obj[1] ;
23924
23925 if (!args) SWIG_fail;
23926 swig_obj[0] = args;
23927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23928 if (!SWIG_IsOK(res1)) {
23929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
23930 }
23931 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23932 {
23933 PyThreadState* __tstate = wxPyBeginAllowThreads();
23934 {
23935 wxDateTime &_result_ref = (arg1)->SetToCurrent();
23936 result = (wxDateTime *) &_result_ref;
23937 }
23938 wxPyEndAllowThreads(__tstate);
23939 if (PyErr_Occurred()) SWIG_fail;
23940 }
23941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23942 return resultobj;
23943 fail:
23944 return NULL;
23945 }
23946
23947
23948 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23949 PyObject *resultobj = 0;
23950 wxDateTime *arg1 = (wxDateTime *) 0 ;
23951 time_t arg2 ;
23952 wxDateTime *result = 0 ;
23953 void *argp1 = 0 ;
23954 int res1 = 0 ;
23955 unsigned int val2 ;
23956 int ecode2 = 0 ;
23957 PyObject * obj0 = 0 ;
23958 PyObject * obj1 = 0 ;
23959 char * kwnames[] = {
23960 (char *) "self",(char *) "timet", NULL
23961 };
23962
23963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
23964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23965 if (!SWIG_IsOK(res1)) {
23966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
23967 }
23968 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23969 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
23970 if (!SWIG_IsOK(ecode2)) {
23971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
23972 }
23973 arg2 = static_cast< time_t >(val2);
23974 {
23975 PyThreadState* __tstate = wxPyBeginAllowThreads();
23976 {
23977 wxDateTime &_result_ref = (arg1)->Set(arg2);
23978 result = (wxDateTime *) &_result_ref;
23979 }
23980 wxPyEndAllowThreads(__tstate);
23981 if (PyErr_Occurred()) SWIG_fail;
23982 }
23983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23984 return resultobj;
23985 fail:
23986 return NULL;
23987 }
23988
23989
23990 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23991 PyObject *resultobj = 0;
23992 wxDateTime *arg1 = (wxDateTime *) 0 ;
23993 double arg2 ;
23994 wxDateTime *result = 0 ;
23995 void *argp1 = 0 ;
23996 int res1 = 0 ;
23997 double val2 ;
23998 int ecode2 = 0 ;
23999 PyObject * obj0 = 0 ;
24000 PyObject * obj1 = 0 ;
24001 char * kwnames[] = {
24002 (char *) "self",(char *) "jdn", NULL
24003 };
24004
24005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24007 if (!SWIG_IsOK(res1)) {
24008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24009 }
24010 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24011 ecode2 = SWIG_AsVal_double(obj1, &val2);
24012 if (!SWIG_IsOK(ecode2)) {
24013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24014 }
24015 arg2 = static_cast< double >(val2);
24016 {
24017 PyThreadState* __tstate = wxPyBeginAllowThreads();
24018 {
24019 wxDateTime &_result_ref = (arg1)->Set(arg2);
24020 result = (wxDateTime *) &_result_ref;
24021 }
24022 wxPyEndAllowThreads(__tstate);
24023 if (PyErr_Occurred()) SWIG_fail;
24024 }
24025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24026 return resultobj;
24027 fail:
24028 return NULL;
24029 }
24030
24031
24032 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24033 PyObject *resultobj = 0;
24034 wxDateTime *arg1 = (wxDateTime *) 0 ;
24035 int arg2 ;
24036 int arg3 = (int) 0 ;
24037 int arg4 = (int) 0 ;
24038 int arg5 = (int) 0 ;
24039 wxDateTime *result = 0 ;
24040 void *argp1 = 0 ;
24041 int res1 = 0 ;
24042 int val2 ;
24043 int ecode2 = 0 ;
24044 int val3 ;
24045 int ecode3 = 0 ;
24046 int val4 ;
24047 int ecode4 = 0 ;
24048 int val5 ;
24049 int ecode5 = 0 ;
24050 PyObject * obj0 = 0 ;
24051 PyObject * obj1 = 0 ;
24052 PyObject * obj2 = 0 ;
24053 PyObject * obj3 = 0 ;
24054 PyObject * obj4 = 0 ;
24055 char * kwnames[] = {
24056 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24057 };
24058
24059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24061 if (!SWIG_IsOK(res1)) {
24062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24063 }
24064 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24065 ecode2 = SWIG_AsVal_int(obj1, &val2);
24066 if (!SWIG_IsOK(ecode2)) {
24067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24068 }
24069 arg2 = static_cast< int >(val2);
24070 if (obj2) {
24071 ecode3 = SWIG_AsVal_int(obj2, &val3);
24072 if (!SWIG_IsOK(ecode3)) {
24073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24074 }
24075 arg3 = static_cast< int >(val3);
24076 }
24077 if (obj3) {
24078 ecode4 = SWIG_AsVal_int(obj3, &val4);
24079 if (!SWIG_IsOK(ecode4)) {
24080 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24081 }
24082 arg4 = static_cast< int >(val4);
24083 }
24084 if (obj4) {
24085 ecode5 = SWIG_AsVal_int(obj4, &val5);
24086 if (!SWIG_IsOK(ecode5)) {
24087 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24088 }
24089 arg5 = static_cast< int >(val5);
24090 }
24091 {
24092 PyThreadState* __tstate = wxPyBeginAllowThreads();
24093 {
24094 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24095 result = (wxDateTime *) &_result_ref;
24096 }
24097 wxPyEndAllowThreads(__tstate);
24098 if (PyErr_Occurred()) SWIG_fail;
24099 }
24100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24101 return resultobj;
24102 fail:
24103 return NULL;
24104 }
24105
24106
24107 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24108 PyObject *resultobj = 0;
24109 wxDateTime *arg1 = (wxDateTime *) 0 ;
24110 int arg2 ;
24111 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24112 int arg4 = (int) wxDateTime::Inv_Year ;
24113 int arg5 = (int) 0 ;
24114 int arg6 = (int) 0 ;
24115 int arg7 = (int) 0 ;
24116 int arg8 = (int) 0 ;
24117 wxDateTime *result = 0 ;
24118 void *argp1 = 0 ;
24119 int res1 = 0 ;
24120 int val2 ;
24121 int ecode2 = 0 ;
24122 int val3 ;
24123 int ecode3 = 0 ;
24124 int val4 ;
24125 int ecode4 = 0 ;
24126 int val5 ;
24127 int ecode5 = 0 ;
24128 int val6 ;
24129 int ecode6 = 0 ;
24130 int val7 ;
24131 int ecode7 = 0 ;
24132 int val8 ;
24133 int ecode8 = 0 ;
24134 PyObject * obj0 = 0 ;
24135 PyObject * obj1 = 0 ;
24136 PyObject * obj2 = 0 ;
24137 PyObject * obj3 = 0 ;
24138 PyObject * obj4 = 0 ;
24139 PyObject * obj5 = 0 ;
24140 PyObject * obj6 = 0 ;
24141 PyObject * obj7 = 0 ;
24142 char * kwnames[] = {
24143 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24144 };
24145
24146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24148 if (!SWIG_IsOK(res1)) {
24149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24150 }
24151 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24152 ecode2 = SWIG_AsVal_int(obj1, &val2);
24153 if (!SWIG_IsOK(ecode2)) {
24154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24155 }
24156 arg2 = static_cast< int >(val2);
24157 if (obj2) {
24158 ecode3 = SWIG_AsVal_int(obj2, &val3);
24159 if (!SWIG_IsOK(ecode3)) {
24160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24161 }
24162 arg3 = static_cast< wxDateTime::Month >(val3);
24163 }
24164 if (obj3) {
24165 ecode4 = SWIG_AsVal_int(obj3, &val4);
24166 if (!SWIG_IsOK(ecode4)) {
24167 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24168 }
24169 arg4 = static_cast< int >(val4);
24170 }
24171 if (obj4) {
24172 ecode5 = SWIG_AsVal_int(obj4, &val5);
24173 if (!SWIG_IsOK(ecode5)) {
24174 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24175 }
24176 arg5 = static_cast< int >(val5);
24177 }
24178 if (obj5) {
24179 ecode6 = SWIG_AsVal_int(obj5, &val6);
24180 if (!SWIG_IsOK(ecode6)) {
24181 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24182 }
24183 arg6 = static_cast< int >(val6);
24184 }
24185 if (obj6) {
24186 ecode7 = SWIG_AsVal_int(obj6, &val7);
24187 if (!SWIG_IsOK(ecode7)) {
24188 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24189 }
24190 arg7 = static_cast< int >(val7);
24191 }
24192 if (obj7) {
24193 ecode8 = SWIG_AsVal_int(obj7, &val8);
24194 if (!SWIG_IsOK(ecode8)) {
24195 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24196 }
24197 arg8 = static_cast< int >(val8);
24198 }
24199 {
24200 PyThreadState* __tstate = wxPyBeginAllowThreads();
24201 {
24202 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24203 result = (wxDateTime *) &_result_ref;
24204 }
24205 wxPyEndAllowThreads(__tstate);
24206 if (PyErr_Occurred()) SWIG_fail;
24207 }
24208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24209 return resultobj;
24210 fail:
24211 return NULL;
24212 }
24213
24214
24215 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24216 PyObject *resultobj = 0;
24217 wxDateTime *arg1 = (wxDateTime *) 0 ;
24218 wxDateTime *result = 0 ;
24219 void *argp1 = 0 ;
24220 int res1 = 0 ;
24221 PyObject *swig_obj[1] ;
24222
24223 if (!args) SWIG_fail;
24224 swig_obj[0] = args;
24225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24226 if (!SWIG_IsOK(res1)) {
24227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24228 }
24229 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24230 {
24231 PyThreadState* __tstate = wxPyBeginAllowThreads();
24232 {
24233 wxDateTime &_result_ref = (arg1)->ResetTime();
24234 result = (wxDateTime *) &_result_ref;
24235 }
24236 wxPyEndAllowThreads(__tstate);
24237 if (PyErr_Occurred()) SWIG_fail;
24238 }
24239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24240 return resultobj;
24241 fail:
24242 return NULL;
24243 }
24244
24245
24246 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24247 PyObject *resultobj = 0;
24248 wxDateTime *arg1 = (wxDateTime *) 0 ;
24249 int arg2 ;
24250 wxDateTime *result = 0 ;
24251 void *argp1 = 0 ;
24252 int res1 = 0 ;
24253 int val2 ;
24254 int ecode2 = 0 ;
24255 PyObject * obj0 = 0 ;
24256 PyObject * obj1 = 0 ;
24257 char * kwnames[] = {
24258 (char *) "self",(char *) "year", NULL
24259 };
24260
24261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24263 if (!SWIG_IsOK(res1)) {
24264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24265 }
24266 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24267 ecode2 = SWIG_AsVal_int(obj1, &val2);
24268 if (!SWIG_IsOK(ecode2)) {
24269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24270 }
24271 arg2 = static_cast< int >(val2);
24272 {
24273 PyThreadState* __tstate = wxPyBeginAllowThreads();
24274 {
24275 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24276 result = (wxDateTime *) &_result_ref;
24277 }
24278 wxPyEndAllowThreads(__tstate);
24279 if (PyErr_Occurred()) SWIG_fail;
24280 }
24281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24282 return resultobj;
24283 fail:
24284 return NULL;
24285 }
24286
24287
24288 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24289 PyObject *resultobj = 0;
24290 wxDateTime *arg1 = (wxDateTime *) 0 ;
24291 wxDateTime::Month arg2 ;
24292 wxDateTime *result = 0 ;
24293 void *argp1 = 0 ;
24294 int res1 = 0 ;
24295 int val2 ;
24296 int ecode2 = 0 ;
24297 PyObject * obj0 = 0 ;
24298 PyObject * obj1 = 0 ;
24299 char * kwnames[] = {
24300 (char *) "self",(char *) "month", NULL
24301 };
24302
24303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24305 if (!SWIG_IsOK(res1)) {
24306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24307 }
24308 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24309 ecode2 = SWIG_AsVal_int(obj1, &val2);
24310 if (!SWIG_IsOK(ecode2)) {
24311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24312 }
24313 arg2 = static_cast< wxDateTime::Month >(val2);
24314 {
24315 PyThreadState* __tstate = wxPyBeginAllowThreads();
24316 {
24317 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24318 result = (wxDateTime *) &_result_ref;
24319 }
24320 wxPyEndAllowThreads(__tstate);
24321 if (PyErr_Occurred()) SWIG_fail;
24322 }
24323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24324 return resultobj;
24325 fail:
24326 return NULL;
24327 }
24328
24329
24330 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24331 PyObject *resultobj = 0;
24332 wxDateTime *arg1 = (wxDateTime *) 0 ;
24333 int arg2 ;
24334 wxDateTime *result = 0 ;
24335 void *argp1 = 0 ;
24336 int res1 = 0 ;
24337 int val2 ;
24338 int ecode2 = 0 ;
24339 PyObject * obj0 = 0 ;
24340 PyObject * obj1 = 0 ;
24341 char * kwnames[] = {
24342 (char *) "self",(char *) "day", NULL
24343 };
24344
24345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24347 if (!SWIG_IsOK(res1)) {
24348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24349 }
24350 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24351 ecode2 = SWIG_AsVal_int(obj1, &val2);
24352 if (!SWIG_IsOK(ecode2)) {
24353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24354 }
24355 arg2 = static_cast< int >(val2);
24356 {
24357 PyThreadState* __tstate = wxPyBeginAllowThreads();
24358 {
24359 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24360 result = (wxDateTime *) &_result_ref;
24361 }
24362 wxPyEndAllowThreads(__tstate);
24363 if (PyErr_Occurred()) SWIG_fail;
24364 }
24365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24366 return resultobj;
24367 fail:
24368 return NULL;
24369 }
24370
24371
24372 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24373 PyObject *resultobj = 0;
24374 wxDateTime *arg1 = (wxDateTime *) 0 ;
24375 int arg2 ;
24376 wxDateTime *result = 0 ;
24377 void *argp1 = 0 ;
24378 int res1 = 0 ;
24379 int val2 ;
24380 int ecode2 = 0 ;
24381 PyObject * obj0 = 0 ;
24382 PyObject * obj1 = 0 ;
24383 char * kwnames[] = {
24384 (char *) "self",(char *) "hour", NULL
24385 };
24386
24387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24389 if (!SWIG_IsOK(res1)) {
24390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24391 }
24392 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24393 ecode2 = SWIG_AsVal_int(obj1, &val2);
24394 if (!SWIG_IsOK(ecode2)) {
24395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24396 }
24397 arg2 = static_cast< int >(val2);
24398 {
24399 PyThreadState* __tstate = wxPyBeginAllowThreads();
24400 {
24401 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24402 result = (wxDateTime *) &_result_ref;
24403 }
24404 wxPyEndAllowThreads(__tstate);
24405 if (PyErr_Occurred()) SWIG_fail;
24406 }
24407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24408 return resultobj;
24409 fail:
24410 return NULL;
24411 }
24412
24413
24414 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24415 PyObject *resultobj = 0;
24416 wxDateTime *arg1 = (wxDateTime *) 0 ;
24417 int arg2 ;
24418 wxDateTime *result = 0 ;
24419 void *argp1 = 0 ;
24420 int res1 = 0 ;
24421 int val2 ;
24422 int ecode2 = 0 ;
24423 PyObject * obj0 = 0 ;
24424 PyObject * obj1 = 0 ;
24425 char * kwnames[] = {
24426 (char *) "self",(char *) "minute", NULL
24427 };
24428
24429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24431 if (!SWIG_IsOK(res1)) {
24432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24433 }
24434 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24435 ecode2 = SWIG_AsVal_int(obj1, &val2);
24436 if (!SWIG_IsOK(ecode2)) {
24437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24438 }
24439 arg2 = static_cast< int >(val2);
24440 {
24441 PyThreadState* __tstate = wxPyBeginAllowThreads();
24442 {
24443 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24444 result = (wxDateTime *) &_result_ref;
24445 }
24446 wxPyEndAllowThreads(__tstate);
24447 if (PyErr_Occurred()) SWIG_fail;
24448 }
24449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24450 return resultobj;
24451 fail:
24452 return NULL;
24453 }
24454
24455
24456 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24457 PyObject *resultobj = 0;
24458 wxDateTime *arg1 = (wxDateTime *) 0 ;
24459 int arg2 ;
24460 wxDateTime *result = 0 ;
24461 void *argp1 = 0 ;
24462 int res1 = 0 ;
24463 int val2 ;
24464 int ecode2 = 0 ;
24465 PyObject * obj0 = 0 ;
24466 PyObject * obj1 = 0 ;
24467 char * kwnames[] = {
24468 (char *) "self",(char *) "second", NULL
24469 };
24470
24471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24473 if (!SWIG_IsOK(res1)) {
24474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24475 }
24476 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24477 ecode2 = SWIG_AsVal_int(obj1, &val2);
24478 if (!SWIG_IsOK(ecode2)) {
24479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24480 }
24481 arg2 = static_cast< int >(val2);
24482 {
24483 PyThreadState* __tstate = wxPyBeginAllowThreads();
24484 {
24485 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24486 result = (wxDateTime *) &_result_ref;
24487 }
24488 wxPyEndAllowThreads(__tstate);
24489 if (PyErr_Occurred()) SWIG_fail;
24490 }
24491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24492 return resultobj;
24493 fail:
24494 return NULL;
24495 }
24496
24497
24498 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24499 PyObject *resultobj = 0;
24500 wxDateTime *arg1 = (wxDateTime *) 0 ;
24501 int arg2 ;
24502 wxDateTime *result = 0 ;
24503 void *argp1 = 0 ;
24504 int res1 = 0 ;
24505 int val2 ;
24506 int ecode2 = 0 ;
24507 PyObject * obj0 = 0 ;
24508 PyObject * obj1 = 0 ;
24509 char * kwnames[] = {
24510 (char *) "self",(char *) "millisecond", NULL
24511 };
24512
24513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24515 if (!SWIG_IsOK(res1)) {
24516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24517 }
24518 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24519 ecode2 = SWIG_AsVal_int(obj1, &val2);
24520 if (!SWIG_IsOK(ecode2)) {
24521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24522 }
24523 arg2 = static_cast< int >(val2);
24524 {
24525 PyThreadState* __tstate = wxPyBeginAllowThreads();
24526 {
24527 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24528 result = (wxDateTime *) &_result_ref;
24529 }
24530 wxPyEndAllowThreads(__tstate);
24531 if (PyErr_Occurred()) SWIG_fail;
24532 }
24533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24534 return resultobj;
24535 fail:
24536 return NULL;
24537 }
24538
24539
24540 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24541 PyObject *resultobj = 0;
24542 wxDateTime *arg1 = (wxDateTime *) 0 ;
24543 wxDateTime::WeekDay arg2 ;
24544 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24545 wxDateTime *result = 0 ;
24546 void *argp1 = 0 ;
24547 int res1 = 0 ;
24548 int val2 ;
24549 int ecode2 = 0 ;
24550 int val3 ;
24551 int ecode3 = 0 ;
24552 PyObject * obj0 = 0 ;
24553 PyObject * obj1 = 0 ;
24554 PyObject * obj2 = 0 ;
24555 char * kwnames[] = {
24556 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24557 };
24558
24559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24561 if (!SWIG_IsOK(res1)) {
24562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24563 }
24564 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24565 ecode2 = SWIG_AsVal_int(obj1, &val2);
24566 if (!SWIG_IsOK(ecode2)) {
24567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24568 }
24569 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24570 if (obj2) {
24571 ecode3 = SWIG_AsVal_int(obj2, &val3);
24572 if (!SWIG_IsOK(ecode3)) {
24573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24574 }
24575 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24576 }
24577 {
24578 PyThreadState* __tstate = wxPyBeginAllowThreads();
24579 {
24580 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24581 result = (wxDateTime *) &_result_ref;
24582 }
24583 wxPyEndAllowThreads(__tstate);
24584 if (PyErr_Occurred()) SWIG_fail;
24585 }
24586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24587 return resultobj;
24588 fail:
24589 return NULL;
24590 }
24591
24592
24593 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24594 PyObject *resultobj = 0;
24595 wxDateTime *arg1 = (wxDateTime *) 0 ;
24596 wxDateTime::WeekDay arg2 ;
24597 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24598 wxDateTime result;
24599 void *argp1 = 0 ;
24600 int res1 = 0 ;
24601 int val2 ;
24602 int ecode2 = 0 ;
24603 int val3 ;
24604 int ecode3 = 0 ;
24605 PyObject * obj0 = 0 ;
24606 PyObject * obj1 = 0 ;
24607 PyObject * obj2 = 0 ;
24608 char * kwnames[] = {
24609 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24610 };
24611
24612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24614 if (!SWIG_IsOK(res1)) {
24615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24616 }
24617 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24618 ecode2 = SWIG_AsVal_int(obj1, &val2);
24619 if (!SWIG_IsOK(ecode2)) {
24620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24621 }
24622 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24623 if (obj2) {
24624 ecode3 = SWIG_AsVal_int(obj2, &val3);
24625 if (!SWIG_IsOK(ecode3)) {
24626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24627 }
24628 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24629 }
24630 {
24631 PyThreadState* __tstate = wxPyBeginAllowThreads();
24632 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24633 wxPyEndAllowThreads(__tstate);
24634 if (PyErr_Occurred()) SWIG_fail;
24635 }
24636 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24637 return resultobj;
24638 fail:
24639 return NULL;
24640 }
24641
24642
24643 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24644 PyObject *resultobj = 0;
24645 wxDateTime *arg1 = (wxDateTime *) 0 ;
24646 wxDateTime::WeekDay arg2 ;
24647 wxDateTime *result = 0 ;
24648 void *argp1 = 0 ;
24649 int res1 = 0 ;
24650 int val2 ;
24651 int ecode2 = 0 ;
24652 PyObject * obj0 = 0 ;
24653 PyObject * obj1 = 0 ;
24654 char * kwnames[] = {
24655 (char *) "self",(char *) "weekday", NULL
24656 };
24657
24658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24660 if (!SWIG_IsOK(res1)) {
24661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24662 }
24663 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24664 ecode2 = SWIG_AsVal_int(obj1, &val2);
24665 if (!SWIG_IsOK(ecode2)) {
24666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24667 }
24668 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24669 {
24670 PyThreadState* __tstate = wxPyBeginAllowThreads();
24671 {
24672 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24673 result = (wxDateTime *) &_result_ref;
24674 }
24675 wxPyEndAllowThreads(__tstate);
24676 if (PyErr_Occurred()) SWIG_fail;
24677 }
24678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24679 return resultobj;
24680 fail:
24681 return NULL;
24682 }
24683
24684
24685 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24686 PyObject *resultobj = 0;
24687 wxDateTime *arg1 = (wxDateTime *) 0 ;
24688 wxDateTime::WeekDay arg2 ;
24689 wxDateTime result;
24690 void *argp1 = 0 ;
24691 int res1 = 0 ;
24692 int val2 ;
24693 int ecode2 = 0 ;
24694 PyObject * obj0 = 0 ;
24695 PyObject * obj1 = 0 ;
24696 char * kwnames[] = {
24697 (char *) "self",(char *) "weekday", NULL
24698 };
24699
24700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24702 if (!SWIG_IsOK(res1)) {
24703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24704 }
24705 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24706 ecode2 = SWIG_AsVal_int(obj1, &val2);
24707 if (!SWIG_IsOK(ecode2)) {
24708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24709 }
24710 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24711 {
24712 PyThreadState* __tstate = wxPyBeginAllowThreads();
24713 result = (arg1)->GetNextWeekDay(arg2);
24714 wxPyEndAllowThreads(__tstate);
24715 if (PyErr_Occurred()) SWIG_fail;
24716 }
24717 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24718 return resultobj;
24719 fail:
24720 return NULL;
24721 }
24722
24723
24724 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24725 PyObject *resultobj = 0;
24726 wxDateTime *arg1 = (wxDateTime *) 0 ;
24727 wxDateTime::WeekDay arg2 ;
24728 wxDateTime *result = 0 ;
24729 void *argp1 = 0 ;
24730 int res1 = 0 ;
24731 int val2 ;
24732 int ecode2 = 0 ;
24733 PyObject * obj0 = 0 ;
24734 PyObject * obj1 = 0 ;
24735 char * kwnames[] = {
24736 (char *) "self",(char *) "weekday", NULL
24737 };
24738
24739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24741 if (!SWIG_IsOK(res1)) {
24742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24743 }
24744 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24745 ecode2 = SWIG_AsVal_int(obj1, &val2);
24746 if (!SWIG_IsOK(ecode2)) {
24747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24748 }
24749 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24750 {
24751 PyThreadState* __tstate = wxPyBeginAllowThreads();
24752 {
24753 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24754 result = (wxDateTime *) &_result_ref;
24755 }
24756 wxPyEndAllowThreads(__tstate);
24757 if (PyErr_Occurred()) SWIG_fail;
24758 }
24759 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24760 return resultobj;
24761 fail:
24762 return NULL;
24763 }
24764
24765
24766 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24767 PyObject *resultobj = 0;
24768 wxDateTime *arg1 = (wxDateTime *) 0 ;
24769 wxDateTime::WeekDay arg2 ;
24770 wxDateTime result;
24771 void *argp1 = 0 ;
24772 int res1 = 0 ;
24773 int val2 ;
24774 int ecode2 = 0 ;
24775 PyObject * obj0 = 0 ;
24776 PyObject * obj1 = 0 ;
24777 char * kwnames[] = {
24778 (char *) "self",(char *) "weekday", NULL
24779 };
24780
24781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24783 if (!SWIG_IsOK(res1)) {
24784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24785 }
24786 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24787 ecode2 = SWIG_AsVal_int(obj1, &val2);
24788 if (!SWIG_IsOK(ecode2)) {
24789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24790 }
24791 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24792 {
24793 PyThreadState* __tstate = wxPyBeginAllowThreads();
24794 result = (arg1)->GetPrevWeekDay(arg2);
24795 wxPyEndAllowThreads(__tstate);
24796 if (PyErr_Occurred()) SWIG_fail;
24797 }
24798 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24799 return resultobj;
24800 fail:
24801 return NULL;
24802 }
24803
24804
24805 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24806 PyObject *resultobj = 0;
24807 wxDateTime *arg1 = (wxDateTime *) 0 ;
24808 wxDateTime::WeekDay arg2 ;
24809 int arg3 = (int) 1 ;
24810 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24811 int arg5 = (int) wxDateTime::Inv_Year ;
24812 bool result;
24813 void *argp1 = 0 ;
24814 int res1 = 0 ;
24815 int val2 ;
24816 int ecode2 = 0 ;
24817 int val3 ;
24818 int ecode3 = 0 ;
24819 int val4 ;
24820 int ecode4 = 0 ;
24821 int val5 ;
24822 int ecode5 = 0 ;
24823 PyObject * obj0 = 0 ;
24824 PyObject * obj1 = 0 ;
24825 PyObject * obj2 = 0 ;
24826 PyObject * obj3 = 0 ;
24827 PyObject * obj4 = 0 ;
24828 char * kwnames[] = {
24829 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
24830 };
24831
24832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24834 if (!SWIG_IsOK(res1)) {
24835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24836 }
24837 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24838 ecode2 = SWIG_AsVal_int(obj1, &val2);
24839 if (!SWIG_IsOK(ecode2)) {
24840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24841 }
24842 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24843 if (obj2) {
24844 ecode3 = SWIG_AsVal_int(obj2, &val3);
24845 if (!SWIG_IsOK(ecode3)) {
24846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
24847 }
24848 arg3 = static_cast< int >(val3);
24849 }
24850 if (obj3) {
24851 ecode4 = SWIG_AsVal_int(obj3, &val4);
24852 if (!SWIG_IsOK(ecode4)) {
24853 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
24854 }
24855 arg4 = static_cast< wxDateTime::Month >(val4);
24856 }
24857 if (obj4) {
24858 ecode5 = SWIG_AsVal_int(obj4, &val5);
24859 if (!SWIG_IsOK(ecode5)) {
24860 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
24861 }
24862 arg5 = static_cast< int >(val5);
24863 }
24864 {
24865 PyThreadState* __tstate = wxPyBeginAllowThreads();
24866 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
24867 wxPyEndAllowThreads(__tstate);
24868 if (PyErr_Occurred()) SWIG_fail;
24869 }
24870 {
24871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24872 }
24873 return resultobj;
24874 fail:
24875 return NULL;
24876 }
24877
24878
24879 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24880 PyObject *resultobj = 0;
24881 wxDateTime *arg1 = (wxDateTime *) 0 ;
24882 wxDateTime::WeekDay arg2 ;
24883 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24884 int arg4 = (int) wxDateTime::Inv_Year ;
24885 bool result;
24886 void *argp1 = 0 ;
24887 int res1 = 0 ;
24888 int val2 ;
24889 int ecode2 = 0 ;
24890 int val3 ;
24891 int ecode3 = 0 ;
24892 int val4 ;
24893 int ecode4 = 0 ;
24894 PyObject * obj0 = 0 ;
24895 PyObject * obj1 = 0 ;
24896 PyObject * obj2 = 0 ;
24897 PyObject * obj3 = 0 ;
24898 char * kwnames[] = {
24899 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
24900 };
24901
24902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24904 if (!SWIG_IsOK(res1)) {
24905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24906 }
24907 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24908 ecode2 = SWIG_AsVal_int(obj1, &val2);
24909 if (!SWIG_IsOK(ecode2)) {
24910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24911 }
24912 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24913 if (obj2) {
24914 ecode3 = SWIG_AsVal_int(obj2, &val3);
24915 if (!SWIG_IsOK(ecode3)) {
24916 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24917 }
24918 arg3 = static_cast< wxDateTime::Month >(val3);
24919 }
24920 if (obj3) {
24921 ecode4 = SWIG_AsVal_int(obj3, &val4);
24922 if (!SWIG_IsOK(ecode4)) {
24923 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
24924 }
24925 arg4 = static_cast< int >(val4);
24926 }
24927 {
24928 PyThreadState* __tstate = wxPyBeginAllowThreads();
24929 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
24930 wxPyEndAllowThreads(__tstate);
24931 if (PyErr_Occurred()) SWIG_fail;
24932 }
24933 {
24934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24935 }
24936 return resultobj;
24937 fail:
24938 return NULL;
24939 }
24940
24941
24942 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24943 PyObject *resultobj = 0;
24944 wxDateTime *arg1 = (wxDateTime *) 0 ;
24945 wxDateTime::WeekDay arg2 ;
24946 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24947 int arg4 = (int) wxDateTime::Inv_Year ;
24948 wxDateTime result;
24949 void *argp1 = 0 ;
24950 int res1 = 0 ;
24951 int val2 ;
24952 int ecode2 = 0 ;
24953 int val3 ;
24954 int ecode3 = 0 ;
24955 int val4 ;
24956 int ecode4 = 0 ;
24957 PyObject * obj0 = 0 ;
24958 PyObject * obj1 = 0 ;
24959 PyObject * obj2 = 0 ;
24960 PyObject * obj3 = 0 ;
24961 char * kwnames[] = {
24962 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
24963 };
24964
24965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24967 if (!SWIG_IsOK(res1)) {
24968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24969 }
24970 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24971 ecode2 = SWIG_AsVal_int(obj1, &val2);
24972 if (!SWIG_IsOK(ecode2)) {
24973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24974 }
24975 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24976 if (obj2) {
24977 ecode3 = SWIG_AsVal_int(obj2, &val3);
24978 if (!SWIG_IsOK(ecode3)) {
24979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24980 }
24981 arg3 = static_cast< wxDateTime::Month >(val3);
24982 }
24983 if (obj3) {
24984 ecode4 = SWIG_AsVal_int(obj3, &val4);
24985 if (!SWIG_IsOK(ecode4)) {
24986 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
24987 }
24988 arg4 = static_cast< int >(val4);
24989 }
24990 {
24991 PyThreadState* __tstate = wxPyBeginAllowThreads();
24992 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
24993 wxPyEndAllowThreads(__tstate);
24994 if (PyErr_Occurred()) SWIG_fail;
24995 }
24996 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24997 return resultobj;
24998 fail:
24999 return NULL;
25000 }
25001
25002
25003 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25004 PyObject *resultobj = 0;
25005 wxDateTime *arg1 = (wxDateTime *) 0 ;
25006 int arg2 ;
25007 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25008 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25009 bool result;
25010 void *argp1 = 0 ;
25011 int res1 = 0 ;
25012 int val2 ;
25013 int ecode2 = 0 ;
25014 int val3 ;
25015 int ecode3 = 0 ;
25016 int val4 ;
25017 int ecode4 = 0 ;
25018 PyObject * obj0 = 0 ;
25019 PyObject * obj1 = 0 ;
25020 PyObject * obj2 = 0 ;
25021 PyObject * obj3 = 0 ;
25022 char * kwnames[] = {
25023 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25024 };
25025
25026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25028 if (!SWIG_IsOK(res1)) {
25029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25030 }
25031 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25032 ecode2 = SWIG_AsVal_int(obj1, &val2);
25033 if (!SWIG_IsOK(ecode2)) {
25034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25035 }
25036 arg2 = static_cast< int >(val2);
25037 if (obj2) {
25038 ecode3 = SWIG_AsVal_int(obj2, &val3);
25039 if (!SWIG_IsOK(ecode3)) {
25040 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25041 }
25042 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25043 }
25044 if (obj3) {
25045 ecode4 = SWIG_AsVal_int(obj3, &val4);
25046 if (!SWIG_IsOK(ecode4)) {
25047 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25048 }
25049 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25050 }
25051 {
25052 PyThreadState* __tstate = wxPyBeginAllowThreads();
25053 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25054 wxPyEndAllowThreads(__tstate);
25055 if (PyErr_Occurred()) SWIG_fail;
25056 }
25057 {
25058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25059 }
25060 return resultobj;
25061 fail:
25062 return NULL;
25063 }
25064
25065
25066 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25067 PyObject *resultobj = 0;
25068 wxDateTime *arg1 = (wxDateTime *) 0 ;
25069 int arg2 ;
25070 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25071 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25072 wxDateTime result;
25073 void *argp1 = 0 ;
25074 int res1 = 0 ;
25075 int val2 ;
25076 int ecode2 = 0 ;
25077 int val3 ;
25078 int ecode3 = 0 ;
25079 int val4 ;
25080 int ecode4 = 0 ;
25081 PyObject * obj0 = 0 ;
25082 PyObject * obj1 = 0 ;
25083 PyObject * obj2 = 0 ;
25084 PyObject * obj3 = 0 ;
25085 char * kwnames[] = {
25086 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25087 };
25088
25089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25091 if (!SWIG_IsOK(res1)) {
25092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25093 }
25094 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25095 ecode2 = SWIG_AsVal_int(obj1, &val2);
25096 if (!SWIG_IsOK(ecode2)) {
25097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25098 }
25099 arg2 = static_cast< int >(val2);
25100 if (obj2) {
25101 ecode3 = SWIG_AsVal_int(obj2, &val3);
25102 if (!SWIG_IsOK(ecode3)) {
25103 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25104 }
25105 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25106 }
25107 if (obj3) {
25108 ecode4 = SWIG_AsVal_int(obj3, &val4);
25109 if (!SWIG_IsOK(ecode4)) {
25110 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25111 }
25112 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25113 }
25114 {
25115 PyThreadState* __tstate = wxPyBeginAllowThreads();
25116 result = (arg1)->GetWeek(arg2,arg3,arg4);
25117 wxPyEndAllowThreads(__tstate);
25118 if (PyErr_Occurred()) SWIG_fail;
25119 }
25120 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25121 return resultobj;
25122 fail:
25123 return NULL;
25124 }
25125
25126
25127 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25128 PyObject *resultobj = 0;
25129 int arg1 ;
25130 int arg2 ;
25131 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25132 wxDateTime result;
25133 int val1 ;
25134 int ecode1 = 0 ;
25135 int val2 ;
25136 int ecode2 = 0 ;
25137 int val3 ;
25138 int ecode3 = 0 ;
25139 PyObject * obj0 = 0 ;
25140 PyObject * obj1 = 0 ;
25141 PyObject * obj2 = 0 ;
25142 char * kwnames[] = {
25143 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25144 };
25145
25146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25147 ecode1 = SWIG_AsVal_int(obj0, &val1);
25148 if (!SWIG_IsOK(ecode1)) {
25149 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25150 }
25151 arg1 = static_cast< int >(val1);
25152 ecode2 = SWIG_AsVal_int(obj1, &val2);
25153 if (!SWIG_IsOK(ecode2)) {
25154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25155 }
25156 arg2 = static_cast< int >(val2);
25157 if (obj2) {
25158 ecode3 = SWIG_AsVal_int(obj2, &val3);
25159 if (!SWIG_IsOK(ecode3)) {
25160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25161 }
25162 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25163 }
25164 {
25165 PyThreadState* __tstate = wxPyBeginAllowThreads();
25166 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25167 wxPyEndAllowThreads(__tstate);
25168 if (PyErr_Occurred()) SWIG_fail;
25169 }
25170 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25171 return resultobj;
25172 fail:
25173 return NULL;
25174 }
25175
25176
25177 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25178 PyObject *resultobj = 0;
25179 wxDateTime *arg1 = (wxDateTime *) 0 ;
25180 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25181 int arg3 = (int) wxDateTime::Inv_Year ;
25182 wxDateTime *result = 0 ;
25183 void *argp1 = 0 ;
25184 int res1 = 0 ;
25185 int val2 ;
25186 int ecode2 = 0 ;
25187 int val3 ;
25188 int ecode3 = 0 ;
25189 PyObject * obj0 = 0 ;
25190 PyObject * obj1 = 0 ;
25191 PyObject * obj2 = 0 ;
25192 char * kwnames[] = {
25193 (char *) "self",(char *) "month",(char *) "year", NULL
25194 };
25195
25196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25198 if (!SWIG_IsOK(res1)) {
25199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25200 }
25201 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25202 if (obj1) {
25203 ecode2 = SWIG_AsVal_int(obj1, &val2);
25204 if (!SWIG_IsOK(ecode2)) {
25205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25206 }
25207 arg2 = static_cast< wxDateTime::Month >(val2);
25208 }
25209 if (obj2) {
25210 ecode3 = SWIG_AsVal_int(obj2, &val3);
25211 if (!SWIG_IsOK(ecode3)) {
25212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25213 }
25214 arg3 = static_cast< int >(val3);
25215 }
25216 {
25217 PyThreadState* __tstate = wxPyBeginAllowThreads();
25218 {
25219 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25220 result = (wxDateTime *) &_result_ref;
25221 }
25222 wxPyEndAllowThreads(__tstate);
25223 if (PyErr_Occurred()) SWIG_fail;
25224 }
25225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25226 return resultobj;
25227 fail:
25228 return NULL;
25229 }
25230
25231
25232 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25233 PyObject *resultobj = 0;
25234 wxDateTime *arg1 = (wxDateTime *) 0 ;
25235 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25236 int arg3 = (int) wxDateTime::Inv_Year ;
25237 wxDateTime result;
25238 void *argp1 = 0 ;
25239 int res1 = 0 ;
25240 int val2 ;
25241 int ecode2 = 0 ;
25242 int val3 ;
25243 int ecode3 = 0 ;
25244 PyObject * obj0 = 0 ;
25245 PyObject * obj1 = 0 ;
25246 PyObject * obj2 = 0 ;
25247 char * kwnames[] = {
25248 (char *) "self",(char *) "month",(char *) "year", NULL
25249 };
25250
25251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25253 if (!SWIG_IsOK(res1)) {
25254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25255 }
25256 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25257 if (obj1) {
25258 ecode2 = SWIG_AsVal_int(obj1, &val2);
25259 if (!SWIG_IsOK(ecode2)) {
25260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25261 }
25262 arg2 = static_cast< wxDateTime::Month >(val2);
25263 }
25264 if (obj2) {
25265 ecode3 = SWIG_AsVal_int(obj2, &val3);
25266 if (!SWIG_IsOK(ecode3)) {
25267 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25268 }
25269 arg3 = static_cast< int >(val3);
25270 }
25271 {
25272 PyThreadState* __tstate = wxPyBeginAllowThreads();
25273 result = (arg1)->GetLastMonthDay(arg2,arg3);
25274 wxPyEndAllowThreads(__tstate);
25275 if (PyErr_Occurred()) SWIG_fail;
25276 }
25277 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25278 return resultobj;
25279 fail:
25280 return NULL;
25281 }
25282
25283
25284 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25285 PyObject *resultobj = 0;
25286 wxDateTime *arg1 = (wxDateTime *) 0 ;
25287 int arg2 ;
25288 wxDateTime *result = 0 ;
25289 void *argp1 = 0 ;
25290 int res1 = 0 ;
25291 int val2 ;
25292 int ecode2 = 0 ;
25293 PyObject * obj0 = 0 ;
25294 PyObject * obj1 = 0 ;
25295 char * kwnames[] = {
25296 (char *) "self",(char *) "yday", NULL
25297 };
25298
25299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25301 if (!SWIG_IsOK(res1)) {
25302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25303 }
25304 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25305 ecode2 = SWIG_AsVal_int(obj1, &val2);
25306 if (!SWIG_IsOK(ecode2)) {
25307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25308 }
25309 arg2 = static_cast< int >(val2);
25310 {
25311 PyThreadState* __tstate = wxPyBeginAllowThreads();
25312 {
25313 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25314 result = (wxDateTime *) &_result_ref;
25315 }
25316 wxPyEndAllowThreads(__tstate);
25317 if (PyErr_Occurred()) SWIG_fail;
25318 }
25319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25320 return resultobj;
25321 fail:
25322 return NULL;
25323 }
25324
25325
25326 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25327 PyObject *resultobj = 0;
25328 wxDateTime *arg1 = (wxDateTime *) 0 ;
25329 int arg2 ;
25330 wxDateTime result;
25331 void *argp1 = 0 ;
25332 int res1 = 0 ;
25333 int val2 ;
25334 int ecode2 = 0 ;
25335 PyObject * obj0 = 0 ;
25336 PyObject * obj1 = 0 ;
25337 char * kwnames[] = {
25338 (char *) "self",(char *) "yday", NULL
25339 };
25340
25341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25343 if (!SWIG_IsOK(res1)) {
25344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25345 }
25346 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25347 ecode2 = SWIG_AsVal_int(obj1, &val2);
25348 if (!SWIG_IsOK(ecode2)) {
25349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25350 }
25351 arg2 = static_cast< int >(val2);
25352 {
25353 PyThreadState* __tstate = wxPyBeginAllowThreads();
25354 result = (arg1)->GetYearDay(arg2);
25355 wxPyEndAllowThreads(__tstate);
25356 if (PyErr_Occurred()) SWIG_fail;
25357 }
25358 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25359 return resultobj;
25360 fail:
25361 return NULL;
25362 }
25363
25364
25365 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25366 PyObject *resultobj = 0;
25367 wxDateTime *arg1 = (wxDateTime *) 0 ;
25368 double result;
25369 void *argp1 = 0 ;
25370 int res1 = 0 ;
25371 PyObject *swig_obj[1] ;
25372
25373 if (!args) SWIG_fail;
25374 swig_obj[0] = args;
25375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25376 if (!SWIG_IsOK(res1)) {
25377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25378 }
25379 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25380 {
25381 PyThreadState* __tstate = wxPyBeginAllowThreads();
25382 result = (double)(arg1)->GetJulianDayNumber();
25383 wxPyEndAllowThreads(__tstate);
25384 if (PyErr_Occurred()) SWIG_fail;
25385 }
25386 resultobj = SWIG_From_double(static_cast< double >(result));
25387 return resultobj;
25388 fail:
25389 return NULL;
25390 }
25391
25392
25393 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25394 PyObject *resultobj = 0;
25395 wxDateTime *arg1 = (wxDateTime *) 0 ;
25396 double result;
25397 void *argp1 = 0 ;
25398 int res1 = 0 ;
25399 PyObject *swig_obj[1] ;
25400
25401 if (!args) SWIG_fail;
25402 swig_obj[0] = args;
25403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25404 if (!SWIG_IsOK(res1)) {
25405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25406 }
25407 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25408 {
25409 PyThreadState* __tstate = wxPyBeginAllowThreads();
25410 result = (double)(arg1)->GetJDN();
25411 wxPyEndAllowThreads(__tstate);
25412 if (PyErr_Occurred()) SWIG_fail;
25413 }
25414 resultobj = SWIG_From_double(static_cast< double >(result));
25415 return resultobj;
25416 fail:
25417 return NULL;
25418 }
25419
25420
25421 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25422 PyObject *resultobj = 0;
25423 wxDateTime *arg1 = (wxDateTime *) 0 ;
25424 double result;
25425 void *argp1 = 0 ;
25426 int res1 = 0 ;
25427 PyObject *swig_obj[1] ;
25428
25429 if (!args) SWIG_fail;
25430 swig_obj[0] = args;
25431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25432 if (!SWIG_IsOK(res1)) {
25433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25434 }
25435 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25436 {
25437 PyThreadState* __tstate = wxPyBeginAllowThreads();
25438 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25439 wxPyEndAllowThreads(__tstate);
25440 if (PyErr_Occurred()) SWIG_fail;
25441 }
25442 resultobj = SWIG_From_double(static_cast< double >(result));
25443 return resultobj;
25444 fail:
25445 return NULL;
25446 }
25447
25448
25449 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25450 PyObject *resultobj = 0;
25451 wxDateTime *arg1 = (wxDateTime *) 0 ;
25452 double result;
25453 void *argp1 = 0 ;
25454 int res1 = 0 ;
25455 PyObject *swig_obj[1] ;
25456
25457 if (!args) SWIG_fail;
25458 swig_obj[0] = args;
25459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25460 if (!SWIG_IsOK(res1)) {
25461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25462 }
25463 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25464 {
25465 PyThreadState* __tstate = wxPyBeginAllowThreads();
25466 result = (double)(arg1)->GetMJD();
25467 wxPyEndAllowThreads(__tstate);
25468 if (PyErr_Occurred()) SWIG_fail;
25469 }
25470 resultobj = SWIG_From_double(static_cast< double >(result));
25471 return resultobj;
25472 fail:
25473 return NULL;
25474 }
25475
25476
25477 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25478 PyObject *resultobj = 0;
25479 wxDateTime *arg1 = (wxDateTime *) 0 ;
25480 double result;
25481 void *argp1 = 0 ;
25482 int res1 = 0 ;
25483 PyObject *swig_obj[1] ;
25484
25485 if (!args) SWIG_fail;
25486 swig_obj[0] = args;
25487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25488 if (!SWIG_IsOK(res1)) {
25489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25490 }
25491 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25492 {
25493 PyThreadState* __tstate = wxPyBeginAllowThreads();
25494 result = (double)(arg1)->GetRataDie();
25495 wxPyEndAllowThreads(__tstate);
25496 if (PyErr_Occurred()) SWIG_fail;
25497 }
25498 resultobj = SWIG_From_double(static_cast< double >(result));
25499 return resultobj;
25500 fail:
25501 return NULL;
25502 }
25503
25504
25505 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25506 PyObject *resultobj = 0;
25507 wxDateTime *arg1 = (wxDateTime *) 0 ;
25508 wxDateTime::TimeZone *arg2 = 0 ;
25509 bool arg3 = (bool) false ;
25510 wxDateTime result;
25511 void *argp1 = 0 ;
25512 int res1 = 0 ;
25513 bool temp2 = false ;
25514 bool val3 ;
25515 int ecode3 = 0 ;
25516 PyObject * obj0 = 0 ;
25517 PyObject * obj1 = 0 ;
25518 PyObject * obj2 = 0 ;
25519 char * kwnames[] = {
25520 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25521 };
25522
25523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25525 if (!SWIG_IsOK(res1)) {
25526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25527 }
25528 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25529 {
25530 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25531 temp2 = true;
25532 }
25533 if (obj2) {
25534 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25535 if (!SWIG_IsOK(ecode3)) {
25536 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25537 }
25538 arg3 = static_cast< bool >(val3);
25539 }
25540 {
25541 PyThreadState* __tstate = wxPyBeginAllowThreads();
25542 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25543 wxPyEndAllowThreads(__tstate);
25544 if (PyErr_Occurred()) SWIG_fail;
25545 }
25546 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25547 {
25548 if (temp2) delete arg2;
25549 }
25550 return resultobj;
25551 fail:
25552 {
25553 if (temp2) delete arg2;
25554 }
25555 return NULL;
25556 }
25557
25558
25559 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25560 PyObject *resultobj = 0;
25561 wxDateTime *arg1 = (wxDateTime *) 0 ;
25562 wxDateTime::TimeZone *arg2 = 0 ;
25563 bool arg3 = (bool) false ;
25564 wxDateTime *result = 0 ;
25565 void *argp1 = 0 ;
25566 int res1 = 0 ;
25567 bool temp2 = false ;
25568 bool val3 ;
25569 int ecode3 = 0 ;
25570 PyObject * obj0 = 0 ;
25571 PyObject * obj1 = 0 ;
25572 PyObject * obj2 = 0 ;
25573 char * kwnames[] = {
25574 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25575 };
25576
25577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25579 if (!SWIG_IsOK(res1)) {
25580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25581 }
25582 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25583 {
25584 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25585 temp2 = true;
25586 }
25587 if (obj2) {
25588 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25589 if (!SWIG_IsOK(ecode3)) {
25590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25591 }
25592 arg3 = static_cast< bool >(val3);
25593 }
25594 {
25595 PyThreadState* __tstate = wxPyBeginAllowThreads();
25596 {
25597 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25598 result = (wxDateTime *) &_result_ref;
25599 }
25600 wxPyEndAllowThreads(__tstate);
25601 if (PyErr_Occurred()) SWIG_fail;
25602 }
25603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25604 {
25605 if (temp2) delete arg2;
25606 }
25607 return resultobj;
25608 fail:
25609 {
25610 if (temp2) delete arg2;
25611 }
25612 return NULL;
25613 }
25614
25615
25616 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25617 PyObject *resultobj = 0;
25618 wxDateTime *arg1 = (wxDateTime *) 0 ;
25619 wxDateTime::TimeZone *arg2 = 0 ;
25620 bool arg3 = (bool) false ;
25621 wxDateTime result;
25622 void *argp1 = 0 ;
25623 int res1 = 0 ;
25624 bool temp2 = false ;
25625 bool val3 ;
25626 int ecode3 = 0 ;
25627 PyObject * obj0 = 0 ;
25628 PyObject * obj1 = 0 ;
25629 PyObject * obj2 = 0 ;
25630 char * kwnames[] = {
25631 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25632 };
25633
25634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25636 if (!SWIG_IsOK(res1)) {
25637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25638 }
25639 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25640 {
25641 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25642 temp2 = true;
25643 }
25644 if (obj2) {
25645 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25646 if (!SWIG_IsOK(ecode3)) {
25647 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25648 }
25649 arg3 = static_cast< bool >(val3);
25650 }
25651 {
25652 PyThreadState* __tstate = wxPyBeginAllowThreads();
25653 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25654 wxPyEndAllowThreads(__tstate);
25655 if (PyErr_Occurred()) SWIG_fail;
25656 }
25657 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25658 {
25659 if (temp2) delete arg2;
25660 }
25661 return resultobj;
25662 fail:
25663 {
25664 if (temp2) delete arg2;
25665 }
25666 return NULL;
25667 }
25668
25669
25670 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25671 PyObject *resultobj = 0;
25672 wxDateTime *arg1 = (wxDateTime *) 0 ;
25673 wxDateTime::TimeZone *arg2 = 0 ;
25674 bool arg3 = (bool) false ;
25675 wxDateTime *result = 0 ;
25676 void *argp1 = 0 ;
25677 int res1 = 0 ;
25678 bool temp2 = false ;
25679 bool val3 ;
25680 int ecode3 = 0 ;
25681 PyObject * obj0 = 0 ;
25682 PyObject * obj1 = 0 ;
25683 PyObject * obj2 = 0 ;
25684 char * kwnames[] = {
25685 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25686 };
25687
25688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25690 if (!SWIG_IsOK(res1)) {
25691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25692 }
25693 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25694 {
25695 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25696 temp2 = true;
25697 }
25698 if (obj2) {
25699 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25700 if (!SWIG_IsOK(ecode3)) {
25701 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25702 }
25703 arg3 = static_cast< bool >(val3);
25704 }
25705 {
25706 PyThreadState* __tstate = wxPyBeginAllowThreads();
25707 {
25708 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25709 result = (wxDateTime *) &_result_ref;
25710 }
25711 wxPyEndAllowThreads(__tstate);
25712 if (PyErr_Occurred()) SWIG_fail;
25713 }
25714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25715 {
25716 if (temp2) delete arg2;
25717 }
25718 return resultobj;
25719 fail:
25720 {
25721 if (temp2) delete arg2;
25722 }
25723 return NULL;
25724 }
25725
25726
25727 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25728 PyObject *resultobj = 0;
25729 wxDateTime *arg1 = (wxDateTime *) 0 ;
25730 bool arg2 = (bool) false ;
25731 wxDateTime result;
25732 void *argp1 = 0 ;
25733 int res1 = 0 ;
25734 bool val2 ;
25735 int ecode2 = 0 ;
25736 PyObject * obj0 = 0 ;
25737 PyObject * obj1 = 0 ;
25738 char * kwnames[] = {
25739 (char *) "self",(char *) "noDST", NULL
25740 };
25741
25742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25744 if (!SWIG_IsOK(res1)) {
25745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25746 }
25747 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25748 if (obj1) {
25749 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25750 if (!SWIG_IsOK(ecode2)) {
25751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25752 }
25753 arg2 = static_cast< bool >(val2);
25754 }
25755 {
25756 PyThreadState* __tstate = wxPyBeginAllowThreads();
25757 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25758 wxPyEndAllowThreads(__tstate);
25759 if (PyErr_Occurred()) SWIG_fail;
25760 }
25761 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25762 return resultobj;
25763 fail:
25764 return NULL;
25765 }
25766
25767
25768 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25769 PyObject *resultobj = 0;
25770 wxDateTime *arg1 = (wxDateTime *) 0 ;
25771 bool arg2 = (bool) false ;
25772 wxDateTime *result = 0 ;
25773 void *argp1 = 0 ;
25774 int res1 = 0 ;
25775 bool val2 ;
25776 int ecode2 = 0 ;
25777 PyObject * obj0 = 0 ;
25778 PyObject * obj1 = 0 ;
25779 char * kwnames[] = {
25780 (char *) "self",(char *) "noDST", NULL
25781 };
25782
25783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25785 if (!SWIG_IsOK(res1)) {
25786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25787 }
25788 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25789 if (obj1) {
25790 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25791 if (!SWIG_IsOK(ecode2)) {
25792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
25793 }
25794 arg2 = static_cast< bool >(val2);
25795 }
25796 {
25797 PyThreadState* __tstate = wxPyBeginAllowThreads();
25798 {
25799 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
25800 result = (wxDateTime *) &_result_ref;
25801 }
25802 wxPyEndAllowThreads(__tstate);
25803 if (PyErr_Occurred()) SWIG_fail;
25804 }
25805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25806 return resultobj;
25807 fail:
25808 return NULL;
25809 }
25810
25811
25812 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25813 PyObject *resultobj = 0;
25814 wxDateTime *arg1 = (wxDateTime *) 0 ;
25815 bool arg2 = (bool) false ;
25816 wxDateTime result;
25817 void *argp1 = 0 ;
25818 int res1 = 0 ;
25819 bool val2 ;
25820 int ecode2 = 0 ;
25821 PyObject * obj0 = 0 ;
25822 PyObject * obj1 = 0 ;
25823 char * kwnames[] = {
25824 (char *) "self",(char *) "noDST", NULL
25825 };
25826
25827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25829 if (!SWIG_IsOK(res1)) {
25830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25831 }
25832 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25833 if (obj1) {
25834 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25835 if (!SWIG_IsOK(ecode2)) {
25836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
25837 }
25838 arg2 = static_cast< bool >(val2);
25839 }
25840 {
25841 PyThreadState* __tstate = wxPyBeginAllowThreads();
25842 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
25843 wxPyEndAllowThreads(__tstate);
25844 if (PyErr_Occurred()) SWIG_fail;
25845 }
25846 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25847 return resultobj;
25848 fail:
25849 return NULL;
25850 }
25851
25852
25853 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25854 PyObject *resultobj = 0;
25855 wxDateTime *arg1 = (wxDateTime *) 0 ;
25856 bool arg2 = (bool) false ;
25857 wxDateTime *result = 0 ;
25858 void *argp1 = 0 ;
25859 int res1 = 0 ;
25860 bool val2 ;
25861 int ecode2 = 0 ;
25862 PyObject * obj0 = 0 ;
25863 PyObject * obj1 = 0 ;
25864 char * kwnames[] = {
25865 (char *) "self",(char *) "noDST", NULL
25866 };
25867
25868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25870 if (!SWIG_IsOK(res1)) {
25871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
25872 }
25873 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25874 if (obj1) {
25875 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25876 if (!SWIG_IsOK(ecode2)) {
25877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
25878 }
25879 arg2 = static_cast< bool >(val2);
25880 }
25881 {
25882 PyThreadState* __tstate = wxPyBeginAllowThreads();
25883 {
25884 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
25885 result = (wxDateTime *) &_result_ref;
25886 }
25887 wxPyEndAllowThreads(__tstate);
25888 if (PyErr_Occurred()) SWIG_fail;
25889 }
25890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25891 return resultobj;
25892 fail:
25893 return NULL;
25894 }
25895
25896
25897 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25898 PyObject *resultobj = 0;
25899 wxDateTime *arg1 = (wxDateTime *) 0 ;
25900 bool arg2 = (bool) false ;
25901 wxDateTime result;
25902 void *argp1 = 0 ;
25903 int res1 = 0 ;
25904 bool val2 ;
25905 int ecode2 = 0 ;
25906 PyObject * obj0 = 0 ;
25907 PyObject * obj1 = 0 ;
25908 char * kwnames[] = {
25909 (char *) "self",(char *) "noDST", NULL
25910 };
25911
25912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25914 if (!SWIG_IsOK(res1)) {
25915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25916 }
25917 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25918 if (obj1) {
25919 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25920 if (!SWIG_IsOK(ecode2)) {
25921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
25922 }
25923 arg2 = static_cast< bool >(val2);
25924 }
25925 {
25926 PyThreadState* __tstate = wxPyBeginAllowThreads();
25927 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
25928 wxPyEndAllowThreads(__tstate);
25929 if (PyErr_Occurred()) SWIG_fail;
25930 }
25931 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25932 return resultobj;
25933 fail:
25934 return NULL;
25935 }
25936
25937
25938 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25939 PyObject *resultobj = 0;
25940 wxDateTime *arg1 = (wxDateTime *) 0 ;
25941 bool arg2 = (bool) false ;
25942 wxDateTime *result = 0 ;
25943 void *argp1 = 0 ;
25944 int res1 = 0 ;
25945 bool val2 ;
25946 int ecode2 = 0 ;
25947 PyObject * obj0 = 0 ;
25948 PyObject * obj1 = 0 ;
25949 char * kwnames[] = {
25950 (char *) "self",(char *) "noDST", NULL
25951 };
25952
25953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25955 if (!SWIG_IsOK(res1)) {
25956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25957 }
25958 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25959 if (obj1) {
25960 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25961 if (!SWIG_IsOK(ecode2)) {
25962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
25963 }
25964 arg2 = static_cast< bool >(val2);
25965 }
25966 {
25967 PyThreadState* __tstate = wxPyBeginAllowThreads();
25968 {
25969 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
25970 result = (wxDateTime *) &_result_ref;
25971 }
25972 wxPyEndAllowThreads(__tstate);
25973 if (PyErr_Occurred()) SWIG_fail;
25974 }
25975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25976 return resultobj;
25977 fail:
25978 return NULL;
25979 }
25980
25981
25982 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25983 PyObject *resultobj = 0;
25984 wxDateTime *arg1 = (wxDateTime *) 0 ;
25985 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25986 int result;
25987 void *argp1 = 0 ;
25988 int res1 = 0 ;
25989 int val2 ;
25990 int ecode2 = 0 ;
25991 PyObject * obj0 = 0 ;
25992 PyObject * obj1 = 0 ;
25993 char * kwnames[] = {
25994 (char *) "self",(char *) "country", NULL
25995 };
25996
25997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
25998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25999 if (!SWIG_IsOK(res1)) {
26000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26001 }
26002 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26003 if (obj1) {
26004 ecode2 = SWIG_AsVal_int(obj1, &val2);
26005 if (!SWIG_IsOK(ecode2)) {
26006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26007 }
26008 arg2 = static_cast< wxDateTime::Country >(val2);
26009 }
26010 {
26011 PyThreadState* __tstate = wxPyBeginAllowThreads();
26012 result = (int)(arg1)->IsDST(arg2);
26013 wxPyEndAllowThreads(__tstate);
26014 if (PyErr_Occurred()) SWIG_fail;
26015 }
26016 resultobj = SWIG_From_int(static_cast< int >(result));
26017 return resultobj;
26018 fail:
26019 return NULL;
26020 }
26021
26022
26023 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26024 PyObject *resultobj = 0;
26025 wxDateTime *arg1 = (wxDateTime *) 0 ;
26026 bool result;
26027 void *argp1 = 0 ;
26028 int res1 = 0 ;
26029 PyObject *swig_obj[1] ;
26030
26031 if (!args) SWIG_fail;
26032 swig_obj[0] = args;
26033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26034 if (!SWIG_IsOK(res1)) {
26035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26036 }
26037 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26038 {
26039 PyThreadState* __tstate = wxPyBeginAllowThreads();
26040 result = (bool)((wxDateTime const *)arg1)->IsValid();
26041 wxPyEndAllowThreads(__tstate);
26042 if (PyErr_Occurred()) SWIG_fail;
26043 }
26044 {
26045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26046 }
26047 return resultobj;
26048 fail:
26049 return NULL;
26050 }
26051
26052
26053 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26054 PyObject *resultobj = 0;
26055 wxDateTime *arg1 = (wxDateTime *) 0 ;
26056 time_t result;
26057 void *argp1 = 0 ;
26058 int res1 = 0 ;
26059 PyObject *swig_obj[1] ;
26060
26061 if (!args) SWIG_fail;
26062 swig_obj[0] = args;
26063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26064 if (!SWIG_IsOK(res1)) {
26065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26066 }
26067 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26068 {
26069 PyThreadState* __tstate = wxPyBeginAllowThreads();
26070 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26071 wxPyEndAllowThreads(__tstate);
26072 if (PyErr_Occurred()) SWIG_fail;
26073 }
26074 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26075 return resultobj;
26076 fail:
26077 return NULL;
26078 }
26079
26080
26081 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26082 PyObject *resultobj = 0;
26083 wxDateTime *arg1 = (wxDateTime *) 0 ;
26084 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26085 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26086 int result;
26087 void *argp1 = 0 ;
26088 int res1 = 0 ;
26089 bool temp2 = false ;
26090 PyObject * obj0 = 0 ;
26091 PyObject * obj1 = 0 ;
26092 char * kwnames[] = {
26093 (char *) "self",(char *) "tz", NULL
26094 };
26095
26096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26098 if (!SWIG_IsOK(res1)) {
26099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26100 }
26101 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26102 if (obj1) {
26103 {
26104 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26105 temp2 = true;
26106 }
26107 }
26108 {
26109 PyThreadState* __tstate = wxPyBeginAllowThreads();
26110 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26111 wxPyEndAllowThreads(__tstate);
26112 if (PyErr_Occurred()) SWIG_fail;
26113 }
26114 resultobj = SWIG_From_int(static_cast< int >(result));
26115 {
26116 if (temp2) delete arg2;
26117 }
26118 return resultobj;
26119 fail:
26120 {
26121 if (temp2) delete arg2;
26122 }
26123 return NULL;
26124 }
26125
26126
26127 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26128 PyObject *resultobj = 0;
26129 wxDateTime *arg1 = (wxDateTime *) 0 ;
26130 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26131 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26132 wxDateTime::Month result;
26133 void *argp1 = 0 ;
26134 int res1 = 0 ;
26135 bool temp2 = false ;
26136 PyObject * obj0 = 0 ;
26137 PyObject * obj1 = 0 ;
26138 char * kwnames[] = {
26139 (char *) "self",(char *) "tz", NULL
26140 };
26141
26142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26144 if (!SWIG_IsOK(res1)) {
26145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26146 }
26147 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26148 if (obj1) {
26149 {
26150 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26151 temp2 = true;
26152 }
26153 }
26154 {
26155 PyThreadState* __tstate = wxPyBeginAllowThreads();
26156 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26157 wxPyEndAllowThreads(__tstate);
26158 if (PyErr_Occurred()) SWIG_fail;
26159 }
26160 resultobj = SWIG_From_int(static_cast< int >(result));
26161 {
26162 if (temp2) delete arg2;
26163 }
26164 return resultobj;
26165 fail:
26166 {
26167 if (temp2) delete arg2;
26168 }
26169 return NULL;
26170 }
26171
26172
26173 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26174 PyObject *resultobj = 0;
26175 wxDateTime *arg1 = (wxDateTime *) 0 ;
26176 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26177 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26178 int result;
26179 void *argp1 = 0 ;
26180 int res1 = 0 ;
26181 bool temp2 = false ;
26182 PyObject * obj0 = 0 ;
26183 PyObject * obj1 = 0 ;
26184 char * kwnames[] = {
26185 (char *) "self",(char *) "tz", NULL
26186 };
26187
26188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26190 if (!SWIG_IsOK(res1)) {
26191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26192 }
26193 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26194 if (obj1) {
26195 {
26196 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26197 temp2 = true;
26198 }
26199 }
26200 {
26201 PyThreadState* __tstate = wxPyBeginAllowThreads();
26202 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26203 wxPyEndAllowThreads(__tstate);
26204 if (PyErr_Occurred()) SWIG_fail;
26205 }
26206 resultobj = SWIG_From_int(static_cast< int >(result));
26207 {
26208 if (temp2) delete arg2;
26209 }
26210 return resultobj;
26211 fail:
26212 {
26213 if (temp2) delete arg2;
26214 }
26215 return NULL;
26216 }
26217
26218
26219 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26220 PyObject *resultobj = 0;
26221 wxDateTime *arg1 = (wxDateTime *) 0 ;
26222 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26223 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26224 wxDateTime::WeekDay result;
26225 void *argp1 = 0 ;
26226 int res1 = 0 ;
26227 bool temp2 = false ;
26228 PyObject * obj0 = 0 ;
26229 PyObject * obj1 = 0 ;
26230 char * kwnames[] = {
26231 (char *) "self",(char *) "tz", NULL
26232 };
26233
26234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26236 if (!SWIG_IsOK(res1)) {
26237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26238 }
26239 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26240 if (obj1) {
26241 {
26242 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26243 temp2 = true;
26244 }
26245 }
26246 {
26247 PyThreadState* __tstate = wxPyBeginAllowThreads();
26248 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26249 wxPyEndAllowThreads(__tstate);
26250 if (PyErr_Occurred()) SWIG_fail;
26251 }
26252 resultobj = SWIG_From_int(static_cast< int >(result));
26253 {
26254 if (temp2) delete arg2;
26255 }
26256 return resultobj;
26257 fail:
26258 {
26259 if (temp2) delete arg2;
26260 }
26261 return NULL;
26262 }
26263
26264
26265 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26266 PyObject *resultobj = 0;
26267 wxDateTime *arg1 = (wxDateTime *) 0 ;
26268 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26269 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26270 int result;
26271 void *argp1 = 0 ;
26272 int res1 = 0 ;
26273 bool temp2 = false ;
26274 PyObject * obj0 = 0 ;
26275 PyObject * obj1 = 0 ;
26276 char * kwnames[] = {
26277 (char *) "self",(char *) "tz", NULL
26278 };
26279
26280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26282 if (!SWIG_IsOK(res1)) {
26283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26284 }
26285 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26286 if (obj1) {
26287 {
26288 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26289 temp2 = true;
26290 }
26291 }
26292 {
26293 PyThreadState* __tstate = wxPyBeginAllowThreads();
26294 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26295 wxPyEndAllowThreads(__tstate);
26296 if (PyErr_Occurred()) SWIG_fail;
26297 }
26298 resultobj = SWIG_From_int(static_cast< int >(result));
26299 {
26300 if (temp2) delete arg2;
26301 }
26302 return resultobj;
26303 fail:
26304 {
26305 if (temp2) delete arg2;
26306 }
26307 return NULL;
26308 }
26309
26310
26311 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26312 PyObject *resultobj = 0;
26313 wxDateTime *arg1 = (wxDateTime *) 0 ;
26314 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26315 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26316 int result;
26317 void *argp1 = 0 ;
26318 int res1 = 0 ;
26319 bool temp2 = false ;
26320 PyObject * obj0 = 0 ;
26321 PyObject * obj1 = 0 ;
26322 char * kwnames[] = {
26323 (char *) "self",(char *) "tz", NULL
26324 };
26325
26326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26328 if (!SWIG_IsOK(res1)) {
26329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26330 }
26331 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26332 if (obj1) {
26333 {
26334 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26335 temp2 = true;
26336 }
26337 }
26338 {
26339 PyThreadState* __tstate = wxPyBeginAllowThreads();
26340 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26341 wxPyEndAllowThreads(__tstate);
26342 if (PyErr_Occurred()) SWIG_fail;
26343 }
26344 resultobj = SWIG_From_int(static_cast< int >(result));
26345 {
26346 if (temp2) delete arg2;
26347 }
26348 return resultobj;
26349 fail:
26350 {
26351 if (temp2) delete arg2;
26352 }
26353 return NULL;
26354 }
26355
26356
26357 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26358 PyObject *resultobj = 0;
26359 wxDateTime *arg1 = (wxDateTime *) 0 ;
26360 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26361 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26362 int result;
26363 void *argp1 = 0 ;
26364 int res1 = 0 ;
26365 bool temp2 = false ;
26366 PyObject * obj0 = 0 ;
26367 PyObject * obj1 = 0 ;
26368 char * kwnames[] = {
26369 (char *) "self",(char *) "tz", NULL
26370 };
26371
26372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26374 if (!SWIG_IsOK(res1)) {
26375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26376 }
26377 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26378 if (obj1) {
26379 {
26380 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26381 temp2 = true;
26382 }
26383 }
26384 {
26385 PyThreadState* __tstate = wxPyBeginAllowThreads();
26386 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26387 wxPyEndAllowThreads(__tstate);
26388 if (PyErr_Occurred()) SWIG_fail;
26389 }
26390 resultobj = SWIG_From_int(static_cast< int >(result));
26391 {
26392 if (temp2) delete arg2;
26393 }
26394 return resultobj;
26395 fail:
26396 {
26397 if (temp2) delete arg2;
26398 }
26399 return NULL;
26400 }
26401
26402
26403 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26404 PyObject *resultobj = 0;
26405 wxDateTime *arg1 = (wxDateTime *) 0 ;
26406 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26407 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26408 int result;
26409 void *argp1 = 0 ;
26410 int res1 = 0 ;
26411 bool temp2 = false ;
26412 PyObject * obj0 = 0 ;
26413 PyObject * obj1 = 0 ;
26414 char * kwnames[] = {
26415 (char *) "self",(char *) "tz", NULL
26416 };
26417
26418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26420 if (!SWIG_IsOK(res1)) {
26421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26422 }
26423 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26424 if (obj1) {
26425 {
26426 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26427 temp2 = true;
26428 }
26429 }
26430 {
26431 PyThreadState* __tstate = wxPyBeginAllowThreads();
26432 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26433 wxPyEndAllowThreads(__tstate);
26434 if (PyErr_Occurred()) SWIG_fail;
26435 }
26436 resultobj = SWIG_From_int(static_cast< int >(result));
26437 {
26438 if (temp2) delete arg2;
26439 }
26440 return resultobj;
26441 fail:
26442 {
26443 if (temp2) delete arg2;
26444 }
26445 return NULL;
26446 }
26447
26448
26449 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26450 PyObject *resultobj = 0;
26451 wxDateTime *arg1 = (wxDateTime *) 0 ;
26452 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26453 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26454 int result;
26455 void *argp1 = 0 ;
26456 int res1 = 0 ;
26457 bool temp2 = false ;
26458 PyObject * obj0 = 0 ;
26459 PyObject * obj1 = 0 ;
26460 char * kwnames[] = {
26461 (char *) "self",(char *) "tz", NULL
26462 };
26463
26464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26466 if (!SWIG_IsOK(res1)) {
26467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26468 }
26469 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26470 if (obj1) {
26471 {
26472 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26473 temp2 = true;
26474 }
26475 }
26476 {
26477 PyThreadState* __tstate = wxPyBeginAllowThreads();
26478 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26479 wxPyEndAllowThreads(__tstate);
26480 if (PyErr_Occurred()) SWIG_fail;
26481 }
26482 resultobj = SWIG_From_int(static_cast< int >(result));
26483 {
26484 if (temp2) delete arg2;
26485 }
26486 return resultobj;
26487 fail:
26488 {
26489 if (temp2) delete arg2;
26490 }
26491 return NULL;
26492 }
26493
26494
26495 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26496 PyObject *resultobj = 0;
26497 wxDateTime *arg1 = (wxDateTime *) 0 ;
26498 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26499 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26500 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26501 int result;
26502 void *argp1 = 0 ;
26503 int res1 = 0 ;
26504 int val2 ;
26505 int ecode2 = 0 ;
26506 bool temp3 = false ;
26507 PyObject * obj0 = 0 ;
26508 PyObject * obj1 = 0 ;
26509 PyObject * obj2 = 0 ;
26510 char * kwnames[] = {
26511 (char *) "self",(char *) "flags",(char *) "tz", NULL
26512 };
26513
26514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26516 if (!SWIG_IsOK(res1)) {
26517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26518 }
26519 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26520 if (obj1) {
26521 ecode2 = SWIG_AsVal_int(obj1, &val2);
26522 if (!SWIG_IsOK(ecode2)) {
26523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26524 }
26525 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26526 }
26527 if (obj2) {
26528 {
26529 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26530 temp3 = true;
26531 }
26532 }
26533 {
26534 PyThreadState* __tstate = wxPyBeginAllowThreads();
26535 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26536 wxPyEndAllowThreads(__tstate);
26537 if (PyErr_Occurred()) SWIG_fail;
26538 }
26539 resultobj = SWIG_From_int(static_cast< int >(result));
26540 {
26541 if (temp3) delete arg3;
26542 }
26543 return resultobj;
26544 fail:
26545 {
26546 if (temp3) delete arg3;
26547 }
26548 return NULL;
26549 }
26550
26551
26552 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26553 PyObject *resultobj = 0;
26554 wxDateTime *arg1 = (wxDateTime *) 0 ;
26555 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26556 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26557 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26558 int result;
26559 void *argp1 = 0 ;
26560 int res1 = 0 ;
26561 int val2 ;
26562 int ecode2 = 0 ;
26563 bool temp3 = false ;
26564 PyObject * obj0 = 0 ;
26565 PyObject * obj1 = 0 ;
26566 PyObject * obj2 = 0 ;
26567 char * kwnames[] = {
26568 (char *) "self",(char *) "flags",(char *) "tz", NULL
26569 };
26570
26571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26573 if (!SWIG_IsOK(res1)) {
26574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26575 }
26576 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26577 if (obj1) {
26578 ecode2 = SWIG_AsVal_int(obj1, &val2);
26579 if (!SWIG_IsOK(ecode2)) {
26580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26581 }
26582 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26583 }
26584 if (obj2) {
26585 {
26586 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26587 temp3 = true;
26588 }
26589 }
26590 {
26591 PyThreadState* __tstate = wxPyBeginAllowThreads();
26592 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26593 wxPyEndAllowThreads(__tstate);
26594 if (PyErr_Occurred()) SWIG_fail;
26595 }
26596 resultobj = SWIG_From_int(static_cast< int >(result));
26597 {
26598 if (temp3) delete arg3;
26599 }
26600 return resultobj;
26601 fail:
26602 {
26603 if (temp3) delete arg3;
26604 }
26605 return NULL;
26606 }
26607
26608
26609 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26610 PyObject *resultobj = 0;
26611 wxDateTime *arg1 = (wxDateTime *) 0 ;
26612 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26613 bool result;
26614 void *argp1 = 0 ;
26615 int res1 = 0 ;
26616 int val2 ;
26617 int ecode2 = 0 ;
26618 PyObject * obj0 = 0 ;
26619 PyObject * obj1 = 0 ;
26620 char * kwnames[] = {
26621 (char *) "self",(char *) "country", NULL
26622 };
26623
26624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26626 if (!SWIG_IsOK(res1)) {
26627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26628 }
26629 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26630 if (obj1) {
26631 ecode2 = SWIG_AsVal_int(obj1, &val2);
26632 if (!SWIG_IsOK(ecode2)) {
26633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26634 }
26635 arg2 = static_cast< wxDateTime::Country >(val2);
26636 }
26637 {
26638 PyThreadState* __tstate = wxPyBeginAllowThreads();
26639 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26640 wxPyEndAllowThreads(__tstate);
26641 if (PyErr_Occurred()) SWIG_fail;
26642 }
26643 {
26644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26645 }
26646 return resultobj;
26647 fail:
26648 return NULL;
26649 }
26650
26651
26652 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26653 PyObject *resultobj = 0;
26654 wxDateTime *arg1 = (wxDateTime *) 0 ;
26655 wxDateTime *arg2 = 0 ;
26656 bool result;
26657 void *argp1 = 0 ;
26658 int res1 = 0 ;
26659 void *argp2 = 0 ;
26660 int res2 = 0 ;
26661 PyObject * obj0 = 0 ;
26662 PyObject * obj1 = 0 ;
26663 char * kwnames[] = {
26664 (char *) "self",(char *) "datetime", NULL
26665 };
26666
26667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26669 if (!SWIG_IsOK(res1)) {
26670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26671 }
26672 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26673 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26674 if (!SWIG_IsOK(res2)) {
26675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26676 }
26677 if (!argp2) {
26678 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26679 }
26680 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26681 {
26682 PyThreadState* __tstate = wxPyBeginAllowThreads();
26683 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26684 wxPyEndAllowThreads(__tstate);
26685 if (PyErr_Occurred()) SWIG_fail;
26686 }
26687 {
26688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26689 }
26690 return resultobj;
26691 fail:
26692 return NULL;
26693 }
26694
26695
26696 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26697 PyObject *resultobj = 0;
26698 wxDateTime *arg1 = (wxDateTime *) 0 ;
26699 wxDateTime *arg2 = 0 ;
26700 bool result;
26701 void *argp1 = 0 ;
26702 int res1 = 0 ;
26703 void *argp2 = 0 ;
26704 int res2 = 0 ;
26705 PyObject * obj0 = 0 ;
26706 PyObject * obj1 = 0 ;
26707 char * kwnames[] = {
26708 (char *) "self",(char *) "datetime", NULL
26709 };
26710
26711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26713 if (!SWIG_IsOK(res1)) {
26714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26715 }
26716 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26717 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26718 if (!SWIG_IsOK(res2)) {
26719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26720 }
26721 if (!argp2) {
26722 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26723 }
26724 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26725 {
26726 PyThreadState* __tstate = wxPyBeginAllowThreads();
26727 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26728 wxPyEndAllowThreads(__tstate);
26729 if (PyErr_Occurred()) SWIG_fail;
26730 }
26731 {
26732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26733 }
26734 return resultobj;
26735 fail:
26736 return NULL;
26737 }
26738
26739
26740 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26741 PyObject *resultobj = 0;
26742 wxDateTime *arg1 = (wxDateTime *) 0 ;
26743 wxDateTime *arg2 = 0 ;
26744 bool result;
26745 void *argp1 = 0 ;
26746 int res1 = 0 ;
26747 void *argp2 = 0 ;
26748 int res2 = 0 ;
26749 PyObject * obj0 = 0 ;
26750 PyObject * obj1 = 0 ;
26751 char * kwnames[] = {
26752 (char *) "self",(char *) "datetime", NULL
26753 };
26754
26755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26757 if (!SWIG_IsOK(res1)) {
26758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26759 }
26760 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26761 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26762 if (!SWIG_IsOK(res2)) {
26763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26764 }
26765 if (!argp2) {
26766 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26767 }
26768 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26769 {
26770 PyThreadState* __tstate = wxPyBeginAllowThreads();
26771 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26772 wxPyEndAllowThreads(__tstate);
26773 if (PyErr_Occurred()) SWIG_fail;
26774 }
26775 {
26776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26777 }
26778 return resultobj;
26779 fail:
26780 return NULL;
26781 }
26782
26783
26784 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26785 PyObject *resultobj = 0;
26786 wxDateTime *arg1 = (wxDateTime *) 0 ;
26787 wxDateTime *arg2 = 0 ;
26788 wxDateTime *arg3 = 0 ;
26789 bool result;
26790 void *argp1 = 0 ;
26791 int res1 = 0 ;
26792 void *argp2 = 0 ;
26793 int res2 = 0 ;
26794 void *argp3 = 0 ;
26795 int res3 = 0 ;
26796 PyObject * obj0 = 0 ;
26797 PyObject * obj1 = 0 ;
26798 PyObject * obj2 = 0 ;
26799 char * kwnames[] = {
26800 (char *) "self",(char *) "t1",(char *) "t2", NULL
26801 };
26802
26803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26805 if (!SWIG_IsOK(res1)) {
26806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26807 }
26808 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26809 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26810 if (!SWIG_IsOK(res2)) {
26811 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26812 }
26813 if (!argp2) {
26814 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26815 }
26816 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26817 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26818 if (!SWIG_IsOK(res3)) {
26819 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26820 }
26821 if (!argp3) {
26822 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26823 }
26824 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26825 {
26826 PyThreadState* __tstate = wxPyBeginAllowThreads();
26827 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
26828 wxPyEndAllowThreads(__tstate);
26829 if (PyErr_Occurred()) SWIG_fail;
26830 }
26831 {
26832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26833 }
26834 return resultobj;
26835 fail:
26836 return NULL;
26837 }
26838
26839
26840 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26841 PyObject *resultobj = 0;
26842 wxDateTime *arg1 = (wxDateTime *) 0 ;
26843 wxDateTime *arg2 = 0 ;
26844 wxDateTime *arg3 = 0 ;
26845 bool result;
26846 void *argp1 = 0 ;
26847 int res1 = 0 ;
26848 void *argp2 = 0 ;
26849 int res2 = 0 ;
26850 void *argp3 = 0 ;
26851 int res3 = 0 ;
26852 PyObject * obj0 = 0 ;
26853 PyObject * obj1 = 0 ;
26854 PyObject * obj2 = 0 ;
26855 char * kwnames[] = {
26856 (char *) "self",(char *) "t1",(char *) "t2", NULL
26857 };
26858
26859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26861 if (!SWIG_IsOK(res1)) {
26862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26863 }
26864 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26865 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26866 if (!SWIG_IsOK(res2)) {
26867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26868 }
26869 if (!argp2) {
26870 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26871 }
26872 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26873 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26874 if (!SWIG_IsOK(res3)) {
26875 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26876 }
26877 if (!argp3) {
26878 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26879 }
26880 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26881 {
26882 PyThreadState* __tstate = wxPyBeginAllowThreads();
26883 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
26884 wxPyEndAllowThreads(__tstate);
26885 if (PyErr_Occurred()) SWIG_fail;
26886 }
26887 {
26888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26889 }
26890 return resultobj;
26891 fail:
26892 return NULL;
26893 }
26894
26895
26896 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26897 PyObject *resultobj = 0;
26898 wxDateTime *arg1 = (wxDateTime *) 0 ;
26899 wxDateTime *arg2 = 0 ;
26900 bool result;
26901 void *argp1 = 0 ;
26902 int res1 = 0 ;
26903 void *argp2 = 0 ;
26904 int res2 = 0 ;
26905 PyObject * obj0 = 0 ;
26906 PyObject * obj1 = 0 ;
26907 char * kwnames[] = {
26908 (char *) "self",(char *) "dt", NULL
26909 };
26910
26911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
26912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26913 if (!SWIG_IsOK(res1)) {
26914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26915 }
26916 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26917 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26918 if (!SWIG_IsOK(res2)) {
26919 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26920 }
26921 if (!argp2) {
26922 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26923 }
26924 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26925 {
26926 PyThreadState* __tstate = wxPyBeginAllowThreads();
26927 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
26928 wxPyEndAllowThreads(__tstate);
26929 if (PyErr_Occurred()) SWIG_fail;
26930 }
26931 {
26932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26933 }
26934 return resultobj;
26935 fail:
26936 return NULL;
26937 }
26938
26939
26940 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26941 PyObject *resultobj = 0;
26942 wxDateTime *arg1 = (wxDateTime *) 0 ;
26943 wxDateTime *arg2 = 0 ;
26944 bool result;
26945 void *argp1 = 0 ;
26946 int res1 = 0 ;
26947 void *argp2 = 0 ;
26948 int res2 = 0 ;
26949 PyObject * obj0 = 0 ;
26950 PyObject * obj1 = 0 ;
26951 char * kwnames[] = {
26952 (char *) "self",(char *) "dt", NULL
26953 };
26954
26955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
26956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26957 if (!SWIG_IsOK(res1)) {
26958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26959 }
26960 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26961 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26962 if (!SWIG_IsOK(res2)) {
26963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26964 }
26965 if (!argp2) {
26966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26967 }
26968 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26969 {
26970 PyThreadState* __tstate = wxPyBeginAllowThreads();
26971 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
26972 wxPyEndAllowThreads(__tstate);
26973 if (PyErr_Occurred()) SWIG_fail;
26974 }
26975 {
26976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26977 }
26978 return resultobj;
26979 fail:
26980 return NULL;
26981 }
26982
26983
26984 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26985 PyObject *resultobj = 0;
26986 wxDateTime *arg1 = (wxDateTime *) 0 ;
26987 wxDateTime *arg2 = 0 ;
26988 wxTimeSpan *arg3 = 0 ;
26989 bool result;
26990 void *argp1 = 0 ;
26991 int res1 = 0 ;
26992 void *argp2 = 0 ;
26993 int res2 = 0 ;
26994 void *argp3 = 0 ;
26995 int res3 = 0 ;
26996 PyObject * obj0 = 0 ;
26997 PyObject * obj1 = 0 ;
26998 PyObject * obj2 = 0 ;
26999 char * kwnames[] = {
27000 (char *) "self",(char *) "dt",(char *) "ts", NULL
27001 };
27002
27003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27005 if (!SWIG_IsOK(res1)) {
27006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27007 }
27008 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27009 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27010 if (!SWIG_IsOK(res2)) {
27011 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27012 }
27013 if (!argp2) {
27014 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27015 }
27016 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27017 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27018 if (!SWIG_IsOK(res3)) {
27019 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27020 }
27021 if (!argp3) {
27022 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27023 }
27024 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27025 {
27026 PyThreadState* __tstate = wxPyBeginAllowThreads();
27027 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27028 wxPyEndAllowThreads(__tstate);
27029 if (PyErr_Occurred()) SWIG_fail;
27030 }
27031 {
27032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27033 }
27034 return resultobj;
27035 fail:
27036 return NULL;
27037 }
27038
27039
27040 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27041 PyObject *resultobj = 0;
27042 wxDateTime *arg1 = (wxDateTime *) 0 ;
27043 wxTimeSpan *arg2 = 0 ;
27044 wxDateTime *result = 0 ;
27045 void *argp1 = 0 ;
27046 int res1 = 0 ;
27047 void *argp2 = 0 ;
27048 int res2 = 0 ;
27049 PyObject * obj0 = 0 ;
27050 PyObject * obj1 = 0 ;
27051 char * kwnames[] = {
27052 (char *) "self",(char *) "diff", NULL
27053 };
27054
27055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27057 if (!SWIG_IsOK(res1)) {
27058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27059 }
27060 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27061 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27062 if (!SWIG_IsOK(res2)) {
27063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27064 }
27065 if (!argp2) {
27066 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27067 }
27068 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27069 {
27070 PyThreadState* __tstate = wxPyBeginAllowThreads();
27071 {
27072 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27073 result = (wxDateTime *) &_result_ref;
27074 }
27075 wxPyEndAllowThreads(__tstate);
27076 if (PyErr_Occurred()) SWIG_fail;
27077 }
27078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27079 return resultobj;
27080 fail:
27081 return NULL;
27082 }
27083
27084
27085 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27086 PyObject *resultobj = 0;
27087 wxDateTime *arg1 = (wxDateTime *) 0 ;
27088 wxDateSpan *arg2 = 0 ;
27089 wxDateTime *result = 0 ;
27090 void *argp1 = 0 ;
27091 int res1 = 0 ;
27092 void *argp2 = 0 ;
27093 int res2 = 0 ;
27094 PyObject * obj0 = 0 ;
27095 PyObject * obj1 = 0 ;
27096 char * kwnames[] = {
27097 (char *) "self",(char *) "diff", NULL
27098 };
27099
27100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27102 if (!SWIG_IsOK(res1)) {
27103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27104 }
27105 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27106 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27107 if (!SWIG_IsOK(res2)) {
27108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27109 }
27110 if (!argp2) {
27111 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27112 }
27113 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27114 {
27115 PyThreadState* __tstate = wxPyBeginAllowThreads();
27116 {
27117 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27118 result = (wxDateTime *) &_result_ref;
27119 }
27120 wxPyEndAllowThreads(__tstate);
27121 if (PyErr_Occurred()) SWIG_fail;
27122 }
27123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27124 return resultobj;
27125 fail:
27126 return NULL;
27127 }
27128
27129
27130 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27131 PyObject *resultobj = 0;
27132 wxDateTime *arg1 = (wxDateTime *) 0 ;
27133 wxTimeSpan *arg2 = 0 ;
27134 wxDateTime *result = 0 ;
27135 void *argp1 = 0 ;
27136 int res1 = 0 ;
27137 void *argp2 = 0 ;
27138 int res2 = 0 ;
27139 PyObject * obj0 = 0 ;
27140 PyObject * obj1 = 0 ;
27141 char * kwnames[] = {
27142 (char *) "self",(char *) "diff", NULL
27143 };
27144
27145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27147 if (!SWIG_IsOK(res1)) {
27148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27149 }
27150 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27151 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27152 if (!SWIG_IsOK(res2)) {
27153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27154 }
27155 if (!argp2) {
27156 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27157 }
27158 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27159 {
27160 PyThreadState* __tstate = wxPyBeginAllowThreads();
27161 {
27162 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27163 result = (wxDateTime *) &_result_ref;
27164 }
27165 wxPyEndAllowThreads(__tstate);
27166 if (PyErr_Occurred()) SWIG_fail;
27167 }
27168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27169 return resultobj;
27170 fail:
27171 return NULL;
27172 }
27173
27174
27175 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27176 PyObject *resultobj = 0;
27177 wxDateTime *arg1 = (wxDateTime *) 0 ;
27178 wxDateSpan *arg2 = 0 ;
27179 wxDateTime *result = 0 ;
27180 void *argp1 = 0 ;
27181 int res1 = 0 ;
27182 void *argp2 = 0 ;
27183 int res2 = 0 ;
27184 PyObject * obj0 = 0 ;
27185 PyObject * obj1 = 0 ;
27186 char * kwnames[] = {
27187 (char *) "self",(char *) "diff", NULL
27188 };
27189
27190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27192 if (!SWIG_IsOK(res1)) {
27193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27194 }
27195 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27196 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27197 if (!SWIG_IsOK(res2)) {
27198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27199 }
27200 if (!argp2) {
27201 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27202 }
27203 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27204 {
27205 PyThreadState* __tstate = wxPyBeginAllowThreads();
27206 {
27207 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27208 result = (wxDateTime *) &_result_ref;
27209 }
27210 wxPyEndAllowThreads(__tstate);
27211 if (PyErr_Occurred()) SWIG_fail;
27212 }
27213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27214 return resultobj;
27215 fail:
27216 return NULL;
27217 }
27218
27219
27220 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27221 PyObject *resultobj = 0;
27222 wxDateTime *arg1 = (wxDateTime *) 0 ;
27223 wxDateTime *arg2 = 0 ;
27224 wxTimeSpan result;
27225 void *argp1 = 0 ;
27226 int res1 = 0 ;
27227 void *argp2 = 0 ;
27228 int res2 = 0 ;
27229 PyObject * obj0 = 0 ;
27230 PyObject * obj1 = 0 ;
27231 char * kwnames[] = {
27232 (char *) "self",(char *) "dt", NULL
27233 };
27234
27235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27237 if (!SWIG_IsOK(res1)) {
27238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27239 }
27240 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27241 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27242 if (!SWIG_IsOK(res2)) {
27243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27244 }
27245 if (!argp2) {
27246 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27247 }
27248 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27249 {
27250 PyThreadState* __tstate = wxPyBeginAllowThreads();
27251 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27252 wxPyEndAllowThreads(__tstate);
27253 if (PyErr_Occurred()) SWIG_fail;
27254 }
27255 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27256 return resultobj;
27257 fail:
27258 return NULL;
27259 }
27260
27261
27262 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27263 PyObject *resultobj = 0;
27264 wxDateTime *arg1 = (wxDateTime *) 0 ;
27265 wxTimeSpan *arg2 = 0 ;
27266 wxDateTime *result = 0 ;
27267 void *argp1 = 0 ;
27268 int res1 = 0 ;
27269 void *argp2 = 0 ;
27270 int res2 = 0 ;
27271
27272 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27274 if (!SWIG_IsOK(res1)) {
27275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27276 }
27277 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27278 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27279 if (!SWIG_IsOK(res2)) {
27280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27281 }
27282 if (!argp2) {
27283 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27284 }
27285 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27286 {
27287 PyThreadState* __tstate = wxPyBeginAllowThreads();
27288 {
27289 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27290 result = (wxDateTime *) &_result_ref;
27291 }
27292 wxPyEndAllowThreads(__tstate);
27293 if (PyErr_Occurred()) SWIG_fail;
27294 }
27295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27296 return resultobj;
27297 fail:
27298 return NULL;
27299 }
27300
27301
27302 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27303 PyObject *resultobj = 0;
27304 wxDateTime *arg1 = (wxDateTime *) 0 ;
27305 wxDateSpan *arg2 = 0 ;
27306 wxDateTime *result = 0 ;
27307 void *argp1 = 0 ;
27308 int res1 = 0 ;
27309 void *argp2 = 0 ;
27310 int res2 = 0 ;
27311
27312 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27314 if (!SWIG_IsOK(res1)) {
27315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27316 }
27317 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27318 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27319 if (!SWIG_IsOK(res2)) {
27320 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27321 }
27322 if (!argp2) {
27323 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27324 }
27325 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27326 {
27327 PyThreadState* __tstate = wxPyBeginAllowThreads();
27328 {
27329 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27330 result = (wxDateTime *) &_result_ref;
27331 }
27332 wxPyEndAllowThreads(__tstate);
27333 if (PyErr_Occurred()) SWIG_fail;
27334 }
27335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27336 return resultobj;
27337 fail:
27338 return NULL;
27339 }
27340
27341
27342 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27343 int argc;
27344 PyObject *argv[3];
27345
27346 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27347 --argc;
27348 if (argc == 2) {
27349 int _v = 0;
27350 {
27351 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27352 _v = SWIG_CheckState(res);
27353 }
27354 if (!_v) goto check_1;
27355 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27356 }
27357 check_1:
27358
27359 if (argc == 2) {
27360 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27361 }
27362
27363 fail:
27364 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27365 return NULL;
27366 }
27367
27368
27369 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27370 PyObject *resultobj = 0;
27371 wxDateTime *arg1 = (wxDateTime *) 0 ;
27372 wxTimeSpan *arg2 = 0 ;
27373 wxDateTime *result = 0 ;
27374 void *argp1 = 0 ;
27375 int res1 = 0 ;
27376 void *argp2 = 0 ;
27377 int res2 = 0 ;
27378
27379 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27381 if (!SWIG_IsOK(res1)) {
27382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27383 }
27384 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27385 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27386 if (!SWIG_IsOK(res2)) {
27387 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27388 }
27389 if (!argp2) {
27390 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27391 }
27392 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27393 {
27394 PyThreadState* __tstate = wxPyBeginAllowThreads();
27395 {
27396 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27397 result = (wxDateTime *) &_result_ref;
27398 }
27399 wxPyEndAllowThreads(__tstate);
27400 if (PyErr_Occurred()) SWIG_fail;
27401 }
27402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27403 return resultobj;
27404 fail:
27405 return NULL;
27406 }
27407
27408
27409 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27410 PyObject *resultobj = 0;
27411 wxDateTime *arg1 = (wxDateTime *) 0 ;
27412 wxDateSpan *arg2 = 0 ;
27413 wxDateTime *result = 0 ;
27414 void *argp1 = 0 ;
27415 int res1 = 0 ;
27416 void *argp2 = 0 ;
27417 int res2 = 0 ;
27418
27419 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27421 if (!SWIG_IsOK(res1)) {
27422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27423 }
27424 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27425 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27426 if (!SWIG_IsOK(res2)) {
27427 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27428 }
27429 if (!argp2) {
27430 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27431 }
27432 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27433 {
27434 PyThreadState* __tstate = wxPyBeginAllowThreads();
27435 {
27436 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27437 result = (wxDateTime *) &_result_ref;
27438 }
27439 wxPyEndAllowThreads(__tstate);
27440 if (PyErr_Occurred()) SWIG_fail;
27441 }
27442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27443 return resultobj;
27444 fail:
27445 return NULL;
27446 }
27447
27448
27449 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27450 int argc;
27451 PyObject *argv[3];
27452
27453 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27454 --argc;
27455 if (argc == 2) {
27456 int _v = 0;
27457 {
27458 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27459 _v = SWIG_CheckState(res);
27460 }
27461 if (!_v) goto check_1;
27462 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27463 }
27464 check_1:
27465
27466 if (argc == 2) {
27467 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27468 }
27469
27470 fail:
27471 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27472 return NULL;
27473 }
27474
27475
27476 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27477 PyObject *resultobj = 0;
27478 wxDateTime *arg1 = (wxDateTime *) 0 ;
27479 wxTimeSpan *arg2 = 0 ;
27480 wxDateTime result;
27481 void *argp1 = 0 ;
27482 int res1 = 0 ;
27483 void *argp2 = 0 ;
27484 int res2 = 0 ;
27485
27486 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27488 if (!SWIG_IsOK(res1)) {
27489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27490 }
27491 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27492 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27493 if (!SWIG_IsOK(res2)) {
27494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27495 }
27496 if (!argp2) {
27497 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27498 }
27499 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27500 {
27501 PyThreadState* __tstate = wxPyBeginAllowThreads();
27502 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27503 wxPyEndAllowThreads(__tstate);
27504 if (PyErr_Occurred()) SWIG_fail;
27505 }
27506 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27507 return resultobj;
27508 fail:
27509 return NULL;
27510 }
27511
27512
27513 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27514 PyObject *resultobj = 0;
27515 wxDateTime *arg1 = (wxDateTime *) 0 ;
27516 wxDateSpan *arg2 = 0 ;
27517 wxDateTime result;
27518 void *argp1 = 0 ;
27519 int res1 = 0 ;
27520 void *argp2 = 0 ;
27521 int res2 = 0 ;
27522
27523 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27525 if (!SWIG_IsOK(res1)) {
27526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27527 }
27528 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27529 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27530 if (!SWIG_IsOK(res2)) {
27531 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27532 }
27533 if (!argp2) {
27534 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27535 }
27536 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27537 {
27538 PyThreadState* __tstate = wxPyBeginAllowThreads();
27539 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27540 wxPyEndAllowThreads(__tstate);
27541 if (PyErr_Occurred()) SWIG_fail;
27542 }
27543 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27544 return resultobj;
27545 fail:
27546 return NULL;
27547 }
27548
27549
27550 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27551 int argc;
27552 PyObject *argv[3];
27553
27554 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27555 --argc;
27556 if (argc == 2) {
27557 int _v = 0;
27558 {
27559 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27560 _v = SWIG_CheckState(res);
27561 }
27562 if (!_v) goto check_1;
27563 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27564 }
27565 check_1:
27566
27567 if (argc == 2) {
27568 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27569 }
27570
27571 fail:
27572 Py_INCREF(Py_NotImplemented);
27573 return Py_NotImplemented;
27574 }
27575
27576
27577 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27578 PyObject *resultobj = 0;
27579 wxDateTime *arg1 = (wxDateTime *) 0 ;
27580 wxDateTime *arg2 = 0 ;
27581 wxTimeSpan result;
27582 void *argp1 = 0 ;
27583 int res1 = 0 ;
27584 void *argp2 = 0 ;
27585 int res2 = 0 ;
27586
27587 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27589 if (!SWIG_IsOK(res1)) {
27590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27591 }
27592 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27593 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27594 if (!SWIG_IsOK(res2)) {
27595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27596 }
27597 if (!argp2) {
27598 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27599 }
27600 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27601 {
27602 PyThreadState* __tstate = wxPyBeginAllowThreads();
27603 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27604 wxPyEndAllowThreads(__tstate);
27605 if (PyErr_Occurred()) SWIG_fail;
27606 }
27607 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27608 return resultobj;
27609 fail:
27610 return NULL;
27611 }
27612
27613
27614 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27615 PyObject *resultobj = 0;
27616 wxDateTime *arg1 = (wxDateTime *) 0 ;
27617 wxTimeSpan *arg2 = 0 ;
27618 wxDateTime result;
27619 void *argp1 = 0 ;
27620 int res1 = 0 ;
27621 void *argp2 = 0 ;
27622 int res2 = 0 ;
27623
27624 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27626 if (!SWIG_IsOK(res1)) {
27627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27628 }
27629 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27630 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27631 if (!SWIG_IsOK(res2)) {
27632 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27633 }
27634 if (!argp2) {
27635 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27636 }
27637 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27638 {
27639 PyThreadState* __tstate = wxPyBeginAllowThreads();
27640 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27641 wxPyEndAllowThreads(__tstate);
27642 if (PyErr_Occurred()) SWIG_fail;
27643 }
27644 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27645 return resultobj;
27646 fail:
27647 return NULL;
27648 }
27649
27650
27651 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27652 PyObject *resultobj = 0;
27653 wxDateTime *arg1 = (wxDateTime *) 0 ;
27654 wxDateSpan *arg2 = 0 ;
27655 wxDateTime result;
27656 void *argp1 = 0 ;
27657 int res1 = 0 ;
27658 void *argp2 = 0 ;
27659 int res2 = 0 ;
27660
27661 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27663 if (!SWIG_IsOK(res1)) {
27664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27665 }
27666 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27667 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27668 if (!SWIG_IsOK(res2)) {
27669 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27670 }
27671 if (!argp2) {
27672 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27673 }
27674 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27675 {
27676 PyThreadState* __tstate = wxPyBeginAllowThreads();
27677 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27678 wxPyEndAllowThreads(__tstate);
27679 if (PyErr_Occurred()) SWIG_fail;
27680 }
27681 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27682 return resultobj;
27683 fail:
27684 return NULL;
27685 }
27686
27687
27688 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27689 int argc;
27690 PyObject *argv[3];
27691
27692 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27693 --argc;
27694 if (argc == 2) {
27695 int _v = 0;
27696 {
27697 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27698 _v = SWIG_CheckState(res);
27699 }
27700 if (!_v) goto check_1;
27701 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27702 }
27703 check_1:
27704
27705 if (argc == 2) {
27706 int _v = 0;
27707 {
27708 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27709 _v = SWIG_CheckState(res);
27710 }
27711 if (!_v) goto check_2;
27712 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27713 }
27714 check_2:
27715
27716 if (argc == 2) {
27717 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27718 }
27719
27720 fail:
27721 Py_INCREF(Py_NotImplemented);
27722 return Py_NotImplemented;
27723 }
27724
27725
27726 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27727 PyObject *resultobj = 0;
27728 wxDateTime *arg1 = (wxDateTime *) 0 ;
27729 wxDateTime *arg2 = (wxDateTime *) 0 ;
27730 bool result;
27731 void *argp1 = 0 ;
27732 int res1 = 0 ;
27733 void *argp2 = 0 ;
27734 int res2 = 0 ;
27735 PyObject * obj0 = 0 ;
27736 PyObject * obj1 = 0 ;
27737 char * kwnames[] = {
27738 (char *) "self",(char *) "other", NULL
27739 };
27740
27741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27743 if (!SWIG_IsOK(res1)) {
27744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27745 }
27746 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27747 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27748 if (!SWIG_IsOK(res2)) {
27749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27750 }
27751 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27752 {
27753 PyThreadState* __tstate = wxPyBeginAllowThreads();
27754 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27755 wxPyEndAllowThreads(__tstate);
27756 if (PyErr_Occurred()) SWIG_fail;
27757 }
27758 {
27759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27760 }
27761 return resultobj;
27762 fail:
27763 return NULL;
27764 }
27765
27766
27767 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27768 PyObject *resultobj = 0;
27769 wxDateTime *arg1 = (wxDateTime *) 0 ;
27770 wxDateTime *arg2 = (wxDateTime *) 0 ;
27771 bool result;
27772 void *argp1 = 0 ;
27773 int res1 = 0 ;
27774 void *argp2 = 0 ;
27775 int res2 = 0 ;
27776 PyObject * obj0 = 0 ;
27777 PyObject * obj1 = 0 ;
27778 char * kwnames[] = {
27779 (char *) "self",(char *) "other", NULL
27780 };
27781
27782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27784 if (!SWIG_IsOK(res1)) {
27785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27786 }
27787 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27788 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27789 if (!SWIG_IsOK(res2)) {
27790 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27791 }
27792 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27793 {
27794 PyThreadState* __tstate = wxPyBeginAllowThreads();
27795 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
27796 wxPyEndAllowThreads(__tstate);
27797 if (PyErr_Occurred()) SWIG_fail;
27798 }
27799 {
27800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27801 }
27802 return resultobj;
27803 fail:
27804 return NULL;
27805 }
27806
27807
27808 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27809 PyObject *resultobj = 0;
27810 wxDateTime *arg1 = (wxDateTime *) 0 ;
27811 wxDateTime *arg2 = (wxDateTime *) 0 ;
27812 bool result;
27813 void *argp1 = 0 ;
27814 int res1 = 0 ;
27815 void *argp2 = 0 ;
27816 int res2 = 0 ;
27817 PyObject * obj0 = 0 ;
27818 PyObject * obj1 = 0 ;
27819 char * kwnames[] = {
27820 (char *) "self",(char *) "other", NULL
27821 };
27822
27823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
27824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27825 if (!SWIG_IsOK(res1)) {
27826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27827 }
27828 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27829 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27830 if (!SWIG_IsOK(res2)) {
27831 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27832 }
27833 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27834 {
27835 PyThreadState* __tstate = wxPyBeginAllowThreads();
27836 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
27837 wxPyEndAllowThreads(__tstate);
27838 if (PyErr_Occurred()) SWIG_fail;
27839 }
27840 {
27841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27842 }
27843 return resultobj;
27844 fail:
27845 return NULL;
27846 }
27847
27848
27849 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27850 PyObject *resultobj = 0;
27851 wxDateTime *arg1 = (wxDateTime *) 0 ;
27852 wxDateTime *arg2 = (wxDateTime *) 0 ;
27853 bool result;
27854 void *argp1 = 0 ;
27855 int res1 = 0 ;
27856 void *argp2 = 0 ;
27857 int res2 = 0 ;
27858 PyObject * obj0 = 0 ;
27859 PyObject * obj1 = 0 ;
27860 char * kwnames[] = {
27861 (char *) "self",(char *) "other", NULL
27862 };
27863
27864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
27865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27866 if (!SWIG_IsOK(res1)) {
27867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27868 }
27869 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27870 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27871 if (!SWIG_IsOK(res2)) {
27872 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27873 }
27874 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27875 {
27876 PyThreadState* __tstate = wxPyBeginAllowThreads();
27877 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
27878 wxPyEndAllowThreads(__tstate);
27879 if (PyErr_Occurred()) SWIG_fail;
27880 }
27881 {
27882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27883 }
27884 return resultobj;
27885 fail:
27886 return NULL;
27887 }
27888
27889
27890 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27891 PyObject *resultobj = 0;
27892 wxDateTime *arg1 = (wxDateTime *) 0 ;
27893 wxDateTime *arg2 = (wxDateTime *) 0 ;
27894 bool result;
27895 void *argp1 = 0 ;
27896 int res1 = 0 ;
27897 void *argp2 = 0 ;
27898 int res2 = 0 ;
27899 PyObject * obj0 = 0 ;
27900 PyObject * obj1 = 0 ;
27901 char * kwnames[] = {
27902 (char *) "self",(char *) "other", NULL
27903 };
27904
27905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
27906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27907 if (!SWIG_IsOK(res1)) {
27908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27909 }
27910 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27911 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27912 if (!SWIG_IsOK(res2)) {
27913 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27914 }
27915 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27916 {
27917 PyThreadState* __tstate = wxPyBeginAllowThreads();
27918 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
27919 wxPyEndAllowThreads(__tstate);
27920 if (PyErr_Occurred()) SWIG_fail;
27921 }
27922 {
27923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27924 }
27925 return resultobj;
27926 fail:
27927 return NULL;
27928 }
27929
27930
27931 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27932 PyObject *resultobj = 0;
27933 wxDateTime *arg1 = (wxDateTime *) 0 ;
27934 wxDateTime *arg2 = (wxDateTime *) 0 ;
27935 bool result;
27936 void *argp1 = 0 ;
27937 int res1 = 0 ;
27938 void *argp2 = 0 ;
27939 int res2 = 0 ;
27940 PyObject * obj0 = 0 ;
27941 PyObject * obj1 = 0 ;
27942 char * kwnames[] = {
27943 (char *) "self",(char *) "other", NULL
27944 };
27945
27946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
27947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27948 if (!SWIG_IsOK(res1)) {
27949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27950 }
27951 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27952 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27953 if (!SWIG_IsOK(res2)) {
27954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27955 }
27956 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27957 {
27958 PyThreadState* __tstate = wxPyBeginAllowThreads();
27959 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
27960 wxPyEndAllowThreads(__tstate);
27961 if (PyErr_Occurred()) SWIG_fail;
27962 }
27963 {
27964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27965 }
27966 return resultobj;
27967 fail:
27968 return NULL;
27969 }
27970
27971
27972 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27973 PyObject *resultobj = 0;
27974 wxDateTime *arg1 = (wxDateTime *) 0 ;
27975 wxString *arg2 = 0 ;
27976 int result;
27977 void *argp1 = 0 ;
27978 int res1 = 0 ;
27979 bool temp2 = false ;
27980 PyObject * obj0 = 0 ;
27981 PyObject * obj1 = 0 ;
27982 char * kwnames[] = {
27983 (char *) "self",(char *) "date", NULL
27984 };
27985
27986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
27987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27988 if (!SWIG_IsOK(res1)) {
27989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
27990 }
27991 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27992 {
27993 arg2 = wxString_in_helper(obj1);
27994 if (arg2 == NULL) SWIG_fail;
27995 temp2 = true;
27996 }
27997 {
27998 PyThreadState* __tstate = wxPyBeginAllowThreads();
27999 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28000 wxPyEndAllowThreads(__tstate);
28001 if (PyErr_Occurred()) SWIG_fail;
28002 }
28003 resultobj = SWIG_From_int(static_cast< int >(result));
28004 {
28005 if (temp2)
28006 delete arg2;
28007 }
28008 return resultobj;
28009 fail:
28010 {
28011 if (temp2)
28012 delete arg2;
28013 }
28014 return NULL;
28015 }
28016
28017
28018 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28019 PyObject *resultobj = 0;
28020 wxDateTime *arg1 = (wxDateTime *) 0 ;
28021 wxString *arg2 = 0 ;
28022 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28023 wxString *arg3 = (wxString *) &arg3_defvalue ;
28024 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28025 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28026 int result;
28027 void *argp1 = 0 ;
28028 int res1 = 0 ;
28029 bool temp2 = false ;
28030 bool temp3 = false ;
28031 void *argp4 = 0 ;
28032 int res4 = 0 ;
28033 PyObject * obj0 = 0 ;
28034 PyObject * obj1 = 0 ;
28035 PyObject * obj2 = 0 ;
28036 PyObject * obj3 = 0 ;
28037 char * kwnames[] = {
28038 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28039 };
28040
28041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28043 if (!SWIG_IsOK(res1)) {
28044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28045 }
28046 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28047 {
28048 arg2 = wxString_in_helper(obj1);
28049 if (arg2 == NULL) SWIG_fail;
28050 temp2 = true;
28051 }
28052 if (obj2) {
28053 {
28054 arg3 = wxString_in_helper(obj2);
28055 if (arg3 == NULL) SWIG_fail;
28056 temp3 = true;
28057 }
28058 }
28059 if (obj3) {
28060 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28061 if (!SWIG_IsOK(res4)) {
28062 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28063 }
28064 if (!argp4) {
28065 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28066 }
28067 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28068 }
28069 {
28070 PyThreadState* __tstate = wxPyBeginAllowThreads();
28071 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28072 wxPyEndAllowThreads(__tstate);
28073 if (PyErr_Occurred()) SWIG_fail;
28074 }
28075 resultobj = SWIG_From_int(static_cast< int >(result));
28076 {
28077 if (temp2)
28078 delete arg2;
28079 }
28080 {
28081 if (temp3)
28082 delete arg3;
28083 }
28084 return resultobj;
28085 fail:
28086 {
28087 if (temp2)
28088 delete arg2;
28089 }
28090 {
28091 if (temp3)
28092 delete arg3;
28093 }
28094 return NULL;
28095 }
28096
28097
28098 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28099 PyObject *resultobj = 0;
28100 wxDateTime *arg1 = (wxDateTime *) 0 ;
28101 wxString *arg2 = 0 ;
28102 int result;
28103 void *argp1 = 0 ;
28104 int res1 = 0 ;
28105 bool temp2 = false ;
28106 PyObject * obj0 = 0 ;
28107 PyObject * obj1 = 0 ;
28108 char * kwnames[] = {
28109 (char *) "self",(char *) "datetime", NULL
28110 };
28111
28112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28114 if (!SWIG_IsOK(res1)) {
28115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28116 }
28117 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28118 {
28119 arg2 = wxString_in_helper(obj1);
28120 if (arg2 == NULL) SWIG_fail;
28121 temp2 = true;
28122 }
28123 {
28124 PyThreadState* __tstate = wxPyBeginAllowThreads();
28125 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28126 wxPyEndAllowThreads(__tstate);
28127 if (PyErr_Occurred()) SWIG_fail;
28128 }
28129 resultobj = SWIG_From_int(static_cast< int >(result));
28130 {
28131 if (temp2)
28132 delete arg2;
28133 }
28134 return resultobj;
28135 fail:
28136 {
28137 if (temp2)
28138 delete arg2;
28139 }
28140 return NULL;
28141 }
28142
28143
28144 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28145 PyObject *resultobj = 0;
28146 wxDateTime *arg1 = (wxDateTime *) 0 ;
28147 wxString *arg2 = 0 ;
28148 int result;
28149 void *argp1 = 0 ;
28150 int res1 = 0 ;
28151 bool temp2 = false ;
28152 PyObject * obj0 = 0 ;
28153 PyObject * obj1 = 0 ;
28154 char * kwnames[] = {
28155 (char *) "self",(char *) "date", NULL
28156 };
28157
28158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28160 if (!SWIG_IsOK(res1)) {
28161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28162 }
28163 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28164 {
28165 arg2 = wxString_in_helper(obj1);
28166 if (arg2 == NULL) SWIG_fail;
28167 temp2 = true;
28168 }
28169 {
28170 PyThreadState* __tstate = wxPyBeginAllowThreads();
28171 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28172 wxPyEndAllowThreads(__tstate);
28173 if (PyErr_Occurred()) SWIG_fail;
28174 }
28175 resultobj = SWIG_From_int(static_cast< int >(result));
28176 {
28177 if (temp2)
28178 delete arg2;
28179 }
28180 return resultobj;
28181 fail:
28182 {
28183 if (temp2)
28184 delete arg2;
28185 }
28186 return NULL;
28187 }
28188
28189
28190 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28191 PyObject *resultobj = 0;
28192 wxDateTime *arg1 = (wxDateTime *) 0 ;
28193 wxString *arg2 = 0 ;
28194 int result;
28195 void *argp1 = 0 ;
28196 int res1 = 0 ;
28197 bool temp2 = false ;
28198 PyObject * obj0 = 0 ;
28199 PyObject * obj1 = 0 ;
28200 char * kwnames[] = {
28201 (char *) "self",(char *) "time", NULL
28202 };
28203
28204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28206 if (!SWIG_IsOK(res1)) {
28207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28208 }
28209 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28210 {
28211 arg2 = wxString_in_helper(obj1);
28212 if (arg2 == NULL) SWIG_fail;
28213 temp2 = true;
28214 }
28215 {
28216 PyThreadState* __tstate = wxPyBeginAllowThreads();
28217 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28218 wxPyEndAllowThreads(__tstate);
28219 if (PyErr_Occurred()) SWIG_fail;
28220 }
28221 resultobj = SWIG_From_int(static_cast< int >(result));
28222 {
28223 if (temp2)
28224 delete arg2;
28225 }
28226 return resultobj;
28227 fail:
28228 {
28229 if (temp2)
28230 delete arg2;
28231 }
28232 return NULL;
28233 }
28234
28235
28236 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28237 PyObject *resultobj = 0;
28238 wxDateTime *arg1 = (wxDateTime *) 0 ;
28239 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28240 wxString *arg2 = (wxString *) &arg2_defvalue ;
28241 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28242 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28243 wxString result;
28244 void *argp1 = 0 ;
28245 int res1 = 0 ;
28246 bool temp2 = false ;
28247 bool temp3 = false ;
28248 PyObject * obj0 = 0 ;
28249 PyObject * obj1 = 0 ;
28250 PyObject * obj2 = 0 ;
28251 char * kwnames[] = {
28252 (char *) "self",(char *) "format",(char *) "tz", NULL
28253 };
28254
28255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28257 if (!SWIG_IsOK(res1)) {
28258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28259 }
28260 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28261 if (obj1) {
28262 {
28263 arg2 = wxString_in_helper(obj1);
28264 if (arg2 == NULL) SWIG_fail;
28265 temp2 = true;
28266 }
28267 }
28268 if (obj2) {
28269 {
28270 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28271 temp3 = true;
28272 }
28273 }
28274 {
28275 PyThreadState* __tstate = wxPyBeginAllowThreads();
28276 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28277 wxPyEndAllowThreads(__tstate);
28278 if (PyErr_Occurred()) SWIG_fail;
28279 }
28280 {
28281 #if wxUSE_UNICODE
28282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28283 #else
28284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28285 #endif
28286 }
28287 {
28288 if (temp2)
28289 delete arg2;
28290 }
28291 {
28292 if (temp3) delete arg3;
28293 }
28294 return resultobj;
28295 fail:
28296 {
28297 if (temp2)
28298 delete arg2;
28299 }
28300 {
28301 if (temp3) delete arg3;
28302 }
28303 return NULL;
28304 }
28305
28306
28307 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28308 PyObject *resultobj = 0;
28309 wxDateTime *arg1 = (wxDateTime *) 0 ;
28310 wxString result;
28311 void *argp1 = 0 ;
28312 int res1 = 0 ;
28313 PyObject *swig_obj[1] ;
28314
28315 if (!args) SWIG_fail;
28316 swig_obj[0] = args;
28317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28318 if (!SWIG_IsOK(res1)) {
28319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28320 }
28321 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28322 {
28323 PyThreadState* __tstate = wxPyBeginAllowThreads();
28324 result = ((wxDateTime const *)arg1)->FormatDate();
28325 wxPyEndAllowThreads(__tstate);
28326 if (PyErr_Occurred()) SWIG_fail;
28327 }
28328 {
28329 #if wxUSE_UNICODE
28330 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28331 #else
28332 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28333 #endif
28334 }
28335 return resultobj;
28336 fail:
28337 return NULL;
28338 }
28339
28340
28341 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28342 PyObject *resultobj = 0;
28343 wxDateTime *arg1 = (wxDateTime *) 0 ;
28344 wxString result;
28345 void *argp1 = 0 ;
28346 int res1 = 0 ;
28347 PyObject *swig_obj[1] ;
28348
28349 if (!args) SWIG_fail;
28350 swig_obj[0] = args;
28351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28352 if (!SWIG_IsOK(res1)) {
28353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28354 }
28355 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28356 {
28357 PyThreadState* __tstate = wxPyBeginAllowThreads();
28358 result = ((wxDateTime const *)arg1)->FormatTime();
28359 wxPyEndAllowThreads(__tstate);
28360 if (PyErr_Occurred()) SWIG_fail;
28361 }
28362 {
28363 #if wxUSE_UNICODE
28364 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28365 #else
28366 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28367 #endif
28368 }
28369 return resultobj;
28370 fail:
28371 return NULL;
28372 }
28373
28374
28375 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28376 PyObject *resultobj = 0;
28377 wxDateTime *arg1 = (wxDateTime *) 0 ;
28378 wxString result;
28379 void *argp1 = 0 ;
28380 int res1 = 0 ;
28381 PyObject *swig_obj[1] ;
28382
28383 if (!args) SWIG_fail;
28384 swig_obj[0] = args;
28385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28386 if (!SWIG_IsOK(res1)) {
28387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28388 }
28389 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28390 {
28391 PyThreadState* __tstate = wxPyBeginAllowThreads();
28392 result = ((wxDateTime const *)arg1)->FormatISODate();
28393 wxPyEndAllowThreads(__tstate);
28394 if (PyErr_Occurred()) SWIG_fail;
28395 }
28396 {
28397 #if wxUSE_UNICODE
28398 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28399 #else
28400 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28401 #endif
28402 }
28403 return resultobj;
28404 fail:
28405 return NULL;
28406 }
28407
28408
28409 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28410 PyObject *resultobj = 0;
28411 wxDateTime *arg1 = (wxDateTime *) 0 ;
28412 wxString result;
28413 void *argp1 = 0 ;
28414 int res1 = 0 ;
28415 PyObject *swig_obj[1] ;
28416
28417 if (!args) SWIG_fail;
28418 swig_obj[0] = args;
28419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28420 if (!SWIG_IsOK(res1)) {
28421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28422 }
28423 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28424 {
28425 PyThreadState* __tstate = wxPyBeginAllowThreads();
28426 result = ((wxDateTime const *)arg1)->FormatISOTime();
28427 wxPyEndAllowThreads(__tstate);
28428 if (PyErr_Occurred()) SWIG_fail;
28429 }
28430 {
28431 #if wxUSE_UNICODE
28432 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28433 #else
28434 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28435 #endif
28436 }
28437 return resultobj;
28438 fail:
28439 return NULL;
28440 }
28441
28442
28443 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28444 PyObject *obj;
28445 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28446 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28447 return SWIG_Py_Void();
28448 }
28449
28450 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28451 return SWIG_Python_InitShadowInstance(args);
28452 }
28453
28454 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28455 PyObject *resultobj = 0;
28456 long arg1 ;
28457 wxTimeSpan result;
28458 long val1 ;
28459 int ecode1 = 0 ;
28460 PyObject * obj0 = 0 ;
28461 char * kwnames[] = {
28462 (char *) "ms", NULL
28463 };
28464
28465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28466 ecode1 = SWIG_AsVal_long(obj0, &val1);
28467 if (!SWIG_IsOK(ecode1)) {
28468 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28469 }
28470 arg1 = static_cast< long >(val1);
28471 {
28472 PyThreadState* __tstate = wxPyBeginAllowThreads();
28473 result = wxTimeSpan::Milliseconds(arg1);
28474 wxPyEndAllowThreads(__tstate);
28475 if (PyErr_Occurred()) SWIG_fail;
28476 }
28477 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28478 return resultobj;
28479 fail:
28480 return NULL;
28481 }
28482
28483
28484 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28485 PyObject *resultobj = 0;
28486 wxTimeSpan result;
28487
28488 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28489 {
28490 PyThreadState* __tstate = wxPyBeginAllowThreads();
28491 result = wxTimeSpan::Millisecond();
28492 wxPyEndAllowThreads(__tstate);
28493 if (PyErr_Occurred()) SWIG_fail;
28494 }
28495 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28496 return resultobj;
28497 fail:
28498 return NULL;
28499 }
28500
28501
28502 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28503 PyObject *resultobj = 0;
28504 long arg1 ;
28505 wxTimeSpan result;
28506 long val1 ;
28507 int ecode1 = 0 ;
28508 PyObject * obj0 = 0 ;
28509 char * kwnames[] = {
28510 (char *) "sec", NULL
28511 };
28512
28513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28514 ecode1 = SWIG_AsVal_long(obj0, &val1);
28515 if (!SWIG_IsOK(ecode1)) {
28516 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28517 }
28518 arg1 = static_cast< long >(val1);
28519 {
28520 PyThreadState* __tstate = wxPyBeginAllowThreads();
28521 result = wxTimeSpan::Seconds(arg1);
28522 wxPyEndAllowThreads(__tstate);
28523 if (PyErr_Occurred()) SWIG_fail;
28524 }
28525 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28526 return resultobj;
28527 fail:
28528 return NULL;
28529 }
28530
28531
28532 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28533 PyObject *resultobj = 0;
28534 wxTimeSpan result;
28535
28536 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28537 {
28538 PyThreadState* __tstate = wxPyBeginAllowThreads();
28539 result = wxTimeSpan::Second();
28540 wxPyEndAllowThreads(__tstate);
28541 if (PyErr_Occurred()) SWIG_fail;
28542 }
28543 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28544 return resultobj;
28545 fail:
28546 return NULL;
28547 }
28548
28549
28550 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28551 PyObject *resultobj = 0;
28552 long arg1 ;
28553 wxTimeSpan result;
28554 long val1 ;
28555 int ecode1 = 0 ;
28556 PyObject * obj0 = 0 ;
28557 char * kwnames[] = {
28558 (char *) "min", NULL
28559 };
28560
28561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28562 ecode1 = SWIG_AsVal_long(obj0, &val1);
28563 if (!SWIG_IsOK(ecode1)) {
28564 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28565 }
28566 arg1 = static_cast< long >(val1);
28567 {
28568 PyThreadState* __tstate = wxPyBeginAllowThreads();
28569 result = wxTimeSpan::Minutes(arg1);
28570 wxPyEndAllowThreads(__tstate);
28571 if (PyErr_Occurred()) SWIG_fail;
28572 }
28573 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28574 return resultobj;
28575 fail:
28576 return NULL;
28577 }
28578
28579
28580 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28581 PyObject *resultobj = 0;
28582 wxTimeSpan result;
28583
28584 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28585 {
28586 PyThreadState* __tstate = wxPyBeginAllowThreads();
28587 result = wxTimeSpan::Minute();
28588 wxPyEndAllowThreads(__tstate);
28589 if (PyErr_Occurred()) SWIG_fail;
28590 }
28591 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28592 return resultobj;
28593 fail:
28594 return NULL;
28595 }
28596
28597
28598 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28599 PyObject *resultobj = 0;
28600 long arg1 ;
28601 wxTimeSpan result;
28602 long val1 ;
28603 int ecode1 = 0 ;
28604 PyObject * obj0 = 0 ;
28605 char * kwnames[] = {
28606 (char *) "hours", NULL
28607 };
28608
28609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28610 ecode1 = SWIG_AsVal_long(obj0, &val1);
28611 if (!SWIG_IsOK(ecode1)) {
28612 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28613 }
28614 arg1 = static_cast< long >(val1);
28615 {
28616 PyThreadState* __tstate = wxPyBeginAllowThreads();
28617 result = wxTimeSpan::Hours(arg1);
28618 wxPyEndAllowThreads(__tstate);
28619 if (PyErr_Occurred()) SWIG_fail;
28620 }
28621 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28622 return resultobj;
28623 fail:
28624 return NULL;
28625 }
28626
28627
28628 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28629 PyObject *resultobj = 0;
28630 wxTimeSpan result;
28631
28632 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28633 {
28634 PyThreadState* __tstate = wxPyBeginAllowThreads();
28635 result = wxTimeSpan::Hour();
28636 wxPyEndAllowThreads(__tstate);
28637 if (PyErr_Occurred()) SWIG_fail;
28638 }
28639 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28640 return resultobj;
28641 fail:
28642 return NULL;
28643 }
28644
28645
28646 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28647 PyObject *resultobj = 0;
28648 long arg1 ;
28649 wxTimeSpan result;
28650 long val1 ;
28651 int ecode1 = 0 ;
28652 PyObject * obj0 = 0 ;
28653 char * kwnames[] = {
28654 (char *) "days", NULL
28655 };
28656
28657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28658 ecode1 = SWIG_AsVal_long(obj0, &val1);
28659 if (!SWIG_IsOK(ecode1)) {
28660 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28661 }
28662 arg1 = static_cast< long >(val1);
28663 {
28664 PyThreadState* __tstate = wxPyBeginAllowThreads();
28665 result = wxTimeSpan::Days(arg1);
28666 wxPyEndAllowThreads(__tstate);
28667 if (PyErr_Occurred()) SWIG_fail;
28668 }
28669 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28670 return resultobj;
28671 fail:
28672 return NULL;
28673 }
28674
28675
28676 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28677 PyObject *resultobj = 0;
28678 wxTimeSpan result;
28679
28680 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28681 {
28682 PyThreadState* __tstate = wxPyBeginAllowThreads();
28683 result = wxTimeSpan::Day();
28684 wxPyEndAllowThreads(__tstate);
28685 if (PyErr_Occurred()) SWIG_fail;
28686 }
28687 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28688 return resultobj;
28689 fail:
28690 return NULL;
28691 }
28692
28693
28694 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28695 PyObject *resultobj = 0;
28696 long arg1 ;
28697 wxTimeSpan result;
28698 long val1 ;
28699 int ecode1 = 0 ;
28700 PyObject * obj0 = 0 ;
28701 char * kwnames[] = {
28702 (char *) "days", NULL
28703 };
28704
28705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28706 ecode1 = SWIG_AsVal_long(obj0, &val1);
28707 if (!SWIG_IsOK(ecode1)) {
28708 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28709 }
28710 arg1 = static_cast< long >(val1);
28711 {
28712 PyThreadState* __tstate = wxPyBeginAllowThreads();
28713 result = wxTimeSpan::Weeks(arg1);
28714 wxPyEndAllowThreads(__tstate);
28715 if (PyErr_Occurred()) SWIG_fail;
28716 }
28717 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28718 return resultobj;
28719 fail:
28720 return NULL;
28721 }
28722
28723
28724 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28725 PyObject *resultobj = 0;
28726 wxTimeSpan result;
28727
28728 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28729 {
28730 PyThreadState* __tstate = wxPyBeginAllowThreads();
28731 result = wxTimeSpan::Week();
28732 wxPyEndAllowThreads(__tstate);
28733 if (PyErr_Occurred()) SWIG_fail;
28734 }
28735 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28736 return resultobj;
28737 fail:
28738 return NULL;
28739 }
28740
28741
28742 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28743 PyObject *resultobj = 0;
28744 long arg1 = (long) 0 ;
28745 long arg2 = (long) 0 ;
28746 long arg3 = (long) 0 ;
28747 long arg4 = (long) 0 ;
28748 wxTimeSpan *result = 0 ;
28749 long val1 ;
28750 int ecode1 = 0 ;
28751 long val2 ;
28752 int ecode2 = 0 ;
28753 long val3 ;
28754 int ecode3 = 0 ;
28755 long val4 ;
28756 int ecode4 = 0 ;
28757 PyObject * obj0 = 0 ;
28758 PyObject * obj1 = 0 ;
28759 PyObject * obj2 = 0 ;
28760 PyObject * obj3 = 0 ;
28761 char * kwnames[] = {
28762 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28763 };
28764
28765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28766 if (obj0) {
28767 ecode1 = SWIG_AsVal_long(obj0, &val1);
28768 if (!SWIG_IsOK(ecode1)) {
28769 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28770 }
28771 arg1 = static_cast< long >(val1);
28772 }
28773 if (obj1) {
28774 ecode2 = SWIG_AsVal_long(obj1, &val2);
28775 if (!SWIG_IsOK(ecode2)) {
28776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28777 }
28778 arg2 = static_cast< long >(val2);
28779 }
28780 if (obj2) {
28781 ecode3 = SWIG_AsVal_long(obj2, &val3);
28782 if (!SWIG_IsOK(ecode3)) {
28783 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28784 }
28785 arg3 = static_cast< long >(val3);
28786 }
28787 if (obj3) {
28788 ecode4 = SWIG_AsVal_long(obj3, &val4);
28789 if (!SWIG_IsOK(ecode4)) {
28790 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28791 }
28792 arg4 = static_cast< long >(val4);
28793 }
28794 {
28795 PyThreadState* __tstate = wxPyBeginAllowThreads();
28796 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
28797 wxPyEndAllowThreads(__tstate);
28798 if (PyErr_Occurred()) SWIG_fail;
28799 }
28800 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
28801 return resultobj;
28802 fail:
28803 return NULL;
28804 }
28805
28806
28807 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28808 PyObject *resultobj = 0;
28809 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28810 void *argp1 = 0 ;
28811 int res1 = 0 ;
28812 PyObject *swig_obj[1] ;
28813
28814 if (!args) SWIG_fail;
28815 swig_obj[0] = args;
28816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28817 if (!SWIG_IsOK(res1)) {
28818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28819 }
28820 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28821 {
28822 PyThreadState* __tstate = wxPyBeginAllowThreads();
28823 delete arg1;
28824
28825 wxPyEndAllowThreads(__tstate);
28826 if (PyErr_Occurred()) SWIG_fail;
28827 }
28828 resultobj = SWIG_Py_Void();
28829 return resultobj;
28830 fail:
28831 return NULL;
28832 }
28833
28834
28835 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28836 PyObject *resultobj = 0;
28837 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28838 wxTimeSpan *arg2 = 0 ;
28839 wxTimeSpan *result = 0 ;
28840 void *argp1 = 0 ;
28841 int res1 = 0 ;
28842 void *argp2 = 0 ;
28843 int res2 = 0 ;
28844 PyObject * obj0 = 0 ;
28845 PyObject * obj1 = 0 ;
28846 char * kwnames[] = {
28847 (char *) "self",(char *) "diff", NULL
28848 };
28849
28850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
28851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28852 if (!SWIG_IsOK(res1)) {
28853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28854 }
28855 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28856 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28857 if (!SWIG_IsOK(res2)) {
28858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28859 }
28860 if (!argp2) {
28861 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28862 }
28863 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28864 {
28865 PyThreadState* __tstate = wxPyBeginAllowThreads();
28866 {
28867 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
28868 result = (wxTimeSpan *) &_result_ref;
28869 }
28870 wxPyEndAllowThreads(__tstate);
28871 if (PyErr_Occurred()) SWIG_fail;
28872 }
28873 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28874 return resultobj;
28875 fail:
28876 return NULL;
28877 }
28878
28879
28880 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28881 PyObject *resultobj = 0;
28882 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28883 wxTimeSpan *arg2 = 0 ;
28884 wxTimeSpan *result = 0 ;
28885 void *argp1 = 0 ;
28886 int res1 = 0 ;
28887 void *argp2 = 0 ;
28888 int res2 = 0 ;
28889 PyObject * obj0 = 0 ;
28890 PyObject * obj1 = 0 ;
28891 char * kwnames[] = {
28892 (char *) "self",(char *) "diff", NULL
28893 };
28894
28895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
28896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28897 if (!SWIG_IsOK(res1)) {
28898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28899 }
28900 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28901 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28902 if (!SWIG_IsOK(res2)) {
28903 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28904 }
28905 if (!argp2) {
28906 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28907 }
28908 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28909 {
28910 PyThreadState* __tstate = wxPyBeginAllowThreads();
28911 {
28912 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
28913 result = (wxTimeSpan *) &_result_ref;
28914 }
28915 wxPyEndAllowThreads(__tstate);
28916 if (PyErr_Occurred()) SWIG_fail;
28917 }
28918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28919 return resultobj;
28920 fail:
28921 return NULL;
28922 }
28923
28924
28925 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28926 PyObject *resultobj = 0;
28927 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28928 int arg2 ;
28929 wxTimeSpan *result = 0 ;
28930 void *argp1 = 0 ;
28931 int res1 = 0 ;
28932 int val2 ;
28933 int ecode2 = 0 ;
28934 PyObject * obj0 = 0 ;
28935 PyObject * obj1 = 0 ;
28936 char * kwnames[] = {
28937 (char *) "self",(char *) "n", NULL
28938 };
28939
28940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
28941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28942 if (!SWIG_IsOK(res1)) {
28943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28944 }
28945 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28946 ecode2 = SWIG_AsVal_int(obj1, &val2);
28947 if (!SWIG_IsOK(ecode2)) {
28948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
28949 }
28950 arg2 = static_cast< int >(val2);
28951 {
28952 PyThreadState* __tstate = wxPyBeginAllowThreads();
28953 {
28954 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
28955 result = (wxTimeSpan *) &_result_ref;
28956 }
28957 wxPyEndAllowThreads(__tstate);
28958 if (PyErr_Occurred()) SWIG_fail;
28959 }
28960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28961 return resultobj;
28962 fail:
28963 return NULL;
28964 }
28965
28966
28967 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28968 PyObject *resultobj = 0;
28969 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28970 wxTimeSpan *result = 0 ;
28971 void *argp1 = 0 ;
28972 int res1 = 0 ;
28973 PyObject *swig_obj[1] ;
28974
28975 if (!args) SWIG_fail;
28976 swig_obj[0] = args;
28977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28978 if (!SWIG_IsOK(res1)) {
28979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28980 }
28981 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28982 {
28983 PyThreadState* __tstate = wxPyBeginAllowThreads();
28984 {
28985 wxTimeSpan &_result_ref = (arg1)->Neg();
28986 result = (wxTimeSpan *) &_result_ref;
28987 }
28988 wxPyEndAllowThreads(__tstate);
28989 if (PyErr_Occurred()) SWIG_fail;
28990 }
28991 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28992 return resultobj;
28993 fail:
28994 return NULL;
28995 }
28996
28997
28998 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28999 PyObject *resultobj = 0;
29000 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29001 wxTimeSpan result;
29002 void *argp1 = 0 ;
29003 int res1 = 0 ;
29004 PyObject *swig_obj[1] ;
29005
29006 if (!args) SWIG_fail;
29007 swig_obj[0] = args;
29008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29009 if (!SWIG_IsOK(res1)) {
29010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29011 }
29012 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29013 {
29014 PyThreadState* __tstate = wxPyBeginAllowThreads();
29015 result = ((wxTimeSpan const *)arg1)->Abs();
29016 wxPyEndAllowThreads(__tstate);
29017 if (PyErr_Occurred()) SWIG_fail;
29018 }
29019 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29020 return resultobj;
29021 fail:
29022 return NULL;
29023 }
29024
29025
29026 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29027 PyObject *resultobj = 0;
29028 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29029 wxTimeSpan *arg2 = 0 ;
29030 wxTimeSpan *result = 0 ;
29031 void *argp1 = 0 ;
29032 int res1 = 0 ;
29033 void *argp2 = 0 ;
29034 int res2 = 0 ;
29035 PyObject * obj0 = 0 ;
29036 PyObject * obj1 = 0 ;
29037 char * kwnames[] = {
29038 (char *) "self",(char *) "diff", NULL
29039 };
29040
29041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29043 if (!SWIG_IsOK(res1)) {
29044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29045 }
29046 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29047 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29048 if (!SWIG_IsOK(res2)) {
29049 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29050 }
29051 if (!argp2) {
29052 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29053 }
29054 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29055 {
29056 PyThreadState* __tstate = wxPyBeginAllowThreads();
29057 {
29058 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29059 result = (wxTimeSpan *) &_result_ref;
29060 }
29061 wxPyEndAllowThreads(__tstate);
29062 if (PyErr_Occurred()) SWIG_fail;
29063 }
29064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29065 return resultobj;
29066 fail:
29067 return NULL;
29068 }
29069
29070
29071 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29072 PyObject *resultobj = 0;
29073 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29074 wxTimeSpan *arg2 = 0 ;
29075 wxTimeSpan *result = 0 ;
29076 void *argp1 = 0 ;
29077 int res1 = 0 ;
29078 void *argp2 = 0 ;
29079 int res2 = 0 ;
29080 PyObject * obj0 = 0 ;
29081 PyObject * obj1 = 0 ;
29082 char * kwnames[] = {
29083 (char *) "self",(char *) "diff", NULL
29084 };
29085
29086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29088 if (!SWIG_IsOK(res1)) {
29089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29090 }
29091 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29092 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29093 if (!SWIG_IsOK(res2)) {
29094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29095 }
29096 if (!argp2) {
29097 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29098 }
29099 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29100 {
29101 PyThreadState* __tstate = wxPyBeginAllowThreads();
29102 {
29103 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29104 result = (wxTimeSpan *) &_result_ref;
29105 }
29106 wxPyEndAllowThreads(__tstate);
29107 if (PyErr_Occurred()) SWIG_fail;
29108 }
29109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29110 return resultobj;
29111 fail:
29112 return NULL;
29113 }
29114
29115
29116 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29117 PyObject *resultobj = 0;
29118 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29119 int arg2 ;
29120 wxTimeSpan *result = 0 ;
29121 void *argp1 = 0 ;
29122 int res1 = 0 ;
29123 int val2 ;
29124 int ecode2 = 0 ;
29125 PyObject * obj0 = 0 ;
29126 PyObject * obj1 = 0 ;
29127 char * kwnames[] = {
29128 (char *) "self",(char *) "n", NULL
29129 };
29130
29131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29133 if (!SWIG_IsOK(res1)) {
29134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29135 }
29136 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29137 ecode2 = SWIG_AsVal_int(obj1, &val2);
29138 if (!SWIG_IsOK(ecode2)) {
29139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29140 }
29141 arg2 = static_cast< int >(val2);
29142 {
29143 PyThreadState* __tstate = wxPyBeginAllowThreads();
29144 {
29145 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29146 result = (wxTimeSpan *) &_result_ref;
29147 }
29148 wxPyEndAllowThreads(__tstate);
29149 if (PyErr_Occurred()) SWIG_fail;
29150 }
29151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29152 return resultobj;
29153 fail:
29154 return NULL;
29155 }
29156
29157
29158 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29159 PyObject *resultobj = 0;
29160 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29161 wxTimeSpan *result = 0 ;
29162 void *argp1 = 0 ;
29163 int res1 = 0 ;
29164 PyObject *swig_obj[1] ;
29165
29166 if (!args) SWIG_fail;
29167 swig_obj[0] = args;
29168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29169 if (!SWIG_IsOK(res1)) {
29170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29171 }
29172 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29173 {
29174 PyThreadState* __tstate = wxPyBeginAllowThreads();
29175 {
29176 wxTimeSpan &_result_ref = (arg1)->operator -();
29177 result = (wxTimeSpan *) &_result_ref;
29178 }
29179 wxPyEndAllowThreads(__tstate);
29180 if (PyErr_Occurred()) SWIG_fail;
29181 }
29182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29183 return resultobj;
29184 fail:
29185 return NULL;
29186 }
29187
29188
29189 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29190 PyObject *resultobj = 0;
29191 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29192 wxTimeSpan *arg2 = 0 ;
29193 wxTimeSpan result;
29194 void *argp1 = 0 ;
29195 int res1 = 0 ;
29196 void *argp2 = 0 ;
29197 int res2 = 0 ;
29198 PyObject * obj0 = 0 ;
29199 PyObject * obj1 = 0 ;
29200 char * kwnames[] = {
29201 (char *) "self",(char *) "other", NULL
29202 };
29203
29204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29206 if (!SWIG_IsOK(res1)) {
29207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29208 }
29209 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29210 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29211 if (!SWIG_IsOK(res2)) {
29212 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29213 }
29214 if (!argp2) {
29215 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29216 }
29217 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29218 {
29219 PyThreadState* __tstate = wxPyBeginAllowThreads();
29220 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29221 wxPyEndAllowThreads(__tstate);
29222 if (PyErr_Occurred()) SWIG_fail;
29223 }
29224 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29225 return resultobj;
29226 fail:
29227 return NULL;
29228 }
29229
29230
29231 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29232 PyObject *resultobj = 0;
29233 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29234 wxTimeSpan *arg2 = 0 ;
29235 wxTimeSpan result;
29236 void *argp1 = 0 ;
29237 int res1 = 0 ;
29238 void *argp2 = 0 ;
29239 int res2 = 0 ;
29240 PyObject * obj0 = 0 ;
29241 PyObject * obj1 = 0 ;
29242 char * kwnames[] = {
29243 (char *) "self",(char *) "other", NULL
29244 };
29245
29246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29248 if (!SWIG_IsOK(res1)) {
29249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29250 }
29251 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29252 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29253 if (!SWIG_IsOK(res2)) {
29254 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29255 }
29256 if (!argp2) {
29257 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29258 }
29259 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29260 {
29261 PyThreadState* __tstate = wxPyBeginAllowThreads();
29262 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29263 wxPyEndAllowThreads(__tstate);
29264 if (PyErr_Occurred()) SWIG_fail;
29265 }
29266 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29267 return resultobj;
29268 fail:
29269 return NULL;
29270 }
29271
29272
29273 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29274 PyObject *resultobj = 0;
29275 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29276 int arg2 ;
29277 wxTimeSpan result;
29278 void *argp1 = 0 ;
29279 int res1 = 0 ;
29280 int val2 ;
29281 int ecode2 = 0 ;
29282 PyObject * obj0 = 0 ;
29283 PyObject * obj1 = 0 ;
29284 char * kwnames[] = {
29285 (char *) "self",(char *) "n", NULL
29286 };
29287
29288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29290 if (!SWIG_IsOK(res1)) {
29291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29292 }
29293 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29294 ecode2 = SWIG_AsVal_int(obj1, &val2);
29295 if (!SWIG_IsOK(ecode2)) {
29296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29297 }
29298 arg2 = static_cast< int >(val2);
29299 {
29300 PyThreadState* __tstate = wxPyBeginAllowThreads();
29301 result = wxTimeSpan___mul__(arg1,arg2);
29302 wxPyEndAllowThreads(__tstate);
29303 if (PyErr_Occurred()) SWIG_fail;
29304 }
29305 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29306 return resultobj;
29307 fail:
29308 return NULL;
29309 }
29310
29311
29312 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29313 PyObject *resultobj = 0;
29314 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29315 int arg2 ;
29316 wxTimeSpan result;
29317 void *argp1 = 0 ;
29318 int res1 = 0 ;
29319 int val2 ;
29320 int ecode2 = 0 ;
29321 PyObject * obj0 = 0 ;
29322 PyObject * obj1 = 0 ;
29323 char * kwnames[] = {
29324 (char *) "self",(char *) "n", NULL
29325 };
29326
29327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29329 if (!SWIG_IsOK(res1)) {
29330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29331 }
29332 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29333 ecode2 = SWIG_AsVal_int(obj1, &val2);
29334 if (!SWIG_IsOK(ecode2)) {
29335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29336 }
29337 arg2 = static_cast< int >(val2);
29338 {
29339 PyThreadState* __tstate = wxPyBeginAllowThreads();
29340 result = wxTimeSpan___rmul__(arg1,arg2);
29341 wxPyEndAllowThreads(__tstate);
29342 if (PyErr_Occurred()) SWIG_fail;
29343 }
29344 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29345 return resultobj;
29346 fail:
29347 return NULL;
29348 }
29349
29350
29351 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29352 PyObject *resultobj = 0;
29353 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29354 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29355 bool result;
29356 void *argp1 = 0 ;
29357 int res1 = 0 ;
29358 void *argp2 = 0 ;
29359 int res2 = 0 ;
29360 PyObject * obj0 = 0 ;
29361 PyObject * obj1 = 0 ;
29362 char * kwnames[] = {
29363 (char *) "self",(char *) "other", NULL
29364 };
29365
29366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29368 if (!SWIG_IsOK(res1)) {
29369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29370 }
29371 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29372 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29373 if (!SWIG_IsOK(res2)) {
29374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29375 }
29376 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29377 {
29378 PyThreadState* __tstate = wxPyBeginAllowThreads();
29379 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29380 wxPyEndAllowThreads(__tstate);
29381 if (PyErr_Occurred()) SWIG_fail;
29382 }
29383 {
29384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29385 }
29386 return resultobj;
29387 fail:
29388 return NULL;
29389 }
29390
29391
29392 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29393 PyObject *resultobj = 0;
29394 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29395 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29396 bool result;
29397 void *argp1 = 0 ;
29398 int res1 = 0 ;
29399 void *argp2 = 0 ;
29400 int res2 = 0 ;
29401 PyObject * obj0 = 0 ;
29402 PyObject * obj1 = 0 ;
29403 char * kwnames[] = {
29404 (char *) "self",(char *) "other", NULL
29405 };
29406
29407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29409 if (!SWIG_IsOK(res1)) {
29410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29411 }
29412 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29413 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29414 if (!SWIG_IsOK(res2)) {
29415 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29416 }
29417 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29418 {
29419 PyThreadState* __tstate = wxPyBeginAllowThreads();
29420 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29421 wxPyEndAllowThreads(__tstate);
29422 if (PyErr_Occurred()) SWIG_fail;
29423 }
29424 {
29425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29426 }
29427 return resultobj;
29428 fail:
29429 return NULL;
29430 }
29431
29432
29433 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29434 PyObject *resultobj = 0;
29435 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29436 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29437 bool result;
29438 void *argp1 = 0 ;
29439 int res1 = 0 ;
29440 void *argp2 = 0 ;
29441 int res2 = 0 ;
29442 PyObject * obj0 = 0 ;
29443 PyObject * obj1 = 0 ;
29444 char * kwnames[] = {
29445 (char *) "self",(char *) "other", NULL
29446 };
29447
29448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29450 if (!SWIG_IsOK(res1)) {
29451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29452 }
29453 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29454 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29455 if (!SWIG_IsOK(res2)) {
29456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29457 }
29458 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29459 {
29460 PyThreadState* __tstate = wxPyBeginAllowThreads();
29461 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29462 wxPyEndAllowThreads(__tstate);
29463 if (PyErr_Occurred()) SWIG_fail;
29464 }
29465 {
29466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29467 }
29468 return resultobj;
29469 fail:
29470 return NULL;
29471 }
29472
29473
29474 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29475 PyObject *resultobj = 0;
29476 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29477 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29478 bool result;
29479 void *argp1 = 0 ;
29480 int res1 = 0 ;
29481 void *argp2 = 0 ;
29482 int res2 = 0 ;
29483 PyObject * obj0 = 0 ;
29484 PyObject * obj1 = 0 ;
29485 char * kwnames[] = {
29486 (char *) "self",(char *) "other", NULL
29487 };
29488
29489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29491 if (!SWIG_IsOK(res1)) {
29492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29493 }
29494 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29495 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29496 if (!SWIG_IsOK(res2)) {
29497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29498 }
29499 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29500 {
29501 PyThreadState* __tstate = wxPyBeginAllowThreads();
29502 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29503 wxPyEndAllowThreads(__tstate);
29504 if (PyErr_Occurred()) SWIG_fail;
29505 }
29506 {
29507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29508 }
29509 return resultobj;
29510 fail:
29511 return NULL;
29512 }
29513
29514
29515 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29516 PyObject *resultobj = 0;
29517 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29518 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29519 bool result;
29520 void *argp1 = 0 ;
29521 int res1 = 0 ;
29522 void *argp2 = 0 ;
29523 int res2 = 0 ;
29524 PyObject * obj0 = 0 ;
29525 PyObject * obj1 = 0 ;
29526 char * kwnames[] = {
29527 (char *) "self",(char *) "other", NULL
29528 };
29529
29530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29532 if (!SWIG_IsOK(res1)) {
29533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29534 }
29535 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29536 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29537 if (!SWIG_IsOK(res2)) {
29538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29539 }
29540 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29541 {
29542 PyThreadState* __tstate = wxPyBeginAllowThreads();
29543 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29544 wxPyEndAllowThreads(__tstate);
29545 if (PyErr_Occurred()) SWIG_fail;
29546 }
29547 {
29548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29549 }
29550 return resultobj;
29551 fail:
29552 return NULL;
29553 }
29554
29555
29556 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29557 PyObject *resultobj = 0;
29558 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29559 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29560 bool result;
29561 void *argp1 = 0 ;
29562 int res1 = 0 ;
29563 void *argp2 = 0 ;
29564 int res2 = 0 ;
29565 PyObject * obj0 = 0 ;
29566 PyObject * obj1 = 0 ;
29567 char * kwnames[] = {
29568 (char *) "self",(char *) "other", NULL
29569 };
29570
29571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29573 if (!SWIG_IsOK(res1)) {
29574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29575 }
29576 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29577 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29578 if (!SWIG_IsOK(res2)) {
29579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29580 }
29581 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29582 {
29583 PyThreadState* __tstate = wxPyBeginAllowThreads();
29584 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29585 wxPyEndAllowThreads(__tstate);
29586 if (PyErr_Occurred()) SWIG_fail;
29587 }
29588 {
29589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29590 }
29591 return resultobj;
29592 fail:
29593 return NULL;
29594 }
29595
29596
29597 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29598 PyObject *resultobj = 0;
29599 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29600 bool result;
29601 void *argp1 = 0 ;
29602 int res1 = 0 ;
29603 PyObject *swig_obj[1] ;
29604
29605 if (!args) SWIG_fail;
29606 swig_obj[0] = args;
29607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29608 if (!SWIG_IsOK(res1)) {
29609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29610 }
29611 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29612 {
29613 PyThreadState* __tstate = wxPyBeginAllowThreads();
29614 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29615 wxPyEndAllowThreads(__tstate);
29616 if (PyErr_Occurred()) SWIG_fail;
29617 }
29618 {
29619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29620 }
29621 return resultobj;
29622 fail:
29623 return NULL;
29624 }
29625
29626
29627 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29628 PyObject *resultobj = 0;
29629 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29630 bool result;
29631 void *argp1 = 0 ;
29632 int res1 = 0 ;
29633 PyObject *swig_obj[1] ;
29634
29635 if (!args) SWIG_fail;
29636 swig_obj[0] = args;
29637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29638 if (!SWIG_IsOK(res1)) {
29639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29640 }
29641 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29642 {
29643 PyThreadState* __tstate = wxPyBeginAllowThreads();
29644 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29645 wxPyEndAllowThreads(__tstate);
29646 if (PyErr_Occurred()) SWIG_fail;
29647 }
29648 {
29649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29650 }
29651 return resultobj;
29652 fail:
29653 return NULL;
29654 }
29655
29656
29657 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29658 PyObject *resultobj = 0;
29659 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29660 bool result;
29661 void *argp1 = 0 ;
29662 int res1 = 0 ;
29663 PyObject *swig_obj[1] ;
29664
29665 if (!args) SWIG_fail;
29666 swig_obj[0] = args;
29667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29668 if (!SWIG_IsOK(res1)) {
29669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29670 }
29671 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29672 {
29673 PyThreadState* __tstate = wxPyBeginAllowThreads();
29674 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29675 wxPyEndAllowThreads(__tstate);
29676 if (PyErr_Occurred()) SWIG_fail;
29677 }
29678 {
29679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29680 }
29681 return resultobj;
29682 fail:
29683 return NULL;
29684 }
29685
29686
29687 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29688 PyObject *resultobj = 0;
29689 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29690 wxTimeSpan *arg2 = 0 ;
29691 bool result;
29692 void *argp1 = 0 ;
29693 int res1 = 0 ;
29694 void *argp2 = 0 ;
29695 int res2 = 0 ;
29696 PyObject * obj0 = 0 ;
29697 PyObject * obj1 = 0 ;
29698 char * kwnames[] = {
29699 (char *) "self",(char *) "ts", NULL
29700 };
29701
29702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29704 if (!SWIG_IsOK(res1)) {
29705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29706 }
29707 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29708 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29709 if (!SWIG_IsOK(res2)) {
29710 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29711 }
29712 if (!argp2) {
29713 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29714 }
29715 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29716 {
29717 PyThreadState* __tstate = wxPyBeginAllowThreads();
29718 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29719 wxPyEndAllowThreads(__tstate);
29720 if (PyErr_Occurred()) SWIG_fail;
29721 }
29722 {
29723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29724 }
29725 return resultobj;
29726 fail:
29727 return NULL;
29728 }
29729
29730
29731 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29732 PyObject *resultobj = 0;
29733 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29734 wxTimeSpan *arg2 = 0 ;
29735 bool result;
29736 void *argp1 = 0 ;
29737 int res1 = 0 ;
29738 void *argp2 = 0 ;
29739 int res2 = 0 ;
29740 PyObject * obj0 = 0 ;
29741 PyObject * obj1 = 0 ;
29742 char * kwnames[] = {
29743 (char *) "self",(char *) "ts", NULL
29744 };
29745
29746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29748 if (!SWIG_IsOK(res1)) {
29749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29750 }
29751 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29752 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29753 if (!SWIG_IsOK(res2)) {
29754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29755 }
29756 if (!argp2) {
29757 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29758 }
29759 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29760 {
29761 PyThreadState* __tstate = wxPyBeginAllowThreads();
29762 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29763 wxPyEndAllowThreads(__tstate);
29764 if (PyErr_Occurred()) SWIG_fail;
29765 }
29766 {
29767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29768 }
29769 return resultobj;
29770 fail:
29771 return NULL;
29772 }
29773
29774
29775 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29776 PyObject *resultobj = 0;
29777 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29778 wxTimeSpan *arg2 = 0 ;
29779 bool result;
29780 void *argp1 = 0 ;
29781 int res1 = 0 ;
29782 void *argp2 = 0 ;
29783 int res2 = 0 ;
29784 PyObject * obj0 = 0 ;
29785 PyObject * obj1 = 0 ;
29786 char * kwnames[] = {
29787 (char *) "self",(char *) "t", NULL
29788 };
29789
29790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29792 if (!SWIG_IsOK(res1)) {
29793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29794 }
29795 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29796 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29797 if (!SWIG_IsOK(res2)) {
29798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29799 }
29800 if (!argp2) {
29801 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29802 }
29803 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29804 {
29805 PyThreadState* __tstate = wxPyBeginAllowThreads();
29806 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
29807 wxPyEndAllowThreads(__tstate);
29808 if (PyErr_Occurred()) SWIG_fail;
29809 }
29810 {
29811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29812 }
29813 return resultobj;
29814 fail:
29815 return NULL;
29816 }
29817
29818
29819 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29820 PyObject *resultobj = 0;
29821 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29822 int result;
29823 void *argp1 = 0 ;
29824 int res1 = 0 ;
29825 PyObject *swig_obj[1] ;
29826
29827 if (!args) SWIG_fail;
29828 swig_obj[0] = args;
29829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29830 if (!SWIG_IsOK(res1)) {
29831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29832 }
29833 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29834 {
29835 PyThreadState* __tstate = wxPyBeginAllowThreads();
29836 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
29837 wxPyEndAllowThreads(__tstate);
29838 if (PyErr_Occurred()) SWIG_fail;
29839 }
29840 resultobj = SWIG_From_int(static_cast< int >(result));
29841 return resultobj;
29842 fail:
29843 return NULL;
29844 }
29845
29846
29847 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29848 PyObject *resultobj = 0;
29849 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29850 int result;
29851 void *argp1 = 0 ;
29852 int res1 = 0 ;
29853 PyObject *swig_obj[1] ;
29854
29855 if (!args) SWIG_fail;
29856 swig_obj[0] = args;
29857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29858 if (!SWIG_IsOK(res1)) {
29859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29860 }
29861 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29862 {
29863 PyThreadState* __tstate = wxPyBeginAllowThreads();
29864 result = (int)((wxTimeSpan const *)arg1)->GetDays();
29865 wxPyEndAllowThreads(__tstate);
29866 if (PyErr_Occurred()) SWIG_fail;
29867 }
29868 resultobj = SWIG_From_int(static_cast< int >(result));
29869 return resultobj;
29870 fail:
29871 return NULL;
29872 }
29873
29874
29875 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29876 PyObject *resultobj = 0;
29877 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29878 int result;
29879 void *argp1 = 0 ;
29880 int res1 = 0 ;
29881 PyObject *swig_obj[1] ;
29882
29883 if (!args) SWIG_fail;
29884 swig_obj[0] = args;
29885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29886 if (!SWIG_IsOK(res1)) {
29887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29888 }
29889 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29890 {
29891 PyThreadState* __tstate = wxPyBeginAllowThreads();
29892 result = (int)((wxTimeSpan const *)arg1)->GetHours();
29893 wxPyEndAllowThreads(__tstate);
29894 if (PyErr_Occurred()) SWIG_fail;
29895 }
29896 resultobj = SWIG_From_int(static_cast< int >(result));
29897 return resultobj;
29898 fail:
29899 return NULL;
29900 }
29901
29902
29903 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29904 PyObject *resultobj = 0;
29905 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29906 int result;
29907 void *argp1 = 0 ;
29908 int res1 = 0 ;
29909 PyObject *swig_obj[1] ;
29910
29911 if (!args) SWIG_fail;
29912 swig_obj[0] = args;
29913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29914 if (!SWIG_IsOK(res1)) {
29915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29916 }
29917 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29918 {
29919 PyThreadState* __tstate = wxPyBeginAllowThreads();
29920 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
29921 wxPyEndAllowThreads(__tstate);
29922 if (PyErr_Occurred()) SWIG_fail;
29923 }
29924 resultobj = SWIG_From_int(static_cast< int >(result));
29925 return resultobj;
29926 fail:
29927 return NULL;
29928 }
29929
29930
29931 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29932 PyObject *resultobj = 0;
29933 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29934 wxLongLong result;
29935 void *argp1 = 0 ;
29936 int res1 = 0 ;
29937 PyObject *swig_obj[1] ;
29938
29939 if (!args) SWIG_fail;
29940 swig_obj[0] = args;
29941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29942 if (!SWIG_IsOK(res1)) {
29943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29944 }
29945 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29946 {
29947 PyThreadState* __tstate = wxPyBeginAllowThreads();
29948 result = ((wxTimeSpan const *)arg1)->GetSeconds();
29949 wxPyEndAllowThreads(__tstate);
29950 if (PyErr_Occurred()) SWIG_fail;
29951 }
29952 {
29953 PyObject *hi, *lo, *shifter, *shifted;
29954 hi = PyLong_FromLong( (&result)->GetHi() );
29955 lo = PyLong_FromLong( (&result)->GetLo() );
29956 shifter = PyLong_FromLong(32);
29957 shifted = PyNumber_Lshift(hi, shifter);
29958 resultobj = PyNumber_Or(shifted, lo);
29959 Py_DECREF(hi);
29960 Py_DECREF(lo);
29961 Py_DECREF(shifter);
29962 Py_DECREF(shifted);
29963 }
29964 return resultobj;
29965 fail:
29966 return NULL;
29967 }
29968
29969
29970 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29971 PyObject *resultobj = 0;
29972 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29973 wxLongLong result;
29974 void *argp1 = 0 ;
29975 int res1 = 0 ;
29976 PyObject *swig_obj[1] ;
29977
29978 if (!args) SWIG_fail;
29979 swig_obj[0] = args;
29980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29981 if (!SWIG_IsOK(res1)) {
29982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29983 }
29984 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29985 {
29986 PyThreadState* __tstate = wxPyBeginAllowThreads();
29987 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
29988 wxPyEndAllowThreads(__tstate);
29989 if (PyErr_Occurred()) SWIG_fail;
29990 }
29991 {
29992 PyObject *hi, *lo, *shifter, *shifted;
29993 hi = PyLong_FromLong( (&result)->GetHi() );
29994 lo = PyLong_FromLong( (&result)->GetLo() );
29995 shifter = PyLong_FromLong(32);
29996 shifted = PyNumber_Lshift(hi, shifter);
29997 resultobj = PyNumber_Or(shifted, lo);
29998 Py_DECREF(hi);
29999 Py_DECREF(lo);
30000 Py_DECREF(shifter);
30001 Py_DECREF(shifted);
30002 }
30003 return resultobj;
30004 fail:
30005 return NULL;
30006 }
30007
30008
30009 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30010 PyObject *resultobj = 0;
30011 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30012 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30013 wxString *arg2 = (wxString *) &arg2_defvalue ;
30014 wxString result;
30015 void *argp1 = 0 ;
30016 int res1 = 0 ;
30017 bool temp2 = false ;
30018 PyObject * obj0 = 0 ;
30019 PyObject * obj1 = 0 ;
30020 char * kwnames[] = {
30021 (char *) "self",(char *) "format", NULL
30022 };
30023
30024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30026 if (!SWIG_IsOK(res1)) {
30027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30028 }
30029 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30030 if (obj1) {
30031 {
30032 arg2 = wxString_in_helper(obj1);
30033 if (arg2 == NULL) SWIG_fail;
30034 temp2 = true;
30035 }
30036 }
30037 {
30038 PyThreadState* __tstate = wxPyBeginAllowThreads();
30039 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30040 wxPyEndAllowThreads(__tstate);
30041 if (PyErr_Occurred()) SWIG_fail;
30042 }
30043 {
30044 #if wxUSE_UNICODE
30045 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30046 #else
30047 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30048 #endif
30049 }
30050 {
30051 if (temp2)
30052 delete arg2;
30053 }
30054 return resultobj;
30055 fail:
30056 {
30057 if (temp2)
30058 delete arg2;
30059 }
30060 return NULL;
30061 }
30062
30063
30064 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30065 PyObject *obj;
30066 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30067 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30068 return SWIG_Py_Void();
30069 }
30070
30071 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30072 return SWIG_Python_InitShadowInstance(args);
30073 }
30074
30075 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30076 PyObject *resultobj = 0;
30077 int arg1 = (int) 0 ;
30078 int arg2 = (int) 0 ;
30079 int arg3 = (int) 0 ;
30080 int arg4 = (int) 0 ;
30081 wxDateSpan *result = 0 ;
30082 int val1 ;
30083 int ecode1 = 0 ;
30084 int val2 ;
30085 int ecode2 = 0 ;
30086 int val3 ;
30087 int ecode3 = 0 ;
30088 int val4 ;
30089 int ecode4 = 0 ;
30090 PyObject * obj0 = 0 ;
30091 PyObject * obj1 = 0 ;
30092 PyObject * obj2 = 0 ;
30093 PyObject * obj3 = 0 ;
30094 char * kwnames[] = {
30095 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30096 };
30097
30098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30099 if (obj0) {
30100 ecode1 = SWIG_AsVal_int(obj0, &val1);
30101 if (!SWIG_IsOK(ecode1)) {
30102 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30103 }
30104 arg1 = static_cast< int >(val1);
30105 }
30106 if (obj1) {
30107 ecode2 = SWIG_AsVal_int(obj1, &val2);
30108 if (!SWIG_IsOK(ecode2)) {
30109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30110 }
30111 arg2 = static_cast< int >(val2);
30112 }
30113 if (obj2) {
30114 ecode3 = SWIG_AsVal_int(obj2, &val3);
30115 if (!SWIG_IsOK(ecode3)) {
30116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30117 }
30118 arg3 = static_cast< int >(val3);
30119 }
30120 if (obj3) {
30121 ecode4 = SWIG_AsVal_int(obj3, &val4);
30122 if (!SWIG_IsOK(ecode4)) {
30123 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30124 }
30125 arg4 = static_cast< int >(val4);
30126 }
30127 {
30128 PyThreadState* __tstate = wxPyBeginAllowThreads();
30129 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30130 wxPyEndAllowThreads(__tstate);
30131 if (PyErr_Occurred()) SWIG_fail;
30132 }
30133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30134 return resultobj;
30135 fail:
30136 return NULL;
30137 }
30138
30139
30140 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30141 PyObject *resultobj = 0;
30142 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30143 void *argp1 = 0 ;
30144 int res1 = 0 ;
30145 PyObject *swig_obj[1] ;
30146
30147 if (!args) SWIG_fail;
30148 swig_obj[0] = args;
30149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30150 if (!SWIG_IsOK(res1)) {
30151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30152 }
30153 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30154 {
30155 PyThreadState* __tstate = wxPyBeginAllowThreads();
30156 delete arg1;
30157
30158 wxPyEndAllowThreads(__tstate);
30159 if (PyErr_Occurred()) SWIG_fail;
30160 }
30161 resultobj = SWIG_Py_Void();
30162 return resultobj;
30163 fail:
30164 return NULL;
30165 }
30166
30167
30168 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30169 PyObject *resultobj = 0;
30170 int arg1 ;
30171 wxDateSpan result;
30172 int val1 ;
30173 int ecode1 = 0 ;
30174 PyObject * obj0 = 0 ;
30175 char * kwnames[] = {
30176 (char *) "days", NULL
30177 };
30178
30179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30180 ecode1 = SWIG_AsVal_int(obj0, &val1);
30181 if (!SWIG_IsOK(ecode1)) {
30182 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30183 }
30184 arg1 = static_cast< int >(val1);
30185 {
30186 PyThreadState* __tstate = wxPyBeginAllowThreads();
30187 result = wxDateSpan::Days(arg1);
30188 wxPyEndAllowThreads(__tstate);
30189 if (PyErr_Occurred()) SWIG_fail;
30190 }
30191 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30192 return resultobj;
30193 fail:
30194 return NULL;
30195 }
30196
30197
30198 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30199 PyObject *resultobj = 0;
30200 wxDateSpan result;
30201
30202 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30203 {
30204 PyThreadState* __tstate = wxPyBeginAllowThreads();
30205 result = wxDateSpan::Day();
30206 wxPyEndAllowThreads(__tstate);
30207 if (PyErr_Occurred()) SWIG_fail;
30208 }
30209 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30210 return resultobj;
30211 fail:
30212 return NULL;
30213 }
30214
30215
30216 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30217 PyObject *resultobj = 0;
30218 int arg1 ;
30219 wxDateSpan result;
30220 int val1 ;
30221 int ecode1 = 0 ;
30222 PyObject * obj0 = 0 ;
30223 char * kwnames[] = {
30224 (char *) "weeks", NULL
30225 };
30226
30227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30228 ecode1 = SWIG_AsVal_int(obj0, &val1);
30229 if (!SWIG_IsOK(ecode1)) {
30230 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30231 }
30232 arg1 = static_cast< int >(val1);
30233 {
30234 PyThreadState* __tstate = wxPyBeginAllowThreads();
30235 result = wxDateSpan::Weeks(arg1);
30236 wxPyEndAllowThreads(__tstate);
30237 if (PyErr_Occurred()) SWIG_fail;
30238 }
30239 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30240 return resultobj;
30241 fail:
30242 return NULL;
30243 }
30244
30245
30246 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30247 PyObject *resultobj = 0;
30248 wxDateSpan result;
30249
30250 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30251 {
30252 PyThreadState* __tstate = wxPyBeginAllowThreads();
30253 result = wxDateSpan::Week();
30254 wxPyEndAllowThreads(__tstate);
30255 if (PyErr_Occurred()) SWIG_fail;
30256 }
30257 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30258 return resultobj;
30259 fail:
30260 return NULL;
30261 }
30262
30263
30264 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30265 PyObject *resultobj = 0;
30266 int arg1 ;
30267 wxDateSpan result;
30268 int val1 ;
30269 int ecode1 = 0 ;
30270 PyObject * obj0 = 0 ;
30271 char * kwnames[] = {
30272 (char *) "mon", NULL
30273 };
30274
30275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30276 ecode1 = SWIG_AsVal_int(obj0, &val1);
30277 if (!SWIG_IsOK(ecode1)) {
30278 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30279 }
30280 arg1 = static_cast< int >(val1);
30281 {
30282 PyThreadState* __tstate = wxPyBeginAllowThreads();
30283 result = wxDateSpan::Months(arg1);
30284 wxPyEndAllowThreads(__tstate);
30285 if (PyErr_Occurred()) SWIG_fail;
30286 }
30287 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30288 return resultobj;
30289 fail:
30290 return NULL;
30291 }
30292
30293
30294 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30295 PyObject *resultobj = 0;
30296 wxDateSpan result;
30297
30298 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30299 {
30300 PyThreadState* __tstate = wxPyBeginAllowThreads();
30301 result = wxDateSpan::Month();
30302 wxPyEndAllowThreads(__tstate);
30303 if (PyErr_Occurred()) SWIG_fail;
30304 }
30305 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30306 return resultobj;
30307 fail:
30308 return NULL;
30309 }
30310
30311
30312 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30313 PyObject *resultobj = 0;
30314 int arg1 ;
30315 wxDateSpan result;
30316 int val1 ;
30317 int ecode1 = 0 ;
30318 PyObject * obj0 = 0 ;
30319 char * kwnames[] = {
30320 (char *) "years", NULL
30321 };
30322
30323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30324 ecode1 = SWIG_AsVal_int(obj0, &val1);
30325 if (!SWIG_IsOK(ecode1)) {
30326 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30327 }
30328 arg1 = static_cast< int >(val1);
30329 {
30330 PyThreadState* __tstate = wxPyBeginAllowThreads();
30331 result = wxDateSpan::Years(arg1);
30332 wxPyEndAllowThreads(__tstate);
30333 if (PyErr_Occurred()) SWIG_fail;
30334 }
30335 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30336 return resultobj;
30337 fail:
30338 return NULL;
30339 }
30340
30341
30342 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30343 PyObject *resultobj = 0;
30344 wxDateSpan result;
30345
30346 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30347 {
30348 PyThreadState* __tstate = wxPyBeginAllowThreads();
30349 result = wxDateSpan::Year();
30350 wxPyEndAllowThreads(__tstate);
30351 if (PyErr_Occurred()) SWIG_fail;
30352 }
30353 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30354 return resultobj;
30355 fail:
30356 return NULL;
30357 }
30358
30359
30360 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30361 PyObject *resultobj = 0;
30362 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30363 int arg2 ;
30364 wxDateSpan *result = 0 ;
30365 void *argp1 = 0 ;
30366 int res1 = 0 ;
30367 int val2 ;
30368 int ecode2 = 0 ;
30369 PyObject * obj0 = 0 ;
30370 PyObject * obj1 = 0 ;
30371 char * kwnames[] = {
30372 (char *) "self",(char *) "n", NULL
30373 };
30374
30375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30377 if (!SWIG_IsOK(res1)) {
30378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30379 }
30380 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30381 ecode2 = SWIG_AsVal_int(obj1, &val2);
30382 if (!SWIG_IsOK(ecode2)) {
30383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30384 }
30385 arg2 = static_cast< int >(val2);
30386 {
30387 PyThreadState* __tstate = wxPyBeginAllowThreads();
30388 {
30389 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30390 result = (wxDateSpan *) &_result_ref;
30391 }
30392 wxPyEndAllowThreads(__tstate);
30393 if (PyErr_Occurred()) SWIG_fail;
30394 }
30395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30396 return resultobj;
30397 fail:
30398 return NULL;
30399 }
30400
30401
30402 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30403 PyObject *resultobj = 0;
30404 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30405 int arg2 ;
30406 wxDateSpan *result = 0 ;
30407 void *argp1 = 0 ;
30408 int res1 = 0 ;
30409 int val2 ;
30410 int ecode2 = 0 ;
30411 PyObject * obj0 = 0 ;
30412 PyObject * obj1 = 0 ;
30413 char * kwnames[] = {
30414 (char *) "self",(char *) "n", NULL
30415 };
30416
30417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30419 if (!SWIG_IsOK(res1)) {
30420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30421 }
30422 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30423 ecode2 = SWIG_AsVal_int(obj1, &val2);
30424 if (!SWIG_IsOK(ecode2)) {
30425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30426 }
30427 arg2 = static_cast< int >(val2);
30428 {
30429 PyThreadState* __tstate = wxPyBeginAllowThreads();
30430 {
30431 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30432 result = (wxDateSpan *) &_result_ref;
30433 }
30434 wxPyEndAllowThreads(__tstate);
30435 if (PyErr_Occurred()) SWIG_fail;
30436 }
30437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30438 return resultobj;
30439 fail:
30440 return NULL;
30441 }
30442
30443
30444 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30445 PyObject *resultobj = 0;
30446 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30447 int arg2 ;
30448 wxDateSpan *result = 0 ;
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 *) "n", NULL
30457 };
30458
30459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30461 if (!SWIG_IsOK(res1)) {
30462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30463 }
30464 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30465 ecode2 = SWIG_AsVal_int(obj1, &val2);
30466 if (!SWIG_IsOK(ecode2)) {
30467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30468 }
30469 arg2 = static_cast< int >(val2);
30470 {
30471 PyThreadState* __tstate = wxPyBeginAllowThreads();
30472 {
30473 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30474 result = (wxDateSpan *) &_result_ref;
30475 }
30476 wxPyEndAllowThreads(__tstate);
30477 if (PyErr_Occurred()) SWIG_fail;
30478 }
30479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30480 return resultobj;
30481 fail:
30482 return NULL;
30483 }
30484
30485
30486 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30487 PyObject *resultobj = 0;
30488 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30489 int arg2 ;
30490 wxDateSpan *result = 0 ;
30491 void *argp1 = 0 ;
30492 int res1 = 0 ;
30493 int val2 ;
30494 int ecode2 = 0 ;
30495 PyObject * obj0 = 0 ;
30496 PyObject * obj1 = 0 ;
30497 char * kwnames[] = {
30498 (char *) "self",(char *) "n", NULL
30499 };
30500
30501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30503 if (!SWIG_IsOK(res1)) {
30504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30505 }
30506 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30507 ecode2 = SWIG_AsVal_int(obj1, &val2);
30508 if (!SWIG_IsOK(ecode2)) {
30509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30510 }
30511 arg2 = static_cast< int >(val2);
30512 {
30513 PyThreadState* __tstate = wxPyBeginAllowThreads();
30514 {
30515 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30516 result = (wxDateSpan *) &_result_ref;
30517 }
30518 wxPyEndAllowThreads(__tstate);
30519 if (PyErr_Occurred()) SWIG_fail;
30520 }
30521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30522 return resultobj;
30523 fail:
30524 return NULL;
30525 }
30526
30527
30528 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30529 PyObject *resultobj = 0;
30530 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30531 int result;
30532 void *argp1 = 0 ;
30533 int res1 = 0 ;
30534 PyObject *swig_obj[1] ;
30535
30536 if (!args) SWIG_fail;
30537 swig_obj[0] = args;
30538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30539 if (!SWIG_IsOK(res1)) {
30540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30541 }
30542 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30543 {
30544 PyThreadState* __tstate = wxPyBeginAllowThreads();
30545 result = (int)((wxDateSpan const *)arg1)->GetYears();
30546 wxPyEndAllowThreads(__tstate);
30547 if (PyErr_Occurred()) SWIG_fail;
30548 }
30549 resultobj = SWIG_From_int(static_cast< int >(result));
30550 return resultobj;
30551 fail:
30552 return NULL;
30553 }
30554
30555
30556 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30557 PyObject *resultobj = 0;
30558 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30559 int result;
30560 void *argp1 = 0 ;
30561 int res1 = 0 ;
30562 PyObject *swig_obj[1] ;
30563
30564 if (!args) SWIG_fail;
30565 swig_obj[0] = args;
30566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30567 if (!SWIG_IsOK(res1)) {
30568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30569 }
30570 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30571 {
30572 PyThreadState* __tstate = wxPyBeginAllowThreads();
30573 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30574 wxPyEndAllowThreads(__tstate);
30575 if (PyErr_Occurred()) SWIG_fail;
30576 }
30577 resultobj = SWIG_From_int(static_cast< int >(result));
30578 return resultobj;
30579 fail:
30580 return NULL;
30581 }
30582
30583
30584 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30585 PyObject *resultobj = 0;
30586 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30587 int result;
30588 void *argp1 = 0 ;
30589 int res1 = 0 ;
30590 PyObject *swig_obj[1] ;
30591
30592 if (!args) SWIG_fail;
30593 swig_obj[0] = args;
30594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30595 if (!SWIG_IsOK(res1)) {
30596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30597 }
30598 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30599 {
30600 PyThreadState* __tstate = wxPyBeginAllowThreads();
30601 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30602 wxPyEndAllowThreads(__tstate);
30603 if (PyErr_Occurred()) SWIG_fail;
30604 }
30605 resultobj = SWIG_From_int(static_cast< int >(result));
30606 return resultobj;
30607 fail:
30608 return NULL;
30609 }
30610
30611
30612 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30613 PyObject *resultobj = 0;
30614 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30615 int result;
30616 void *argp1 = 0 ;
30617 int res1 = 0 ;
30618 PyObject *swig_obj[1] ;
30619
30620 if (!args) SWIG_fail;
30621 swig_obj[0] = args;
30622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30623 if (!SWIG_IsOK(res1)) {
30624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30625 }
30626 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30627 {
30628 PyThreadState* __tstate = wxPyBeginAllowThreads();
30629 result = (int)((wxDateSpan const *)arg1)->GetDays();
30630 wxPyEndAllowThreads(__tstate);
30631 if (PyErr_Occurred()) SWIG_fail;
30632 }
30633 resultobj = SWIG_From_int(static_cast< int >(result));
30634 return resultobj;
30635 fail:
30636 return NULL;
30637 }
30638
30639
30640 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30641 PyObject *resultobj = 0;
30642 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30643 int result;
30644 void *argp1 = 0 ;
30645 int res1 = 0 ;
30646 PyObject *swig_obj[1] ;
30647
30648 if (!args) SWIG_fail;
30649 swig_obj[0] = args;
30650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30651 if (!SWIG_IsOK(res1)) {
30652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30653 }
30654 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30655 {
30656 PyThreadState* __tstate = wxPyBeginAllowThreads();
30657 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30658 wxPyEndAllowThreads(__tstate);
30659 if (PyErr_Occurred()) SWIG_fail;
30660 }
30661 resultobj = SWIG_From_int(static_cast< int >(result));
30662 return resultobj;
30663 fail:
30664 return NULL;
30665 }
30666
30667
30668 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30669 PyObject *resultobj = 0;
30670 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30671 wxDateSpan *arg2 = 0 ;
30672 wxDateSpan *result = 0 ;
30673 void *argp1 = 0 ;
30674 int res1 = 0 ;
30675 void *argp2 = 0 ;
30676 int res2 = 0 ;
30677 PyObject * obj0 = 0 ;
30678 PyObject * obj1 = 0 ;
30679 char * kwnames[] = {
30680 (char *) "self",(char *) "other", NULL
30681 };
30682
30683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30685 if (!SWIG_IsOK(res1)) {
30686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30687 }
30688 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30689 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30690 if (!SWIG_IsOK(res2)) {
30691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30692 }
30693 if (!argp2) {
30694 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30695 }
30696 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30697 {
30698 PyThreadState* __tstate = wxPyBeginAllowThreads();
30699 {
30700 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30701 result = (wxDateSpan *) &_result_ref;
30702 }
30703 wxPyEndAllowThreads(__tstate);
30704 if (PyErr_Occurred()) SWIG_fail;
30705 }
30706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30707 return resultobj;
30708 fail:
30709 return NULL;
30710 }
30711
30712
30713 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30714 PyObject *resultobj = 0;
30715 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30716 wxDateSpan *arg2 = 0 ;
30717 wxDateSpan *result = 0 ;
30718 void *argp1 = 0 ;
30719 int res1 = 0 ;
30720 void *argp2 = 0 ;
30721 int res2 = 0 ;
30722 PyObject * obj0 = 0 ;
30723 PyObject * obj1 = 0 ;
30724 char * kwnames[] = {
30725 (char *) "self",(char *) "other", NULL
30726 };
30727
30728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30730 if (!SWIG_IsOK(res1)) {
30731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30732 }
30733 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30734 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30735 if (!SWIG_IsOK(res2)) {
30736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30737 }
30738 if (!argp2) {
30739 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30740 }
30741 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30742 {
30743 PyThreadState* __tstate = wxPyBeginAllowThreads();
30744 {
30745 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30746 result = (wxDateSpan *) &_result_ref;
30747 }
30748 wxPyEndAllowThreads(__tstate);
30749 if (PyErr_Occurred()) SWIG_fail;
30750 }
30751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30752 return resultobj;
30753 fail:
30754 return NULL;
30755 }
30756
30757
30758 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30759 PyObject *resultobj = 0;
30760 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30761 wxDateSpan *result = 0 ;
30762 void *argp1 = 0 ;
30763 int res1 = 0 ;
30764 PyObject *swig_obj[1] ;
30765
30766 if (!args) SWIG_fail;
30767 swig_obj[0] = args;
30768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30769 if (!SWIG_IsOK(res1)) {
30770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30771 }
30772 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30773 {
30774 PyThreadState* __tstate = wxPyBeginAllowThreads();
30775 {
30776 wxDateSpan &_result_ref = (arg1)->Neg();
30777 result = (wxDateSpan *) &_result_ref;
30778 }
30779 wxPyEndAllowThreads(__tstate);
30780 if (PyErr_Occurred()) SWIG_fail;
30781 }
30782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30783 return resultobj;
30784 fail:
30785 return NULL;
30786 }
30787
30788
30789 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30790 PyObject *resultobj = 0;
30791 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30792 int arg2 ;
30793 wxDateSpan *result = 0 ;
30794 void *argp1 = 0 ;
30795 int res1 = 0 ;
30796 int val2 ;
30797 int ecode2 = 0 ;
30798 PyObject * obj0 = 0 ;
30799 PyObject * obj1 = 0 ;
30800 char * kwnames[] = {
30801 (char *) "self",(char *) "factor", NULL
30802 };
30803
30804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
30805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30806 if (!SWIG_IsOK(res1)) {
30807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30808 }
30809 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30810 ecode2 = SWIG_AsVal_int(obj1, &val2);
30811 if (!SWIG_IsOK(ecode2)) {
30812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
30813 }
30814 arg2 = static_cast< int >(val2);
30815 {
30816 PyThreadState* __tstate = wxPyBeginAllowThreads();
30817 {
30818 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
30819 result = (wxDateSpan *) &_result_ref;
30820 }
30821 wxPyEndAllowThreads(__tstate);
30822 if (PyErr_Occurred()) SWIG_fail;
30823 }
30824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30825 return resultobj;
30826 fail:
30827 return NULL;
30828 }
30829
30830
30831 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30832 PyObject *resultobj = 0;
30833 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30834 wxDateSpan *arg2 = 0 ;
30835 wxDateSpan *result = 0 ;
30836 void *argp1 = 0 ;
30837 int res1 = 0 ;
30838 void *argp2 = 0 ;
30839 int res2 = 0 ;
30840 PyObject * obj0 = 0 ;
30841 PyObject * obj1 = 0 ;
30842 char * kwnames[] = {
30843 (char *) "self",(char *) "other", NULL
30844 };
30845
30846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
30847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30848 if (!SWIG_IsOK(res1)) {
30849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30850 }
30851 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30852 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30853 if (!SWIG_IsOK(res2)) {
30854 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30855 }
30856 if (!argp2) {
30857 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30858 }
30859 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30860 {
30861 PyThreadState* __tstate = wxPyBeginAllowThreads();
30862 {
30863 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
30864 result = (wxDateSpan *) &_result_ref;
30865 }
30866 wxPyEndAllowThreads(__tstate);
30867 if (PyErr_Occurred()) SWIG_fail;
30868 }
30869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30870 return resultobj;
30871 fail:
30872 return NULL;
30873 }
30874
30875
30876 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30877 PyObject *resultobj = 0;
30878 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30879 wxDateSpan *arg2 = 0 ;
30880 wxDateSpan *result = 0 ;
30881 void *argp1 = 0 ;
30882 int res1 = 0 ;
30883 void *argp2 = 0 ;
30884 int res2 = 0 ;
30885 PyObject * obj0 = 0 ;
30886 PyObject * obj1 = 0 ;
30887 char * kwnames[] = {
30888 (char *) "self",(char *) "other", NULL
30889 };
30890
30891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
30892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30893 if (!SWIG_IsOK(res1)) {
30894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30895 }
30896 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30897 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30898 if (!SWIG_IsOK(res2)) {
30899 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30900 }
30901 if (!argp2) {
30902 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30903 }
30904 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30905 {
30906 PyThreadState* __tstate = wxPyBeginAllowThreads();
30907 {
30908 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
30909 result = (wxDateSpan *) &_result_ref;
30910 }
30911 wxPyEndAllowThreads(__tstate);
30912 if (PyErr_Occurred()) SWIG_fail;
30913 }
30914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30915 return resultobj;
30916 fail:
30917 return NULL;
30918 }
30919
30920
30921 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30922 PyObject *resultobj = 0;
30923 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30924 wxDateSpan *result = 0 ;
30925 void *argp1 = 0 ;
30926 int res1 = 0 ;
30927 PyObject *swig_obj[1] ;
30928
30929 if (!args) SWIG_fail;
30930 swig_obj[0] = args;
30931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30932 if (!SWIG_IsOK(res1)) {
30933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30934 }
30935 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30936 {
30937 PyThreadState* __tstate = wxPyBeginAllowThreads();
30938 {
30939 wxDateSpan &_result_ref = (arg1)->operator -();
30940 result = (wxDateSpan *) &_result_ref;
30941 }
30942 wxPyEndAllowThreads(__tstate);
30943 if (PyErr_Occurred()) SWIG_fail;
30944 }
30945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30946 return resultobj;
30947 fail:
30948 return NULL;
30949 }
30950
30951
30952 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30953 PyObject *resultobj = 0;
30954 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30955 int arg2 ;
30956 wxDateSpan *result = 0 ;
30957 void *argp1 = 0 ;
30958 int res1 = 0 ;
30959 int val2 ;
30960 int ecode2 = 0 ;
30961 PyObject * obj0 = 0 ;
30962 PyObject * obj1 = 0 ;
30963 char * kwnames[] = {
30964 (char *) "self",(char *) "factor", NULL
30965 };
30966
30967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
30968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30969 if (!SWIG_IsOK(res1)) {
30970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30971 }
30972 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30973 ecode2 = SWIG_AsVal_int(obj1, &val2);
30974 if (!SWIG_IsOK(ecode2)) {
30975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
30976 }
30977 arg2 = static_cast< int >(val2);
30978 {
30979 PyThreadState* __tstate = wxPyBeginAllowThreads();
30980 {
30981 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
30982 result = (wxDateSpan *) &_result_ref;
30983 }
30984 wxPyEndAllowThreads(__tstate);
30985 if (PyErr_Occurred()) SWIG_fail;
30986 }
30987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30988 return resultobj;
30989 fail:
30990 return NULL;
30991 }
30992
30993
30994 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30995 PyObject *resultobj = 0;
30996 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30997 wxDateSpan *arg2 = 0 ;
30998 wxDateSpan result;
30999 void *argp1 = 0 ;
31000 int res1 = 0 ;
31001 void *argp2 = 0 ;
31002 int res2 = 0 ;
31003 PyObject * obj0 = 0 ;
31004 PyObject * obj1 = 0 ;
31005 char * kwnames[] = {
31006 (char *) "self",(char *) "other", NULL
31007 };
31008
31009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31011 if (!SWIG_IsOK(res1)) {
31012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31013 }
31014 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31015 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31016 if (!SWIG_IsOK(res2)) {
31017 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31018 }
31019 if (!argp2) {
31020 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31021 }
31022 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31023 {
31024 PyThreadState* __tstate = wxPyBeginAllowThreads();
31025 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31026 wxPyEndAllowThreads(__tstate);
31027 if (PyErr_Occurred()) SWIG_fail;
31028 }
31029 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31030 return resultobj;
31031 fail:
31032 return NULL;
31033 }
31034
31035
31036 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31037 PyObject *resultobj = 0;
31038 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31039 wxDateSpan *arg2 = 0 ;
31040 wxDateSpan result;
31041 void *argp1 = 0 ;
31042 int res1 = 0 ;
31043 void *argp2 = 0 ;
31044 int res2 = 0 ;
31045 PyObject * obj0 = 0 ;
31046 PyObject * obj1 = 0 ;
31047 char * kwnames[] = {
31048 (char *) "self",(char *) "other", NULL
31049 };
31050
31051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31053 if (!SWIG_IsOK(res1)) {
31054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31055 }
31056 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31057 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31058 if (!SWIG_IsOK(res2)) {
31059 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31060 }
31061 if (!argp2) {
31062 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31063 }
31064 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31065 {
31066 PyThreadState* __tstate = wxPyBeginAllowThreads();
31067 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31068 wxPyEndAllowThreads(__tstate);
31069 if (PyErr_Occurred()) SWIG_fail;
31070 }
31071 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31072 return resultobj;
31073 fail:
31074 return NULL;
31075 }
31076
31077
31078 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31079 PyObject *resultobj = 0;
31080 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31081 int arg2 ;
31082 wxDateSpan result;
31083 void *argp1 = 0 ;
31084 int res1 = 0 ;
31085 int val2 ;
31086 int ecode2 = 0 ;
31087 PyObject * obj0 = 0 ;
31088 PyObject * obj1 = 0 ;
31089 char * kwnames[] = {
31090 (char *) "self",(char *) "n", NULL
31091 };
31092
31093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31095 if (!SWIG_IsOK(res1)) {
31096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31097 }
31098 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31099 ecode2 = SWIG_AsVal_int(obj1, &val2);
31100 if (!SWIG_IsOK(ecode2)) {
31101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31102 }
31103 arg2 = static_cast< int >(val2);
31104 {
31105 PyThreadState* __tstate = wxPyBeginAllowThreads();
31106 result = wxDateSpan___mul__(arg1,arg2);
31107 wxPyEndAllowThreads(__tstate);
31108 if (PyErr_Occurred()) SWIG_fail;
31109 }
31110 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31111 return resultobj;
31112 fail:
31113 return NULL;
31114 }
31115
31116
31117 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31118 PyObject *resultobj = 0;
31119 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31120 int arg2 ;
31121 wxDateSpan result;
31122 void *argp1 = 0 ;
31123 int res1 = 0 ;
31124 int val2 ;
31125 int ecode2 = 0 ;
31126 PyObject * obj0 = 0 ;
31127 PyObject * obj1 = 0 ;
31128 char * kwnames[] = {
31129 (char *) "self",(char *) "n", NULL
31130 };
31131
31132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31134 if (!SWIG_IsOK(res1)) {
31135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31136 }
31137 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31138 ecode2 = SWIG_AsVal_int(obj1, &val2);
31139 if (!SWIG_IsOK(ecode2)) {
31140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31141 }
31142 arg2 = static_cast< int >(val2);
31143 {
31144 PyThreadState* __tstate = wxPyBeginAllowThreads();
31145 result = wxDateSpan___rmul__(arg1,arg2);
31146 wxPyEndAllowThreads(__tstate);
31147 if (PyErr_Occurred()) SWIG_fail;
31148 }
31149 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31150 return resultobj;
31151 fail:
31152 return NULL;
31153 }
31154
31155
31156 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31157 PyObject *resultobj = 0;
31158 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31159 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31160 bool result;
31161 void *argp1 = 0 ;
31162 int res1 = 0 ;
31163 void *argp2 = 0 ;
31164 int res2 = 0 ;
31165 PyObject * obj0 = 0 ;
31166 PyObject * obj1 = 0 ;
31167 char * kwnames[] = {
31168 (char *) "self",(char *) "other", NULL
31169 };
31170
31171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31173 if (!SWIG_IsOK(res1)) {
31174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31175 }
31176 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31177 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31178 if (!SWIG_IsOK(res2)) {
31179 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31180 }
31181 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31182 {
31183 PyThreadState* __tstate = wxPyBeginAllowThreads();
31184 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31185 wxPyEndAllowThreads(__tstate);
31186 if (PyErr_Occurred()) SWIG_fail;
31187 }
31188 {
31189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31190 }
31191 return resultobj;
31192 fail:
31193 return NULL;
31194 }
31195
31196
31197 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31198 PyObject *resultobj = 0;
31199 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31200 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31201 bool result;
31202 void *argp1 = 0 ;
31203 int res1 = 0 ;
31204 void *argp2 = 0 ;
31205 int res2 = 0 ;
31206 PyObject * obj0 = 0 ;
31207 PyObject * obj1 = 0 ;
31208 char * kwnames[] = {
31209 (char *) "self",(char *) "other", NULL
31210 };
31211
31212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31214 if (!SWIG_IsOK(res1)) {
31215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31216 }
31217 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31218 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31219 if (!SWIG_IsOK(res2)) {
31220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31221 }
31222 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31223 {
31224 PyThreadState* __tstate = wxPyBeginAllowThreads();
31225 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31226 wxPyEndAllowThreads(__tstate);
31227 if (PyErr_Occurred()) SWIG_fail;
31228 }
31229 {
31230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31231 }
31232 return resultobj;
31233 fail:
31234 return NULL;
31235 }
31236
31237
31238 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31239 PyObject *obj;
31240 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31241 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31242 return SWIG_Py_Void();
31243 }
31244
31245 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31246 return SWIG_Python_InitShadowInstance(args);
31247 }
31248
31249 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31250 PyObject *resultobj = 0;
31251 long result;
31252
31253 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31254 {
31255 PyThreadState* __tstate = wxPyBeginAllowThreads();
31256 result = (long)wxGetLocalTime();
31257 wxPyEndAllowThreads(__tstate);
31258 if (PyErr_Occurred()) SWIG_fail;
31259 }
31260 resultobj = SWIG_From_long(static_cast< long >(result));
31261 return resultobj;
31262 fail:
31263 return NULL;
31264 }
31265
31266
31267 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31268 PyObject *resultobj = 0;
31269 long result;
31270
31271 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31272 {
31273 PyThreadState* __tstate = wxPyBeginAllowThreads();
31274 result = (long)wxGetUTCTime();
31275 wxPyEndAllowThreads(__tstate);
31276 if (PyErr_Occurred()) SWIG_fail;
31277 }
31278 resultobj = SWIG_From_long(static_cast< long >(result));
31279 return resultobj;
31280 fail:
31281 return NULL;
31282 }
31283
31284
31285 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31286 PyObject *resultobj = 0;
31287 long result;
31288
31289 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31290 {
31291 PyThreadState* __tstate = wxPyBeginAllowThreads();
31292 result = (long)wxGetCurrentTime();
31293 wxPyEndAllowThreads(__tstate);
31294 if (PyErr_Occurred()) SWIG_fail;
31295 }
31296 resultobj = SWIG_From_long(static_cast< long >(result));
31297 return resultobj;
31298 fail:
31299 return NULL;
31300 }
31301
31302
31303 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31304 PyObject *resultobj = 0;
31305 wxLongLong result;
31306
31307 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31308 {
31309 PyThreadState* __tstate = wxPyBeginAllowThreads();
31310 result = wxGetLocalTimeMillis();
31311 wxPyEndAllowThreads(__tstate);
31312 if (PyErr_Occurred()) SWIG_fail;
31313 }
31314 {
31315 PyObject *hi, *lo, *shifter, *shifted;
31316 hi = PyLong_FromLong( (&result)->GetHi() );
31317 lo = PyLong_FromLong( (&result)->GetLo() );
31318 shifter = PyLong_FromLong(32);
31319 shifted = PyNumber_Lshift(hi, shifter);
31320 resultobj = PyNumber_Or(shifted, lo);
31321 Py_DECREF(hi);
31322 Py_DECREF(lo);
31323 Py_DECREF(shifter);
31324 Py_DECREF(shifted);
31325 }
31326 return resultobj;
31327 fail:
31328 return NULL;
31329 }
31330
31331
31332 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31333 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31334 return 1;
31335 }
31336
31337
31338 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31339 PyObject *pyobj = 0;
31340
31341 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31342 return pyobj;
31343 }
31344
31345
31346 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31347 PyObject *resultobj = 0;
31348 wxDataFormatId arg1 ;
31349 wxDataFormat *result = 0 ;
31350 int val1 ;
31351 int ecode1 = 0 ;
31352 PyObject * obj0 = 0 ;
31353 char * kwnames[] = {
31354 (char *) "type", NULL
31355 };
31356
31357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31358 ecode1 = SWIG_AsVal_int(obj0, &val1);
31359 if (!SWIG_IsOK(ecode1)) {
31360 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31361 }
31362 arg1 = static_cast< wxDataFormatId >(val1);
31363 {
31364 PyThreadState* __tstate = wxPyBeginAllowThreads();
31365 result = (wxDataFormat *)new wxDataFormat(arg1);
31366 wxPyEndAllowThreads(__tstate);
31367 if (PyErr_Occurred()) SWIG_fail;
31368 }
31369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31370 return resultobj;
31371 fail:
31372 return NULL;
31373 }
31374
31375
31376 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31377 PyObject *resultobj = 0;
31378 wxString *arg1 = 0 ;
31379 wxDataFormat *result = 0 ;
31380 bool temp1 = false ;
31381 PyObject * obj0 = 0 ;
31382 char * kwnames[] = {
31383 (char *) "format", NULL
31384 };
31385
31386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31387 {
31388 arg1 = wxString_in_helper(obj0);
31389 if (arg1 == NULL) SWIG_fail;
31390 temp1 = true;
31391 }
31392 {
31393 PyThreadState* __tstate = wxPyBeginAllowThreads();
31394 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31395 wxPyEndAllowThreads(__tstate);
31396 if (PyErr_Occurred()) SWIG_fail;
31397 }
31398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31399 {
31400 if (temp1)
31401 delete arg1;
31402 }
31403 return resultobj;
31404 fail:
31405 {
31406 if (temp1)
31407 delete arg1;
31408 }
31409 return NULL;
31410 }
31411
31412
31413 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31414 PyObject *resultobj = 0;
31415 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31416 void *argp1 = 0 ;
31417 int res1 = 0 ;
31418 PyObject *swig_obj[1] ;
31419
31420 if (!args) SWIG_fail;
31421 swig_obj[0] = args;
31422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31423 if (!SWIG_IsOK(res1)) {
31424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31425 }
31426 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31427 {
31428 PyThreadState* __tstate = wxPyBeginAllowThreads();
31429 delete arg1;
31430
31431 wxPyEndAllowThreads(__tstate);
31432 if (PyErr_Occurred()) SWIG_fail;
31433 }
31434 resultobj = SWIG_Py_Void();
31435 return resultobj;
31436 fail:
31437 return NULL;
31438 }
31439
31440
31441 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31442 PyObject *resultobj = 0;
31443 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31444 wxDataFormatId arg2 ;
31445 bool result;
31446 void *argp1 = 0 ;
31447 int res1 = 0 ;
31448 int val2 ;
31449 int ecode2 = 0 ;
31450
31451 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31453 if (!SWIG_IsOK(res1)) {
31454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31455 }
31456 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31457 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31458 if (!SWIG_IsOK(ecode2)) {
31459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31460 }
31461 arg2 = static_cast< wxDataFormatId >(val2);
31462 {
31463 PyThreadState* __tstate = wxPyBeginAllowThreads();
31464 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31465 wxPyEndAllowThreads(__tstate);
31466 if (PyErr_Occurred()) SWIG_fail;
31467 }
31468 {
31469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31470 }
31471 return resultobj;
31472 fail:
31473 return NULL;
31474 }
31475
31476
31477 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31478 PyObject *resultobj = 0;
31479 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31480 wxDataFormatId arg2 ;
31481 bool result;
31482 void *argp1 = 0 ;
31483 int res1 = 0 ;
31484 int val2 ;
31485 int ecode2 = 0 ;
31486
31487 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31489 if (!SWIG_IsOK(res1)) {
31490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31491 }
31492 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31493 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31494 if (!SWIG_IsOK(ecode2)) {
31495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31496 }
31497 arg2 = static_cast< wxDataFormatId >(val2);
31498 {
31499 PyThreadState* __tstate = wxPyBeginAllowThreads();
31500 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31501 wxPyEndAllowThreads(__tstate);
31502 if (PyErr_Occurred()) SWIG_fail;
31503 }
31504 {
31505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31506 }
31507 return resultobj;
31508 fail:
31509 return NULL;
31510 }
31511
31512
31513 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31514 PyObject *resultobj = 0;
31515 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31516 wxDataFormat *arg2 = 0 ;
31517 bool result;
31518 void *argp1 = 0 ;
31519 int res1 = 0 ;
31520 void *argp2 = 0 ;
31521 int res2 = 0 ;
31522
31523 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31525 if (!SWIG_IsOK(res1)) {
31526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31527 }
31528 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31529 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31530 if (!SWIG_IsOK(res2)) {
31531 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31532 }
31533 if (!argp2) {
31534 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31535 }
31536 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31537 {
31538 PyThreadState* __tstate = wxPyBeginAllowThreads();
31539 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31540 wxPyEndAllowThreads(__tstate);
31541 if (PyErr_Occurred()) SWIG_fail;
31542 }
31543 {
31544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31545 }
31546 return resultobj;
31547 fail:
31548 return NULL;
31549 }
31550
31551
31552 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31553 int argc;
31554 PyObject *argv[3];
31555
31556 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31557 --argc;
31558 if (argc == 2) {
31559 int _v = 0;
31560 {
31561 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31562 _v = SWIG_CheckState(res);
31563 }
31564 if (!_v) goto check_1;
31565 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31566 }
31567 check_1:
31568
31569 if (argc == 2) {
31570 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31571 }
31572
31573 fail:
31574 Py_INCREF(Py_NotImplemented);
31575 return Py_NotImplemented;
31576 }
31577
31578
31579 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31580 PyObject *resultobj = 0;
31581 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31582 wxDataFormat *arg2 = 0 ;
31583 bool result;
31584 void *argp1 = 0 ;
31585 int res1 = 0 ;
31586 void *argp2 = 0 ;
31587 int res2 = 0 ;
31588
31589 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31591 if (!SWIG_IsOK(res1)) {
31592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31593 }
31594 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31595 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31596 if (!SWIG_IsOK(res2)) {
31597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31598 }
31599 if (!argp2) {
31600 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31601 }
31602 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31603 {
31604 PyThreadState* __tstate = wxPyBeginAllowThreads();
31605 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31606 wxPyEndAllowThreads(__tstate);
31607 if (PyErr_Occurred()) SWIG_fail;
31608 }
31609 {
31610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31611 }
31612 return resultobj;
31613 fail:
31614 return NULL;
31615 }
31616
31617
31618 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31619 int argc;
31620 PyObject *argv[3];
31621
31622 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31623 --argc;
31624 if (argc == 2) {
31625 int _v = 0;
31626 {
31627 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31628 _v = SWIG_CheckState(res);
31629 }
31630 if (!_v) goto check_1;
31631 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31632 }
31633 check_1:
31634
31635 if (argc == 2) {
31636 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31637 }
31638
31639 fail:
31640 Py_INCREF(Py_NotImplemented);
31641 return Py_NotImplemented;
31642 }
31643
31644
31645 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31646 PyObject *resultobj = 0;
31647 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31648 wxDataFormatId arg2 ;
31649 void *argp1 = 0 ;
31650 int res1 = 0 ;
31651 int val2 ;
31652 int ecode2 = 0 ;
31653 PyObject * obj0 = 0 ;
31654 PyObject * obj1 = 0 ;
31655 char * kwnames[] = {
31656 (char *) "self",(char *) "format", NULL
31657 };
31658
31659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31661 if (!SWIG_IsOK(res1)) {
31662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31663 }
31664 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31665 ecode2 = SWIG_AsVal_int(obj1, &val2);
31666 if (!SWIG_IsOK(ecode2)) {
31667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31668 }
31669 arg2 = static_cast< wxDataFormatId >(val2);
31670 {
31671 PyThreadState* __tstate = wxPyBeginAllowThreads();
31672 (arg1)->SetType(arg2);
31673 wxPyEndAllowThreads(__tstate);
31674 if (PyErr_Occurred()) SWIG_fail;
31675 }
31676 resultobj = SWIG_Py_Void();
31677 return resultobj;
31678 fail:
31679 return NULL;
31680 }
31681
31682
31683 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31684 PyObject *resultobj = 0;
31685 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31686 wxDataFormatId result;
31687 void *argp1 = 0 ;
31688 int res1 = 0 ;
31689 PyObject *swig_obj[1] ;
31690
31691 if (!args) SWIG_fail;
31692 swig_obj[0] = args;
31693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31694 if (!SWIG_IsOK(res1)) {
31695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31696 }
31697 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31698 {
31699 PyThreadState* __tstate = wxPyBeginAllowThreads();
31700 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31701 wxPyEndAllowThreads(__tstate);
31702 if (PyErr_Occurred()) SWIG_fail;
31703 }
31704 resultobj = SWIG_From_int(static_cast< int >(result));
31705 return resultobj;
31706 fail:
31707 return NULL;
31708 }
31709
31710
31711 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31712 PyObject *resultobj = 0;
31713 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31714 wxString result;
31715 void *argp1 = 0 ;
31716 int res1 = 0 ;
31717 PyObject *swig_obj[1] ;
31718
31719 if (!args) SWIG_fail;
31720 swig_obj[0] = args;
31721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31722 if (!SWIG_IsOK(res1)) {
31723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31724 }
31725 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31726 {
31727 PyThreadState* __tstate = wxPyBeginAllowThreads();
31728 result = ((wxDataFormat const *)arg1)->GetId();
31729 wxPyEndAllowThreads(__tstate);
31730 if (PyErr_Occurred()) SWIG_fail;
31731 }
31732 {
31733 #if wxUSE_UNICODE
31734 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31735 #else
31736 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31737 #endif
31738 }
31739 return resultobj;
31740 fail:
31741 return NULL;
31742 }
31743
31744
31745 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31746 PyObject *resultobj = 0;
31747 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31748 wxString *arg2 = 0 ;
31749 void *argp1 = 0 ;
31750 int res1 = 0 ;
31751 bool temp2 = false ;
31752 PyObject * obj0 = 0 ;
31753 PyObject * obj1 = 0 ;
31754 char * kwnames[] = {
31755 (char *) "self",(char *) "format", NULL
31756 };
31757
31758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31760 if (!SWIG_IsOK(res1)) {
31761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31762 }
31763 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31764 {
31765 arg2 = wxString_in_helper(obj1);
31766 if (arg2 == NULL) SWIG_fail;
31767 temp2 = true;
31768 }
31769 {
31770 PyThreadState* __tstate = wxPyBeginAllowThreads();
31771 (arg1)->SetId((wxString const &)*arg2);
31772 wxPyEndAllowThreads(__tstate);
31773 if (PyErr_Occurred()) SWIG_fail;
31774 }
31775 resultobj = SWIG_Py_Void();
31776 {
31777 if (temp2)
31778 delete arg2;
31779 }
31780 return resultobj;
31781 fail:
31782 {
31783 if (temp2)
31784 delete arg2;
31785 }
31786 return NULL;
31787 }
31788
31789
31790 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31791 PyObject *obj;
31792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31793 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
31794 return SWIG_Py_Void();
31795 }
31796
31797 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31798 return SWIG_Python_InitShadowInstance(args);
31799 }
31800
31801 SWIGINTERN int FormatInvalid_set(PyObject *) {
31802 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
31803 return 1;
31804 }
31805
31806
31807 SWIGINTERN PyObject *FormatInvalid_get(void) {
31808 PyObject *pyobj = 0;
31809
31810 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
31811 return pyobj;
31812 }
31813
31814
31815 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31816 PyObject *resultobj = 0;
31817 wxDataObject *arg1 = (wxDataObject *) 0 ;
31818 void *argp1 = 0 ;
31819 int res1 = 0 ;
31820 PyObject *swig_obj[1] ;
31821
31822 if (!args) SWIG_fail;
31823 swig_obj[0] = args;
31824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
31825 if (!SWIG_IsOK(res1)) {
31826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
31827 }
31828 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31829 {
31830 PyThreadState* __tstate = wxPyBeginAllowThreads();
31831 delete arg1;
31832
31833 wxPyEndAllowThreads(__tstate);
31834 if (PyErr_Occurred()) SWIG_fail;
31835 }
31836 resultobj = SWIG_Py_Void();
31837 return resultobj;
31838 fail:
31839 return NULL;
31840 }
31841
31842
31843 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31844 PyObject *resultobj = 0;
31845 wxDataObject *arg1 = (wxDataObject *) 0 ;
31846 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31847 SwigValueWrapper<wxDataFormat > result;
31848 void *argp1 = 0 ;
31849 int res1 = 0 ;
31850 int val2 ;
31851 int ecode2 = 0 ;
31852 PyObject * obj0 = 0 ;
31853 PyObject * obj1 = 0 ;
31854 char * kwnames[] = {
31855 (char *) "self",(char *) "dir", NULL
31856 };
31857
31858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31860 if (!SWIG_IsOK(res1)) {
31861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31862 }
31863 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31864 if (obj1) {
31865 ecode2 = SWIG_AsVal_int(obj1, &val2);
31866 if (!SWIG_IsOK(ecode2)) {
31867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31868 }
31869 arg2 = static_cast< wxDataObject::Direction >(val2);
31870 }
31871 {
31872 PyThreadState* __tstate = wxPyBeginAllowThreads();
31873 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
31874 wxPyEndAllowThreads(__tstate);
31875 if (PyErr_Occurred()) SWIG_fail;
31876 }
31877 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31878 return resultobj;
31879 fail:
31880 return NULL;
31881 }
31882
31883
31884 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31885 PyObject *resultobj = 0;
31886 wxDataObject *arg1 = (wxDataObject *) 0 ;
31887 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31888 size_t result;
31889 void *argp1 = 0 ;
31890 int res1 = 0 ;
31891 int val2 ;
31892 int ecode2 = 0 ;
31893 PyObject * obj0 = 0 ;
31894 PyObject * obj1 = 0 ;
31895 char * kwnames[] = {
31896 (char *) "self",(char *) "dir", NULL
31897 };
31898
31899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
31900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31901 if (!SWIG_IsOK(res1)) {
31902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31903 }
31904 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31905 if (obj1) {
31906 ecode2 = SWIG_AsVal_int(obj1, &val2);
31907 if (!SWIG_IsOK(ecode2)) {
31908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31909 }
31910 arg2 = static_cast< wxDataObject::Direction >(val2);
31911 }
31912 {
31913 PyThreadState* __tstate = wxPyBeginAllowThreads();
31914 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
31915 wxPyEndAllowThreads(__tstate);
31916 if (PyErr_Occurred()) SWIG_fail;
31917 }
31918 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31919 return resultobj;
31920 fail:
31921 return NULL;
31922 }
31923
31924
31925 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31926 PyObject *resultobj = 0;
31927 wxDataObject *arg1 = (wxDataObject *) 0 ;
31928 wxDataFormat *arg2 = 0 ;
31929 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
31930 bool result;
31931 void *argp1 = 0 ;
31932 int res1 = 0 ;
31933 void *argp2 = 0 ;
31934 int res2 = 0 ;
31935 int val3 ;
31936 int ecode3 = 0 ;
31937 PyObject * obj0 = 0 ;
31938 PyObject * obj1 = 0 ;
31939 PyObject * obj2 = 0 ;
31940 char * kwnames[] = {
31941 (char *) "self",(char *) "format",(char *) "dir", NULL
31942 };
31943
31944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31946 if (!SWIG_IsOK(res1)) {
31947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31948 }
31949 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31950 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31951 if (!SWIG_IsOK(res2)) {
31952 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31953 }
31954 if (!argp2) {
31955 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31956 }
31957 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31958 if (obj2) {
31959 ecode3 = SWIG_AsVal_int(obj2, &val3);
31960 if (!SWIG_IsOK(ecode3)) {
31961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
31962 }
31963 arg3 = static_cast< wxDataObject::Direction >(val3);
31964 }
31965 {
31966 PyThreadState* __tstate = wxPyBeginAllowThreads();
31967 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
31968 wxPyEndAllowThreads(__tstate);
31969 if (PyErr_Occurred()) SWIG_fail;
31970 }
31971 {
31972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31973 }
31974 return resultobj;
31975 fail:
31976 return NULL;
31977 }
31978
31979
31980 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31981 PyObject *resultobj = 0;
31982 wxDataObject *arg1 = (wxDataObject *) 0 ;
31983 wxDataFormat *arg2 = 0 ;
31984 size_t result;
31985 void *argp1 = 0 ;
31986 int res1 = 0 ;
31987 void *argp2 = 0 ;
31988 int res2 = 0 ;
31989 PyObject * obj0 = 0 ;
31990 PyObject * obj1 = 0 ;
31991 char * kwnames[] = {
31992 (char *) "self",(char *) "format", NULL
31993 };
31994
31995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
31996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31997 if (!SWIG_IsOK(res1)) {
31998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31999 }
32000 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32001 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32002 if (!SWIG_IsOK(res2)) {
32003 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32004 }
32005 if (!argp2) {
32006 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32007 }
32008 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32009 {
32010 PyThreadState* __tstate = wxPyBeginAllowThreads();
32011 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32012 wxPyEndAllowThreads(__tstate);
32013 if (PyErr_Occurred()) SWIG_fail;
32014 }
32015 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32016 return resultobj;
32017 fail:
32018 return NULL;
32019 }
32020
32021
32022 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32023 PyObject *resultobj = 0;
32024 wxDataObject *arg1 = (wxDataObject *) 0 ;
32025 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32026 PyObject *result = 0 ;
32027 void *argp1 = 0 ;
32028 int res1 = 0 ;
32029 int val2 ;
32030 int ecode2 = 0 ;
32031 PyObject * obj0 = 0 ;
32032 PyObject * obj1 = 0 ;
32033 char * kwnames[] = {
32034 (char *) "self",(char *) "dir", NULL
32035 };
32036
32037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32039 if (!SWIG_IsOK(res1)) {
32040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32041 }
32042 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32043 if (obj1) {
32044 ecode2 = SWIG_AsVal_int(obj1, &val2);
32045 if (!SWIG_IsOK(ecode2)) {
32046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32047 }
32048 arg2 = static_cast< wxDataObject::Direction >(val2);
32049 }
32050 {
32051 PyThreadState* __tstate = wxPyBeginAllowThreads();
32052 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32053 wxPyEndAllowThreads(__tstate);
32054 if (PyErr_Occurred()) SWIG_fail;
32055 }
32056 resultobj = result;
32057 return resultobj;
32058 fail:
32059 return NULL;
32060 }
32061
32062
32063 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32064 PyObject *resultobj = 0;
32065 wxDataObject *arg1 = (wxDataObject *) 0 ;
32066 wxDataFormat *arg2 = 0 ;
32067 PyObject *result = 0 ;
32068 void *argp1 = 0 ;
32069 int res1 = 0 ;
32070 void *argp2 = 0 ;
32071 int res2 = 0 ;
32072 PyObject * obj0 = 0 ;
32073 PyObject * obj1 = 0 ;
32074 char * kwnames[] = {
32075 (char *) "self",(char *) "format", NULL
32076 };
32077
32078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32080 if (!SWIG_IsOK(res1)) {
32081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32082 }
32083 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32084 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32085 if (!SWIG_IsOK(res2)) {
32086 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32087 }
32088 if (!argp2) {
32089 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32090 }
32091 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32092 {
32093 PyThreadState* __tstate = wxPyBeginAllowThreads();
32094 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32095 wxPyEndAllowThreads(__tstate);
32096 if (PyErr_Occurred()) SWIG_fail;
32097 }
32098 resultobj = result;
32099 return resultobj;
32100 fail:
32101 return NULL;
32102 }
32103
32104
32105 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32106 PyObject *resultobj = 0;
32107 wxDataObject *arg1 = (wxDataObject *) 0 ;
32108 wxDataFormat *arg2 = 0 ;
32109 PyObject *arg3 = (PyObject *) 0 ;
32110 bool result;
32111 void *argp1 = 0 ;
32112 int res1 = 0 ;
32113 void *argp2 = 0 ;
32114 int res2 = 0 ;
32115 PyObject * obj0 = 0 ;
32116 PyObject * obj1 = 0 ;
32117 PyObject * obj2 = 0 ;
32118 char * kwnames[] = {
32119 (char *) "self",(char *) "format",(char *) "data", NULL
32120 };
32121
32122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32124 if (!SWIG_IsOK(res1)) {
32125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32126 }
32127 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32128 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32129 if (!SWIG_IsOK(res2)) {
32130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32131 }
32132 if (!argp2) {
32133 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32134 }
32135 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32136 arg3 = obj2;
32137 {
32138 PyThreadState* __tstate = wxPyBeginAllowThreads();
32139 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32140 wxPyEndAllowThreads(__tstate);
32141 if (PyErr_Occurred()) SWIG_fail;
32142 }
32143 {
32144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32145 }
32146 return resultobj;
32147 fail:
32148 return NULL;
32149 }
32150
32151
32152 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32153 PyObject *obj;
32154 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32155 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32156 return SWIG_Py_Void();
32157 }
32158
32159 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32160 PyObject *resultobj = 0;
32161 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32162 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32163 wxDataObjectSimple *result = 0 ;
32164 void *argp1 = 0 ;
32165 int res1 = 0 ;
32166 PyObject * obj0 = 0 ;
32167 char * kwnames[] = {
32168 (char *) "format", NULL
32169 };
32170
32171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32172 if (obj0) {
32173 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32174 if (!SWIG_IsOK(res1)) {
32175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32176 }
32177 if (!argp1) {
32178 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32179 }
32180 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32181 }
32182 {
32183 PyThreadState* __tstate = wxPyBeginAllowThreads();
32184 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32185 wxPyEndAllowThreads(__tstate);
32186 if (PyErr_Occurred()) SWIG_fail;
32187 }
32188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32189 return resultobj;
32190 fail:
32191 return NULL;
32192 }
32193
32194
32195 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32196 PyObject *resultobj = 0;
32197 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32198 wxDataFormat *result = 0 ;
32199 void *argp1 = 0 ;
32200 int res1 = 0 ;
32201 PyObject *swig_obj[1] ;
32202
32203 if (!args) SWIG_fail;
32204 swig_obj[0] = args;
32205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32206 if (!SWIG_IsOK(res1)) {
32207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32208 }
32209 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32210 {
32211 PyThreadState* __tstate = wxPyBeginAllowThreads();
32212 {
32213 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32214 result = (wxDataFormat *) &_result_ref;
32215 }
32216 wxPyEndAllowThreads(__tstate);
32217 if (PyErr_Occurred()) SWIG_fail;
32218 }
32219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32220 return resultobj;
32221 fail:
32222 return NULL;
32223 }
32224
32225
32226 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32227 PyObject *resultobj = 0;
32228 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32229 wxDataFormat *arg2 = 0 ;
32230 void *argp1 = 0 ;
32231 int res1 = 0 ;
32232 void *argp2 = 0 ;
32233 int res2 = 0 ;
32234 PyObject * obj0 = 0 ;
32235 PyObject * obj1 = 0 ;
32236 char * kwnames[] = {
32237 (char *) "self",(char *) "format", NULL
32238 };
32239
32240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32242 if (!SWIG_IsOK(res1)) {
32243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32244 }
32245 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32246 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32247 if (!SWIG_IsOK(res2)) {
32248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32249 }
32250 if (!argp2) {
32251 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32252 }
32253 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32254 {
32255 PyThreadState* __tstate = wxPyBeginAllowThreads();
32256 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32257 wxPyEndAllowThreads(__tstate);
32258 if (PyErr_Occurred()) SWIG_fail;
32259 }
32260 resultobj = SWIG_Py_Void();
32261 return resultobj;
32262 fail:
32263 return NULL;
32264 }
32265
32266
32267 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32268 PyObject *resultobj = 0;
32269 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32270 size_t result;
32271 void *argp1 = 0 ;
32272 int res1 = 0 ;
32273 PyObject *swig_obj[1] ;
32274
32275 if (!args) SWIG_fail;
32276 swig_obj[0] = args;
32277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32278 if (!SWIG_IsOK(res1)) {
32279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32280 }
32281 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32282 {
32283 PyThreadState* __tstate = wxPyBeginAllowThreads();
32284 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32285 wxPyEndAllowThreads(__tstate);
32286 if (PyErr_Occurred()) SWIG_fail;
32287 }
32288 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32289 return resultobj;
32290 fail:
32291 return NULL;
32292 }
32293
32294
32295 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32296 PyObject *resultobj = 0;
32297 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32298 PyObject *result = 0 ;
32299 void *argp1 = 0 ;
32300 int res1 = 0 ;
32301 PyObject *swig_obj[1] ;
32302
32303 if (!args) SWIG_fail;
32304 swig_obj[0] = args;
32305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32306 if (!SWIG_IsOK(res1)) {
32307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32308 }
32309 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32310 {
32311 PyThreadState* __tstate = wxPyBeginAllowThreads();
32312 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32313 wxPyEndAllowThreads(__tstate);
32314 if (PyErr_Occurred()) SWIG_fail;
32315 }
32316 resultobj = result;
32317 return resultobj;
32318 fail:
32319 return NULL;
32320 }
32321
32322
32323 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32324 PyObject *resultobj = 0;
32325 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32326 PyObject *arg2 = (PyObject *) 0 ;
32327 bool result;
32328 void *argp1 = 0 ;
32329 int res1 = 0 ;
32330 PyObject * obj0 = 0 ;
32331 PyObject * obj1 = 0 ;
32332 char * kwnames[] = {
32333 (char *) "self",(char *) "data", NULL
32334 };
32335
32336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32338 if (!SWIG_IsOK(res1)) {
32339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32340 }
32341 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32342 arg2 = obj1;
32343 {
32344 PyThreadState* __tstate = wxPyBeginAllowThreads();
32345 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32346 wxPyEndAllowThreads(__tstate);
32347 if (PyErr_Occurred()) SWIG_fail;
32348 }
32349 {
32350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32351 }
32352 return resultobj;
32353 fail:
32354 return NULL;
32355 }
32356
32357
32358 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32359 PyObject *obj;
32360 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32361 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32362 return SWIG_Py_Void();
32363 }
32364
32365 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32366 return SWIG_Python_InitShadowInstance(args);
32367 }
32368
32369 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32370 PyObject *resultobj = 0;
32371 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32372 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32373 wxPyDataObjectSimple *result = 0 ;
32374 void *argp1 = 0 ;
32375 int res1 = 0 ;
32376 PyObject * obj0 = 0 ;
32377 char * kwnames[] = {
32378 (char *) "format", NULL
32379 };
32380
32381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32382 if (obj0) {
32383 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32384 if (!SWIG_IsOK(res1)) {
32385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32386 }
32387 if (!argp1) {
32388 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32389 }
32390 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32391 }
32392 {
32393 PyThreadState* __tstate = wxPyBeginAllowThreads();
32394 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32395 wxPyEndAllowThreads(__tstate);
32396 if (PyErr_Occurred()) SWIG_fail;
32397 }
32398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32399 return resultobj;
32400 fail:
32401 return NULL;
32402 }
32403
32404
32405 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32406 PyObject *resultobj = 0;
32407 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32408 PyObject *arg2 = (PyObject *) 0 ;
32409 PyObject *arg3 = (PyObject *) 0 ;
32410 void *argp1 = 0 ;
32411 int res1 = 0 ;
32412 PyObject * obj0 = 0 ;
32413 PyObject * obj1 = 0 ;
32414 PyObject * obj2 = 0 ;
32415 char * kwnames[] = {
32416 (char *) "self",(char *) "self",(char *) "_class", NULL
32417 };
32418
32419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32421 if (!SWIG_IsOK(res1)) {
32422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32423 }
32424 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32425 arg2 = obj1;
32426 arg3 = obj2;
32427 {
32428 PyThreadState* __tstate = wxPyBeginAllowThreads();
32429 (arg1)->_setCallbackInfo(arg2,arg3);
32430 wxPyEndAllowThreads(__tstate);
32431 if (PyErr_Occurred()) SWIG_fail;
32432 }
32433 resultobj = SWIG_Py_Void();
32434 return resultobj;
32435 fail:
32436 return NULL;
32437 }
32438
32439
32440 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32441 PyObject *obj;
32442 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32443 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32444 return SWIG_Py_Void();
32445 }
32446
32447 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32448 return SWIG_Python_InitShadowInstance(args);
32449 }
32450
32451 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32452 PyObject *resultobj = 0;
32453 wxDataObjectComposite *result = 0 ;
32454
32455 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32456 {
32457 PyThreadState* __tstate = wxPyBeginAllowThreads();
32458 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32459 wxPyEndAllowThreads(__tstate);
32460 if (PyErr_Occurred()) SWIG_fail;
32461 }
32462 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32463 return resultobj;
32464 fail:
32465 return NULL;
32466 }
32467
32468
32469 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32470 PyObject *resultobj = 0;
32471 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32472 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32473 bool arg3 = (bool) false ;
32474 void *argp1 = 0 ;
32475 int res1 = 0 ;
32476 int res2 = 0 ;
32477 bool val3 ;
32478 int ecode3 = 0 ;
32479 PyObject * obj0 = 0 ;
32480 PyObject * obj1 = 0 ;
32481 PyObject * obj2 = 0 ;
32482 char * kwnames[] = {
32483 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32484 };
32485
32486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32488 if (!SWIG_IsOK(res1)) {
32489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32490 }
32491 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32492 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32493 if (!SWIG_IsOK(res2)) {
32494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32495 }
32496 if (obj2) {
32497 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32498 if (!SWIG_IsOK(ecode3)) {
32499 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32500 }
32501 arg3 = static_cast< bool >(val3);
32502 }
32503 {
32504 PyThreadState* __tstate = wxPyBeginAllowThreads();
32505 (arg1)->Add(arg2,arg3);
32506 wxPyEndAllowThreads(__tstate);
32507 if (PyErr_Occurred()) SWIG_fail;
32508 }
32509 resultobj = SWIG_Py_Void();
32510 return resultobj;
32511 fail:
32512 return NULL;
32513 }
32514
32515
32516 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32517 PyObject *resultobj = 0;
32518 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32519 SwigValueWrapper<wxDataFormat > result;
32520 void *argp1 = 0 ;
32521 int res1 = 0 ;
32522 PyObject *swig_obj[1] ;
32523
32524 if (!args) SWIG_fail;
32525 swig_obj[0] = args;
32526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32527 if (!SWIG_IsOK(res1)) {
32528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32529 }
32530 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32531 {
32532 PyThreadState* __tstate = wxPyBeginAllowThreads();
32533 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32534 wxPyEndAllowThreads(__tstate);
32535 if (PyErr_Occurred()) SWIG_fail;
32536 }
32537 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32538 return resultobj;
32539 fail:
32540 return NULL;
32541 }
32542
32543
32544 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32545 PyObject *obj;
32546 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32547 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32548 return SWIG_Py_Void();
32549 }
32550
32551 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32552 return SWIG_Python_InitShadowInstance(args);
32553 }
32554
32555 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32556 PyObject *resultobj = 0;
32557 wxString const &arg1_defvalue = wxPyEmptyString ;
32558 wxString *arg1 = (wxString *) &arg1_defvalue ;
32559 wxTextDataObject *result = 0 ;
32560 bool temp1 = false ;
32561 PyObject * obj0 = 0 ;
32562 char * kwnames[] = {
32563 (char *) "text", NULL
32564 };
32565
32566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32567 if (obj0) {
32568 {
32569 arg1 = wxString_in_helper(obj0);
32570 if (arg1 == NULL) SWIG_fail;
32571 temp1 = true;
32572 }
32573 }
32574 {
32575 PyThreadState* __tstate = wxPyBeginAllowThreads();
32576 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32577 wxPyEndAllowThreads(__tstate);
32578 if (PyErr_Occurred()) SWIG_fail;
32579 }
32580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32581 {
32582 if (temp1)
32583 delete arg1;
32584 }
32585 return resultobj;
32586 fail:
32587 {
32588 if (temp1)
32589 delete arg1;
32590 }
32591 return NULL;
32592 }
32593
32594
32595 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32596 PyObject *resultobj = 0;
32597 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32598 size_t result;
32599 void *argp1 = 0 ;
32600 int res1 = 0 ;
32601 PyObject *swig_obj[1] ;
32602
32603 if (!args) SWIG_fail;
32604 swig_obj[0] = args;
32605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32606 if (!SWIG_IsOK(res1)) {
32607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32608 }
32609 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32610 {
32611 PyThreadState* __tstate = wxPyBeginAllowThreads();
32612 result = (size_t)(arg1)->GetTextLength();
32613 wxPyEndAllowThreads(__tstate);
32614 if (PyErr_Occurred()) SWIG_fail;
32615 }
32616 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32617 return resultobj;
32618 fail:
32619 return NULL;
32620 }
32621
32622
32623 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32624 PyObject *resultobj = 0;
32625 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32626 wxString result;
32627 void *argp1 = 0 ;
32628 int res1 = 0 ;
32629 PyObject *swig_obj[1] ;
32630
32631 if (!args) SWIG_fail;
32632 swig_obj[0] = args;
32633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32634 if (!SWIG_IsOK(res1)) {
32635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32636 }
32637 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32638 {
32639 PyThreadState* __tstate = wxPyBeginAllowThreads();
32640 result = (arg1)->GetText();
32641 wxPyEndAllowThreads(__tstate);
32642 if (PyErr_Occurred()) SWIG_fail;
32643 }
32644 {
32645 #if wxUSE_UNICODE
32646 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32647 #else
32648 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32649 #endif
32650 }
32651 return resultobj;
32652 fail:
32653 return NULL;
32654 }
32655
32656
32657 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32658 PyObject *resultobj = 0;
32659 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32660 wxString *arg2 = 0 ;
32661 void *argp1 = 0 ;
32662 int res1 = 0 ;
32663 bool temp2 = false ;
32664 PyObject * obj0 = 0 ;
32665 PyObject * obj1 = 0 ;
32666 char * kwnames[] = {
32667 (char *) "self",(char *) "text", NULL
32668 };
32669
32670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32672 if (!SWIG_IsOK(res1)) {
32673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32674 }
32675 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32676 {
32677 arg2 = wxString_in_helper(obj1);
32678 if (arg2 == NULL) SWIG_fail;
32679 temp2 = true;
32680 }
32681 {
32682 PyThreadState* __tstate = wxPyBeginAllowThreads();
32683 (arg1)->SetText((wxString const &)*arg2);
32684 wxPyEndAllowThreads(__tstate);
32685 if (PyErr_Occurred()) SWIG_fail;
32686 }
32687 resultobj = SWIG_Py_Void();
32688 {
32689 if (temp2)
32690 delete arg2;
32691 }
32692 return resultobj;
32693 fail:
32694 {
32695 if (temp2)
32696 delete arg2;
32697 }
32698 return NULL;
32699 }
32700
32701
32702 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32703 PyObject *obj;
32704 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32705 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32706 return SWIG_Py_Void();
32707 }
32708
32709 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32710 return SWIG_Python_InitShadowInstance(args);
32711 }
32712
32713 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32714 PyObject *resultobj = 0;
32715 wxString const &arg1_defvalue = wxPyEmptyString ;
32716 wxString *arg1 = (wxString *) &arg1_defvalue ;
32717 wxPyTextDataObject *result = 0 ;
32718 bool temp1 = false ;
32719 PyObject * obj0 = 0 ;
32720 char * kwnames[] = {
32721 (char *) "text", NULL
32722 };
32723
32724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32725 if (obj0) {
32726 {
32727 arg1 = wxString_in_helper(obj0);
32728 if (arg1 == NULL) SWIG_fail;
32729 temp1 = true;
32730 }
32731 }
32732 {
32733 PyThreadState* __tstate = wxPyBeginAllowThreads();
32734 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32735 wxPyEndAllowThreads(__tstate);
32736 if (PyErr_Occurred()) SWIG_fail;
32737 }
32738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32739 {
32740 if (temp1)
32741 delete arg1;
32742 }
32743 return resultobj;
32744 fail:
32745 {
32746 if (temp1)
32747 delete arg1;
32748 }
32749 return NULL;
32750 }
32751
32752
32753 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32754 PyObject *resultobj = 0;
32755 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32756 PyObject *arg2 = (PyObject *) 0 ;
32757 PyObject *arg3 = (PyObject *) 0 ;
32758 void *argp1 = 0 ;
32759 int res1 = 0 ;
32760 PyObject * obj0 = 0 ;
32761 PyObject * obj1 = 0 ;
32762 PyObject * obj2 = 0 ;
32763 char * kwnames[] = {
32764 (char *) "self",(char *) "self",(char *) "_class", NULL
32765 };
32766
32767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32769 if (!SWIG_IsOK(res1)) {
32770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32771 }
32772 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32773 arg2 = obj1;
32774 arg3 = obj2;
32775 {
32776 PyThreadState* __tstate = wxPyBeginAllowThreads();
32777 (arg1)->_setCallbackInfo(arg2,arg3);
32778 wxPyEndAllowThreads(__tstate);
32779 if (PyErr_Occurred()) SWIG_fail;
32780 }
32781 resultobj = SWIG_Py_Void();
32782 return resultobj;
32783 fail:
32784 return NULL;
32785 }
32786
32787
32788 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32789 PyObject *obj;
32790 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32791 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32792 return SWIG_Py_Void();
32793 }
32794
32795 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32796 return SWIG_Python_InitShadowInstance(args);
32797 }
32798
32799 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32800 PyObject *resultobj = 0;
32801 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32802 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32803 wxBitmapDataObject *result = 0 ;
32804 void *argp1 = 0 ;
32805 int res1 = 0 ;
32806 PyObject * obj0 = 0 ;
32807 char * kwnames[] = {
32808 (char *) "bitmap", NULL
32809 };
32810
32811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
32812 if (obj0) {
32813 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
32814 if (!SWIG_IsOK(res1)) {
32815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32816 }
32817 if (!argp1) {
32818 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32819 }
32820 arg1 = reinterpret_cast< wxBitmap * >(argp1);
32821 }
32822 {
32823 PyThreadState* __tstate = wxPyBeginAllowThreads();
32824 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
32825 wxPyEndAllowThreads(__tstate);
32826 if (PyErr_Occurred()) SWIG_fail;
32827 }
32828 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
32829 return resultobj;
32830 fail:
32831 return NULL;
32832 }
32833
32834
32835 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32836 PyObject *resultobj = 0;
32837 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32838 wxBitmap result;
32839 void *argp1 = 0 ;
32840 int res1 = 0 ;
32841 PyObject *swig_obj[1] ;
32842
32843 if (!args) SWIG_fail;
32844 swig_obj[0] = args;
32845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
32846 if (!SWIG_IsOK(res1)) {
32847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
32848 }
32849 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
32850 {
32851 PyThreadState* __tstate = wxPyBeginAllowThreads();
32852 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
32853 wxPyEndAllowThreads(__tstate);
32854 if (PyErr_Occurred()) SWIG_fail;
32855 }
32856 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
32857 return resultobj;
32858 fail:
32859 return NULL;
32860 }
32861
32862
32863 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32864 PyObject *resultobj = 0;
32865 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32866 wxBitmap *arg2 = 0 ;
32867 void *argp1 = 0 ;
32868 int res1 = 0 ;
32869 void *argp2 = 0 ;
32870 int res2 = 0 ;
32871 PyObject * obj0 = 0 ;
32872 PyObject * obj1 = 0 ;
32873 char * kwnames[] = {
32874 (char *) "self",(char *) "bitmap", NULL
32875 };
32876
32877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
32878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
32879 if (!SWIG_IsOK(res1)) {
32880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
32881 }
32882 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
32883 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
32884 if (!SWIG_IsOK(res2)) {
32885 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
32886 }
32887 if (!argp2) {
32888 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
32889 }
32890 arg2 = reinterpret_cast< wxBitmap * >(argp2);
32891 {
32892 PyThreadState* __tstate = wxPyBeginAllowThreads();
32893 (arg1)->SetBitmap((wxBitmap const &)*arg2);
32894 wxPyEndAllowThreads(__tstate);
32895 if (PyErr_Occurred()) SWIG_fail;
32896 }
32897 resultobj = SWIG_Py_Void();
32898 return resultobj;
32899 fail:
32900 return NULL;
32901 }
32902
32903
32904 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32905 PyObject *obj;
32906 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32907 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
32908 return SWIG_Py_Void();
32909 }
32910
32911 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32912 return SWIG_Python_InitShadowInstance(args);
32913 }
32914
32915 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32916 PyObject *resultobj = 0;
32917 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32918 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32919 wxPyBitmapDataObject *result = 0 ;
32920 void *argp1 = 0 ;
32921 int res1 = 0 ;
32922 PyObject * obj0 = 0 ;
32923 char * kwnames[] = {
32924 (char *) "bitmap", NULL
32925 };
32926
32927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
32928 if (obj0) {
32929 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
32930 if (!SWIG_IsOK(res1)) {
32931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32932 }
32933 if (!argp1) {
32934 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32935 }
32936 arg1 = reinterpret_cast< wxBitmap * >(argp1);
32937 }
32938 {
32939 PyThreadState* __tstate = wxPyBeginAllowThreads();
32940 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
32941 wxPyEndAllowThreads(__tstate);
32942 if (PyErr_Occurred()) SWIG_fail;
32943 }
32944 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
32945 return resultobj;
32946 fail:
32947 return NULL;
32948 }
32949
32950
32951 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32952 PyObject *resultobj = 0;
32953 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
32954 PyObject *arg2 = (PyObject *) 0 ;
32955 PyObject *arg3 = (PyObject *) 0 ;
32956 void *argp1 = 0 ;
32957 int res1 = 0 ;
32958 PyObject * obj0 = 0 ;
32959 PyObject * obj1 = 0 ;
32960 PyObject * obj2 = 0 ;
32961 char * kwnames[] = {
32962 (char *) "self",(char *) "self",(char *) "_class", NULL
32963 };
32964
32965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
32967 if (!SWIG_IsOK(res1)) {
32968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
32969 }
32970 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
32971 arg2 = obj1;
32972 arg3 = obj2;
32973 {
32974 PyThreadState* __tstate = wxPyBeginAllowThreads();
32975 (arg1)->_setCallbackInfo(arg2,arg3);
32976 wxPyEndAllowThreads(__tstate);
32977 if (PyErr_Occurred()) SWIG_fail;
32978 }
32979 resultobj = SWIG_Py_Void();
32980 return resultobj;
32981 fail:
32982 return NULL;
32983 }
32984
32985
32986 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32987 PyObject *obj;
32988 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32989 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
32990 return SWIG_Py_Void();
32991 }
32992
32993 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32994 return SWIG_Python_InitShadowInstance(args);
32995 }
32996
32997 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32998 PyObject *resultobj = 0;
32999 wxFileDataObject *result = 0 ;
33000
33001 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33002 {
33003 PyThreadState* __tstate = wxPyBeginAllowThreads();
33004 result = (wxFileDataObject *)new wxFileDataObject();
33005 wxPyEndAllowThreads(__tstate);
33006 if (PyErr_Occurred()) SWIG_fail;
33007 }
33008 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33009 return resultobj;
33010 fail:
33011 return NULL;
33012 }
33013
33014
33015 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33016 PyObject *resultobj = 0;
33017 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33018 wxArrayString *result = 0 ;
33019 void *argp1 = 0 ;
33020 int res1 = 0 ;
33021 PyObject *swig_obj[1] ;
33022
33023 if (!args) SWIG_fail;
33024 swig_obj[0] = args;
33025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33026 if (!SWIG_IsOK(res1)) {
33027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33028 }
33029 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33030 {
33031 PyThreadState* __tstate = wxPyBeginAllowThreads();
33032 {
33033 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33034 result = (wxArrayString *) &_result_ref;
33035 }
33036 wxPyEndAllowThreads(__tstate);
33037 if (PyErr_Occurred()) SWIG_fail;
33038 }
33039 {
33040 resultobj = wxArrayString2PyList_helper(*result);
33041 }
33042 return resultobj;
33043 fail:
33044 return NULL;
33045 }
33046
33047
33048 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33049 PyObject *resultobj = 0;
33050 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33051 wxString *arg2 = 0 ;
33052 void *argp1 = 0 ;
33053 int res1 = 0 ;
33054 bool temp2 = false ;
33055 PyObject * obj0 = 0 ;
33056 PyObject * obj1 = 0 ;
33057 char * kwnames[] = {
33058 (char *) "self",(char *) "filename", NULL
33059 };
33060
33061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33063 if (!SWIG_IsOK(res1)) {
33064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33065 }
33066 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33067 {
33068 arg2 = wxString_in_helper(obj1);
33069 if (arg2 == NULL) SWIG_fail;
33070 temp2 = true;
33071 }
33072 {
33073 PyThreadState* __tstate = wxPyBeginAllowThreads();
33074 (arg1)->AddFile((wxString const &)*arg2);
33075 wxPyEndAllowThreads(__tstate);
33076 if (PyErr_Occurred()) SWIG_fail;
33077 }
33078 resultobj = SWIG_Py_Void();
33079 {
33080 if (temp2)
33081 delete arg2;
33082 }
33083 return resultobj;
33084 fail:
33085 {
33086 if (temp2)
33087 delete arg2;
33088 }
33089 return NULL;
33090 }
33091
33092
33093 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33094 PyObject *obj;
33095 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33096 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33097 return SWIG_Py_Void();
33098 }
33099
33100 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33101 return SWIG_Python_InitShadowInstance(args);
33102 }
33103
33104 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33105 PyObject *resultobj = 0;
33106 wxDataFormat *arg1 = 0 ;
33107 wxCustomDataObject *result = 0 ;
33108 void *argp1 = 0 ;
33109 int res1 = 0 ;
33110
33111 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33113 if (!SWIG_IsOK(res1)) {
33114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33115 }
33116 if (!argp1) {
33117 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33118 }
33119 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33120 {
33121 PyThreadState* __tstate = wxPyBeginAllowThreads();
33122 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33123 wxPyEndAllowThreads(__tstate);
33124 if (PyErr_Occurred()) SWIG_fail;
33125 }
33126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33127 return resultobj;
33128 fail:
33129 return NULL;
33130 }
33131
33132
33133 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33134 PyObject *resultobj = 0;
33135 wxString *arg1 = 0 ;
33136 wxCustomDataObject *result = 0 ;
33137 bool temp1 = false ;
33138
33139 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33140 {
33141 arg1 = wxString_in_helper(swig_obj[0]);
33142 if (arg1 == NULL) SWIG_fail;
33143 temp1 = true;
33144 }
33145 {
33146 PyThreadState* __tstate = wxPyBeginAllowThreads();
33147 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33148 wxPyEndAllowThreads(__tstate);
33149 if (PyErr_Occurred()) SWIG_fail;
33150 }
33151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33152 {
33153 if (temp1)
33154 delete arg1;
33155 }
33156 return resultobj;
33157 fail:
33158 {
33159 if (temp1)
33160 delete arg1;
33161 }
33162 return NULL;
33163 }
33164
33165
33166 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33167 PyObject *resultobj = 0;
33168 wxCustomDataObject *result = 0 ;
33169
33170 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33171 {
33172 PyThreadState* __tstate = wxPyBeginAllowThreads();
33173 result = (wxCustomDataObject *)new wxCustomDataObject();
33174 wxPyEndAllowThreads(__tstate);
33175 if (PyErr_Occurred()) SWIG_fail;
33176 }
33177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33178 return resultobj;
33179 fail:
33180 return NULL;
33181 }
33182
33183
33184 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33185 int argc;
33186 PyObject *argv[2];
33187
33188 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33189 --argc;
33190 if (argc == 0) {
33191 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33192 }
33193 if (argc == 1) {
33194 int _v = 0;
33195 {
33196 {
33197 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33198 }
33199 }
33200 if (!_v) goto check_2;
33201 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33202 }
33203 check_2:
33204
33205 if (argc == 1) {
33206 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33207 }
33208
33209 fail:
33210 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33211 return NULL;
33212 }
33213
33214
33215 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33216 PyObject *resultobj = 0;
33217 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33218 PyObject *arg2 = (PyObject *) 0 ;
33219 bool result;
33220 void *argp1 = 0 ;
33221 int res1 = 0 ;
33222 PyObject * obj0 = 0 ;
33223 PyObject * obj1 = 0 ;
33224 char * kwnames[] = {
33225 (char *) "self",(char *) "data", NULL
33226 };
33227
33228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33230 if (!SWIG_IsOK(res1)) {
33231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33232 }
33233 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33234 arg2 = obj1;
33235 {
33236 PyThreadState* __tstate = wxPyBeginAllowThreads();
33237 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33238 wxPyEndAllowThreads(__tstate);
33239 if (PyErr_Occurred()) SWIG_fail;
33240 }
33241 {
33242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33243 }
33244 return resultobj;
33245 fail:
33246 return NULL;
33247 }
33248
33249
33250 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33251 PyObject *resultobj = 0;
33252 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33253 size_t result;
33254 void *argp1 = 0 ;
33255 int res1 = 0 ;
33256 PyObject *swig_obj[1] ;
33257
33258 if (!args) SWIG_fail;
33259 swig_obj[0] = args;
33260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33261 if (!SWIG_IsOK(res1)) {
33262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33263 }
33264 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33265 {
33266 PyThreadState* __tstate = wxPyBeginAllowThreads();
33267 result = (size_t)(arg1)->GetSize();
33268 wxPyEndAllowThreads(__tstate);
33269 if (PyErr_Occurred()) SWIG_fail;
33270 }
33271 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33272 return resultobj;
33273 fail:
33274 return NULL;
33275 }
33276
33277
33278 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33279 PyObject *resultobj = 0;
33280 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33281 PyObject *result = 0 ;
33282 void *argp1 = 0 ;
33283 int res1 = 0 ;
33284 PyObject *swig_obj[1] ;
33285
33286 if (!args) SWIG_fail;
33287 swig_obj[0] = args;
33288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33289 if (!SWIG_IsOK(res1)) {
33290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33291 }
33292 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33293 {
33294 PyThreadState* __tstate = wxPyBeginAllowThreads();
33295 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33296 wxPyEndAllowThreads(__tstate);
33297 if (PyErr_Occurred()) SWIG_fail;
33298 }
33299 resultobj = result;
33300 return resultobj;
33301 fail:
33302 return NULL;
33303 }
33304
33305
33306 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33307 PyObject *obj;
33308 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33309 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33310 return SWIG_Py_Void();
33311 }
33312
33313 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33314 return SWIG_Python_InitShadowInstance(args);
33315 }
33316
33317 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33318 PyObject *resultobj = 0;
33319 wxString const &arg1_defvalue = wxPyEmptyString ;
33320 wxString *arg1 = (wxString *) &arg1_defvalue ;
33321 wxURLDataObject *result = 0 ;
33322 bool temp1 = false ;
33323 PyObject * obj0 = 0 ;
33324 char * kwnames[] = {
33325 (char *) "url", NULL
33326 };
33327
33328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33329 if (obj0) {
33330 {
33331 arg1 = wxString_in_helper(obj0);
33332 if (arg1 == NULL) SWIG_fail;
33333 temp1 = true;
33334 }
33335 }
33336 {
33337 PyThreadState* __tstate = wxPyBeginAllowThreads();
33338 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33339 wxPyEndAllowThreads(__tstate);
33340 if (PyErr_Occurred()) SWIG_fail;
33341 }
33342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33343 {
33344 if (temp1)
33345 delete arg1;
33346 }
33347 return resultobj;
33348 fail:
33349 {
33350 if (temp1)
33351 delete arg1;
33352 }
33353 return NULL;
33354 }
33355
33356
33357 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33358 PyObject *resultobj = 0;
33359 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33360 wxString result;
33361 void *argp1 = 0 ;
33362 int res1 = 0 ;
33363 PyObject *swig_obj[1] ;
33364
33365 if (!args) SWIG_fail;
33366 swig_obj[0] = args;
33367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33368 if (!SWIG_IsOK(res1)) {
33369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33370 }
33371 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33372 {
33373 PyThreadState* __tstate = wxPyBeginAllowThreads();
33374 result = (arg1)->GetURL();
33375 wxPyEndAllowThreads(__tstate);
33376 if (PyErr_Occurred()) SWIG_fail;
33377 }
33378 {
33379 #if wxUSE_UNICODE
33380 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33381 #else
33382 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33383 #endif
33384 }
33385 return resultobj;
33386 fail:
33387 return NULL;
33388 }
33389
33390
33391 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33392 PyObject *resultobj = 0;
33393 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33394 wxString *arg2 = 0 ;
33395 void *argp1 = 0 ;
33396 int res1 = 0 ;
33397 bool temp2 = false ;
33398 PyObject * obj0 = 0 ;
33399 PyObject * obj1 = 0 ;
33400 char * kwnames[] = {
33401 (char *) "self",(char *) "url", NULL
33402 };
33403
33404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33406 if (!SWIG_IsOK(res1)) {
33407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33408 }
33409 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33410 {
33411 arg2 = wxString_in_helper(obj1);
33412 if (arg2 == NULL) SWIG_fail;
33413 temp2 = true;
33414 }
33415 {
33416 PyThreadState* __tstate = wxPyBeginAllowThreads();
33417 (arg1)->SetURL((wxString const &)*arg2);
33418 wxPyEndAllowThreads(__tstate);
33419 if (PyErr_Occurred()) SWIG_fail;
33420 }
33421 resultobj = SWIG_Py_Void();
33422 {
33423 if (temp2)
33424 delete arg2;
33425 }
33426 return resultobj;
33427 fail:
33428 {
33429 if (temp2)
33430 delete arg2;
33431 }
33432 return NULL;
33433 }
33434
33435
33436 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33437 PyObject *obj;
33438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33439 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33440 return SWIG_Py_Void();
33441 }
33442
33443 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33444 return SWIG_Python_InitShadowInstance(args);
33445 }
33446
33447 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33448 PyObject *resultobj = 0;
33449 wxMetafileDataObject *result = 0 ;
33450
33451 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33452 {
33453 PyThreadState* __tstate = wxPyBeginAllowThreads();
33454 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33455 wxPyEndAllowThreads(__tstate);
33456 if (PyErr_Occurred()) SWIG_fail;
33457 }
33458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33459 return resultobj;
33460 fail:
33461 return NULL;
33462 }
33463
33464
33465 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33466 PyObject *resultobj = 0;
33467 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33468 wxMetafile *arg2 = 0 ;
33469 void *argp1 = 0 ;
33470 int res1 = 0 ;
33471 void *argp2 = 0 ;
33472 int res2 = 0 ;
33473 PyObject * obj0 = 0 ;
33474 PyObject * obj1 = 0 ;
33475 char * kwnames[] = {
33476 (char *) "self",(char *) "metafile", NULL
33477 };
33478
33479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
33480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33481 if (!SWIG_IsOK(res1)) {
33482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
33483 }
33484 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33485 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
33486 if (!SWIG_IsOK(res2)) {
33487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33488 }
33489 if (!argp2) {
33490 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33491 }
33492 arg2 = reinterpret_cast< wxMetafile * >(argp2);
33493 {
33494 PyThreadState* __tstate = wxPyBeginAllowThreads();
33495 (arg1)->SetMetafile((wxMetafile const &)*arg2);
33496 wxPyEndAllowThreads(__tstate);
33497 if (PyErr_Occurred()) SWIG_fail;
33498 }
33499 resultobj = SWIG_Py_Void();
33500 return resultobj;
33501 fail:
33502 return NULL;
33503 }
33504
33505
33506 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33507 PyObject *resultobj = 0;
33508 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33509 wxMetafile result;
33510 void *argp1 = 0 ;
33511 int res1 = 0 ;
33512 PyObject *swig_obj[1] ;
33513
33514 if (!args) SWIG_fail;
33515 swig_obj[0] = args;
33516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33517 if (!SWIG_IsOK(res1)) {
33518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
33519 }
33520 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33521 {
33522 PyThreadState* __tstate = wxPyBeginAllowThreads();
33523 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
33524 wxPyEndAllowThreads(__tstate);
33525 if (PyErr_Occurred()) SWIG_fail;
33526 }
33527 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
33528 return resultobj;
33529 fail:
33530 return NULL;
33531 }
33532
33533
33534 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33535 PyObject *obj;
33536 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33537 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33538 return SWIG_Py_Void();
33539 }
33540
33541 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33542 return SWIG_Python_InitShadowInstance(args);
33543 }
33544
33545 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33546 PyObject *resultobj = 0;
33547 wxDragResult arg1 ;
33548 bool result;
33549 int val1 ;
33550 int ecode1 = 0 ;
33551 PyObject * obj0 = 0 ;
33552 char * kwnames[] = {
33553 (char *) "res", NULL
33554 };
33555
33556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33557 ecode1 = SWIG_AsVal_int(obj0, &val1);
33558 if (!SWIG_IsOK(ecode1)) {
33559 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33560 }
33561 arg1 = static_cast< wxDragResult >(val1);
33562 {
33563 PyThreadState* __tstate = wxPyBeginAllowThreads();
33564 result = (bool)wxIsDragResultOk(arg1);
33565 wxPyEndAllowThreads(__tstate);
33566 if (PyErr_Occurred()) SWIG_fail;
33567 }
33568 {
33569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33570 }
33571 return resultobj;
33572 fail:
33573 return NULL;
33574 }
33575
33576
33577 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33578 PyObject *resultobj = 0;
33579 wxWindow *arg1 = (wxWindow *) 0 ;
33580 wxCursor const &arg2_defvalue = wxNullCursor ;
33581 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
33582 wxCursor const &arg3_defvalue = wxNullCursor ;
33583 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
33584 wxCursor const &arg4_defvalue = wxNullCursor ;
33585 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
33586 wxPyDropSource *result = 0 ;
33587 void *argp1 = 0 ;
33588 int res1 = 0 ;
33589 void *argp2 = 0 ;
33590 int res2 = 0 ;
33591 void *argp3 = 0 ;
33592 int res3 = 0 ;
33593 void *argp4 = 0 ;
33594 int res4 = 0 ;
33595 PyObject * obj0 = 0 ;
33596 PyObject * obj1 = 0 ;
33597 PyObject * obj2 = 0 ;
33598 PyObject * obj3 = 0 ;
33599 char * kwnames[] = {
33600 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33601 };
33602
33603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33605 if (!SWIG_IsOK(res1)) {
33606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33607 }
33608 arg1 = reinterpret_cast< wxWindow * >(argp1);
33609 if (obj1) {
33610 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
33611 if (!SWIG_IsOK(res2)) {
33612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33613 }
33614 if (!argp2) {
33615 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33616 }
33617 arg2 = reinterpret_cast< wxCursor * >(argp2);
33618 }
33619 if (obj2) {
33620 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33621 if (!SWIG_IsOK(res3)) {
33622 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33623 }
33624 if (!argp3) {
33625 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33626 }
33627 arg3 = reinterpret_cast< wxCursor * >(argp3);
33628 }
33629 if (obj3) {
33630 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
33631 if (!SWIG_IsOK(res4)) {
33632 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33633 }
33634 if (!argp4) {
33635 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33636 }
33637 arg4 = reinterpret_cast< wxCursor * >(argp4);
33638 }
33639 {
33640 PyThreadState* __tstate = wxPyBeginAllowThreads();
33641 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
33642 wxPyEndAllowThreads(__tstate);
33643 if (PyErr_Occurred()) SWIG_fail;
33644 }
33645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33646 return resultobj;
33647 fail:
33648 return NULL;
33649 }
33650
33651
33652 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33653 PyObject *resultobj = 0;
33654 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33655 PyObject *arg2 = (PyObject *) 0 ;
33656 PyObject *arg3 = (PyObject *) 0 ;
33657 int arg4 ;
33658 void *argp1 = 0 ;
33659 int res1 = 0 ;
33660 int val4 ;
33661 int ecode4 = 0 ;
33662 PyObject * obj0 = 0 ;
33663 PyObject * obj1 = 0 ;
33664 PyObject * obj2 = 0 ;
33665 PyObject * obj3 = 0 ;
33666 char * kwnames[] = {
33667 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33668 };
33669
33670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33672 if (!SWIG_IsOK(res1)) {
33673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33674 }
33675 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33676 arg2 = obj1;
33677 arg3 = obj2;
33678 ecode4 = SWIG_AsVal_int(obj3, &val4);
33679 if (!SWIG_IsOK(ecode4)) {
33680 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33681 }
33682 arg4 = static_cast< int >(val4);
33683 {
33684 PyThreadState* __tstate = wxPyBeginAllowThreads();
33685 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33686 wxPyEndAllowThreads(__tstate);
33687 if (PyErr_Occurred()) SWIG_fail;
33688 }
33689 resultobj = SWIG_Py_Void();
33690 return resultobj;
33691 fail:
33692 return NULL;
33693 }
33694
33695
33696 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33697 PyObject *resultobj = 0;
33698 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33699 void *argp1 = 0 ;
33700 int res1 = 0 ;
33701 PyObject *swig_obj[1] ;
33702
33703 if (!args) SWIG_fail;
33704 swig_obj[0] = args;
33705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33706 if (!SWIG_IsOK(res1)) {
33707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33708 }
33709 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33710 {
33711 PyThreadState* __tstate = wxPyBeginAllowThreads();
33712 delete arg1;
33713
33714 wxPyEndAllowThreads(__tstate);
33715 if (PyErr_Occurred()) SWIG_fail;
33716 }
33717 resultobj = SWIG_Py_Void();
33718 return resultobj;
33719 fail:
33720 return NULL;
33721 }
33722
33723
33724 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33725 PyObject *resultobj = 0;
33726 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33727 wxDataObject *arg2 = 0 ;
33728 void *argp1 = 0 ;
33729 int res1 = 0 ;
33730 void *argp2 = 0 ;
33731 int res2 = 0 ;
33732 PyObject * obj0 = 0 ;
33733 PyObject * obj1 = 0 ;
33734 char * kwnames[] = {
33735 (char *) "self",(char *) "data", NULL
33736 };
33737
33738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33740 if (!SWIG_IsOK(res1)) {
33741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33742 }
33743 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33744 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33745 if (!SWIG_IsOK(res2)) {
33746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33747 }
33748 if (!argp2) {
33749 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33750 }
33751 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33752 {
33753 PyThreadState* __tstate = wxPyBeginAllowThreads();
33754 (arg1)->SetData(*arg2);
33755 wxPyEndAllowThreads(__tstate);
33756 if (PyErr_Occurred()) SWIG_fail;
33757 }
33758 resultobj = SWIG_Py_Void();
33759 return resultobj;
33760 fail:
33761 return NULL;
33762 }
33763
33764
33765 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33766 PyObject *resultobj = 0;
33767 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33768 wxDataObject *result = 0 ;
33769 void *argp1 = 0 ;
33770 int res1 = 0 ;
33771 PyObject *swig_obj[1] ;
33772
33773 if (!args) SWIG_fail;
33774 swig_obj[0] = args;
33775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33776 if (!SWIG_IsOK(res1)) {
33777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33778 }
33779 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33780 {
33781 PyThreadState* __tstate = wxPyBeginAllowThreads();
33782 result = (wxDataObject *)(arg1)->GetDataObject();
33783 wxPyEndAllowThreads(__tstate);
33784 if (PyErr_Occurred()) SWIG_fail;
33785 }
33786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33787 return resultobj;
33788 fail:
33789 return NULL;
33790 }
33791
33792
33793 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33794 PyObject *resultobj = 0;
33795 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33796 wxDragResult arg2 ;
33797 wxCursor *arg3 = 0 ;
33798 void *argp1 = 0 ;
33799 int res1 = 0 ;
33800 int val2 ;
33801 int ecode2 = 0 ;
33802 void *argp3 = 0 ;
33803 int res3 = 0 ;
33804 PyObject * obj0 = 0 ;
33805 PyObject * obj1 = 0 ;
33806 PyObject * obj2 = 0 ;
33807 char * kwnames[] = {
33808 (char *) "self",(char *) "res",(char *) "cursor", NULL
33809 };
33810
33811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33813 if (!SWIG_IsOK(res1)) {
33814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33815 }
33816 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33817 ecode2 = SWIG_AsVal_int(obj1, &val2);
33818 if (!SWIG_IsOK(ecode2)) {
33819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
33820 }
33821 arg2 = static_cast< wxDragResult >(val2);
33822 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33823 if (!SWIG_IsOK(res3)) {
33824 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33825 }
33826 if (!argp3) {
33827 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33828 }
33829 arg3 = reinterpret_cast< wxCursor * >(argp3);
33830 {
33831 PyThreadState* __tstate = wxPyBeginAllowThreads();
33832 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
33833 wxPyEndAllowThreads(__tstate);
33834 if (PyErr_Occurred()) SWIG_fail;
33835 }
33836 resultobj = SWIG_Py_Void();
33837 return resultobj;
33838 fail:
33839 return NULL;
33840 }
33841
33842
33843 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33844 PyObject *resultobj = 0;
33845 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33846 int arg2 = (int) wxDrag_CopyOnly ;
33847 wxDragResult result;
33848 void *argp1 = 0 ;
33849 int res1 = 0 ;
33850 int val2 ;
33851 int ecode2 = 0 ;
33852 PyObject * obj0 = 0 ;
33853 PyObject * obj1 = 0 ;
33854 char * kwnames[] = {
33855 (char *) "self",(char *) "flags", NULL
33856 };
33857
33858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
33859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33860 if (!SWIG_IsOK(res1)) {
33861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33862 }
33863 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33864 if (obj1) {
33865 ecode2 = SWIG_AsVal_int(obj1, &val2);
33866 if (!SWIG_IsOK(ecode2)) {
33867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
33868 }
33869 arg2 = static_cast< int >(val2);
33870 }
33871 {
33872 PyThreadState* __tstate = wxPyBeginAllowThreads();
33873 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
33874 wxPyEndAllowThreads(__tstate);
33875 if (PyErr_Occurred()) SWIG_fail;
33876 }
33877 resultobj = SWIG_From_int(static_cast< int >(result));
33878 return resultobj;
33879 fail:
33880 return NULL;
33881 }
33882
33883
33884 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33885 PyObject *resultobj = 0;
33886 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33887 wxDragResult arg2 ;
33888 bool result;
33889 void *argp1 = 0 ;
33890 int res1 = 0 ;
33891 int val2 ;
33892 int ecode2 = 0 ;
33893 PyObject * obj0 = 0 ;
33894 PyObject * obj1 = 0 ;
33895 char * kwnames[] = {
33896 (char *) "self",(char *) "effect", NULL
33897 };
33898
33899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
33900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33901 if (!SWIG_IsOK(res1)) {
33902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33903 }
33904 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33905 ecode2 = SWIG_AsVal_int(obj1, &val2);
33906 if (!SWIG_IsOK(ecode2)) {
33907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
33908 }
33909 arg2 = static_cast< wxDragResult >(val2);
33910 {
33911 PyThreadState* __tstate = wxPyBeginAllowThreads();
33912 result = (bool)(arg1)->GiveFeedback(arg2);
33913 wxPyEndAllowThreads(__tstate);
33914 if (PyErr_Occurred()) SWIG_fail;
33915 }
33916 {
33917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33918 }
33919 return resultobj;
33920 fail:
33921 return NULL;
33922 }
33923
33924
33925 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33926 PyObject *obj;
33927 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33928 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
33929 return SWIG_Py_Void();
33930 }
33931
33932 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33933 return SWIG_Python_InitShadowInstance(args);
33934 }
33935
33936 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33937 PyObject *resultobj = 0;
33938 wxDataObject *arg1 = (wxDataObject *) NULL ;
33939 wxPyDropTarget *result = 0 ;
33940 int res1 = 0 ;
33941 PyObject * obj0 = 0 ;
33942 char * kwnames[] = {
33943 (char *) "dataObject", NULL
33944 };
33945
33946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
33947 if (obj0) {
33948 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
33949 if (!SWIG_IsOK(res1)) {
33950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
33951 }
33952 }
33953 {
33954 PyThreadState* __tstate = wxPyBeginAllowThreads();
33955 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
33956 wxPyEndAllowThreads(__tstate);
33957 if (PyErr_Occurred()) SWIG_fail;
33958 }
33959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
33960 return resultobj;
33961 fail:
33962 return NULL;
33963 }
33964
33965
33966 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33967 PyObject *resultobj = 0;
33968 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33969 PyObject *arg2 = (PyObject *) 0 ;
33970 PyObject *arg3 = (PyObject *) 0 ;
33971 void *argp1 = 0 ;
33972 int res1 = 0 ;
33973 PyObject * obj0 = 0 ;
33974 PyObject * obj1 = 0 ;
33975 PyObject * obj2 = 0 ;
33976 char * kwnames[] = {
33977 (char *) "self",(char *) "self",(char *) "_class", NULL
33978 };
33979
33980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33982 if (!SWIG_IsOK(res1)) {
33983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33984 }
33985 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33986 arg2 = obj1;
33987 arg3 = obj2;
33988 {
33989 PyThreadState* __tstate = wxPyBeginAllowThreads();
33990 (arg1)->_setCallbackInfo(arg2,arg3);
33991 wxPyEndAllowThreads(__tstate);
33992 if (PyErr_Occurred()) SWIG_fail;
33993 }
33994 resultobj = SWIG_Py_Void();
33995 return resultobj;
33996 fail:
33997 return NULL;
33998 }
33999
34000
34001 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34002 PyObject *resultobj = 0;
34003 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34004 void *argp1 = 0 ;
34005 int res1 = 0 ;
34006 PyObject *swig_obj[1] ;
34007
34008 if (!args) SWIG_fail;
34009 swig_obj[0] = args;
34010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34011 if (!SWIG_IsOK(res1)) {
34012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34013 }
34014 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34015 {
34016 PyThreadState* __tstate = wxPyBeginAllowThreads();
34017 delete arg1;
34018
34019 wxPyEndAllowThreads(__tstate);
34020 if (PyErr_Occurred()) SWIG_fail;
34021 }
34022 resultobj = SWIG_Py_Void();
34023 return resultobj;
34024 fail:
34025 return NULL;
34026 }
34027
34028
34029 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34030 PyObject *resultobj = 0;
34031 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34032 wxDataObject *result = 0 ;
34033 void *argp1 = 0 ;
34034 int res1 = 0 ;
34035 PyObject *swig_obj[1] ;
34036
34037 if (!args) SWIG_fail;
34038 swig_obj[0] = args;
34039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34040 if (!SWIG_IsOK(res1)) {
34041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34042 }
34043 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34044 {
34045 PyThreadState* __tstate = wxPyBeginAllowThreads();
34046 result = (wxDataObject *)(arg1)->GetDataObject();
34047 wxPyEndAllowThreads(__tstate);
34048 if (PyErr_Occurred()) SWIG_fail;
34049 }
34050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34051 return resultobj;
34052 fail:
34053 return NULL;
34054 }
34055
34056
34057 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34058 PyObject *resultobj = 0;
34059 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34060 wxDataObject *arg2 = (wxDataObject *) 0 ;
34061 void *argp1 = 0 ;
34062 int res1 = 0 ;
34063 int res2 = 0 ;
34064 PyObject * obj0 = 0 ;
34065 PyObject * obj1 = 0 ;
34066 char * kwnames[] = {
34067 (char *) "self",(char *) "dataObject", NULL
34068 };
34069
34070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34072 if (!SWIG_IsOK(res1)) {
34073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34074 }
34075 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34076 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34077 if (!SWIG_IsOK(res2)) {
34078 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34079 }
34080 {
34081 PyThreadState* __tstate = wxPyBeginAllowThreads();
34082 (arg1)->SetDataObject(arg2);
34083 wxPyEndAllowThreads(__tstate);
34084 if (PyErr_Occurred()) SWIG_fail;
34085 }
34086 resultobj = SWIG_Py_Void();
34087 return resultobj;
34088 fail:
34089 return NULL;
34090 }
34091
34092
34093 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34094 PyObject *resultobj = 0;
34095 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34096 int arg2 ;
34097 int arg3 ;
34098 wxDragResult arg4 ;
34099 wxDragResult result;
34100 void *argp1 = 0 ;
34101 int res1 = 0 ;
34102 int val2 ;
34103 int ecode2 = 0 ;
34104 int val3 ;
34105 int ecode3 = 0 ;
34106 int val4 ;
34107 int ecode4 = 0 ;
34108 PyObject * obj0 = 0 ;
34109 PyObject * obj1 = 0 ;
34110 PyObject * obj2 = 0 ;
34111 PyObject * obj3 = 0 ;
34112 char * kwnames[] = {
34113 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34114 };
34115
34116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34118 if (!SWIG_IsOK(res1)) {
34119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34120 }
34121 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34122 ecode2 = SWIG_AsVal_int(obj1, &val2);
34123 if (!SWIG_IsOK(ecode2)) {
34124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34125 }
34126 arg2 = static_cast< int >(val2);
34127 ecode3 = SWIG_AsVal_int(obj2, &val3);
34128 if (!SWIG_IsOK(ecode3)) {
34129 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34130 }
34131 arg3 = static_cast< int >(val3);
34132 ecode4 = SWIG_AsVal_int(obj3, &val4);
34133 if (!SWIG_IsOK(ecode4)) {
34134 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34135 }
34136 arg4 = static_cast< wxDragResult >(val4);
34137 {
34138 PyThreadState* __tstate = wxPyBeginAllowThreads();
34139 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34140 wxPyEndAllowThreads(__tstate);
34141 if (PyErr_Occurred()) SWIG_fail;
34142 }
34143 resultobj = SWIG_From_int(static_cast< int >(result));
34144 return resultobj;
34145 fail:
34146 return NULL;
34147 }
34148
34149
34150 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34151 PyObject *resultobj = 0;
34152 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34153 int arg2 ;
34154 int arg3 ;
34155 wxDragResult arg4 ;
34156 wxDragResult result;
34157 void *argp1 = 0 ;
34158 int res1 = 0 ;
34159 int val2 ;
34160 int ecode2 = 0 ;
34161 int val3 ;
34162 int ecode3 = 0 ;
34163 int val4 ;
34164 int ecode4 = 0 ;
34165 PyObject * obj0 = 0 ;
34166 PyObject * obj1 = 0 ;
34167 PyObject * obj2 = 0 ;
34168 PyObject * obj3 = 0 ;
34169 char * kwnames[] = {
34170 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34171 };
34172
34173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34175 if (!SWIG_IsOK(res1)) {
34176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34177 }
34178 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34179 ecode2 = SWIG_AsVal_int(obj1, &val2);
34180 if (!SWIG_IsOK(ecode2)) {
34181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34182 }
34183 arg2 = static_cast< int >(val2);
34184 ecode3 = SWIG_AsVal_int(obj2, &val3);
34185 if (!SWIG_IsOK(ecode3)) {
34186 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34187 }
34188 arg3 = static_cast< int >(val3);
34189 ecode4 = SWIG_AsVal_int(obj3, &val4);
34190 if (!SWIG_IsOK(ecode4)) {
34191 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34192 }
34193 arg4 = static_cast< wxDragResult >(val4);
34194 {
34195 PyThreadState* __tstate = wxPyBeginAllowThreads();
34196 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34197 wxPyEndAllowThreads(__tstate);
34198 if (PyErr_Occurred()) SWIG_fail;
34199 }
34200 resultobj = SWIG_From_int(static_cast< int >(result));
34201 return resultobj;
34202 fail:
34203 return NULL;
34204 }
34205
34206
34207 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34208 PyObject *resultobj = 0;
34209 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34210 void *argp1 = 0 ;
34211 int res1 = 0 ;
34212 PyObject *swig_obj[1] ;
34213
34214 if (!args) SWIG_fail;
34215 swig_obj[0] = args;
34216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34217 if (!SWIG_IsOK(res1)) {
34218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34219 }
34220 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34221 {
34222 PyThreadState* __tstate = wxPyBeginAllowThreads();
34223 (arg1)->OnLeave();
34224 wxPyEndAllowThreads(__tstate);
34225 if (PyErr_Occurred()) SWIG_fail;
34226 }
34227 resultobj = SWIG_Py_Void();
34228 return resultobj;
34229 fail:
34230 return NULL;
34231 }
34232
34233
34234 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34235 PyObject *resultobj = 0;
34236 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34237 int arg2 ;
34238 int arg3 ;
34239 bool result;
34240 void *argp1 = 0 ;
34241 int res1 = 0 ;
34242 int val2 ;
34243 int ecode2 = 0 ;
34244 int val3 ;
34245 int ecode3 = 0 ;
34246 PyObject * obj0 = 0 ;
34247 PyObject * obj1 = 0 ;
34248 PyObject * obj2 = 0 ;
34249 char * kwnames[] = {
34250 (char *) "self",(char *) "x",(char *) "y", NULL
34251 };
34252
34253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34255 if (!SWIG_IsOK(res1)) {
34256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34257 }
34258 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34259 ecode2 = SWIG_AsVal_int(obj1, &val2);
34260 if (!SWIG_IsOK(ecode2)) {
34261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34262 }
34263 arg2 = static_cast< int >(val2);
34264 ecode3 = SWIG_AsVal_int(obj2, &val3);
34265 if (!SWIG_IsOK(ecode3)) {
34266 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34267 }
34268 arg3 = static_cast< int >(val3);
34269 {
34270 PyThreadState* __tstate = wxPyBeginAllowThreads();
34271 result = (bool)(arg1)->OnDrop(arg2,arg3);
34272 wxPyEndAllowThreads(__tstate);
34273 if (PyErr_Occurred()) SWIG_fail;
34274 }
34275 {
34276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34277 }
34278 return resultobj;
34279 fail:
34280 return NULL;
34281 }
34282
34283
34284 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34285 PyObject *resultobj = 0;
34286 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34287 bool result;
34288 void *argp1 = 0 ;
34289 int res1 = 0 ;
34290 PyObject *swig_obj[1] ;
34291
34292 if (!args) SWIG_fail;
34293 swig_obj[0] = args;
34294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34295 if (!SWIG_IsOK(res1)) {
34296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34297 }
34298 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34299 {
34300 PyThreadState* __tstate = wxPyBeginAllowThreads();
34301 result = (bool)(arg1)->GetData();
34302 wxPyEndAllowThreads(__tstate);
34303 if (PyErr_Occurred()) SWIG_fail;
34304 }
34305 {
34306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34307 }
34308 return resultobj;
34309 fail:
34310 return NULL;
34311 }
34312
34313
34314 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34315 PyObject *resultobj = 0;
34316 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34317 wxDragResult arg2 ;
34318 void *argp1 = 0 ;
34319 int res1 = 0 ;
34320 int val2 ;
34321 int ecode2 = 0 ;
34322 PyObject * obj0 = 0 ;
34323 PyObject * obj1 = 0 ;
34324 char * kwnames[] = {
34325 (char *) "self",(char *) "action", NULL
34326 };
34327
34328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34330 if (!SWIG_IsOK(res1)) {
34331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34332 }
34333 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34334 ecode2 = SWIG_AsVal_int(obj1, &val2);
34335 if (!SWIG_IsOK(ecode2)) {
34336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34337 }
34338 arg2 = static_cast< wxDragResult >(val2);
34339 {
34340 PyThreadState* __tstate = wxPyBeginAllowThreads();
34341 (arg1)->SetDefaultAction(arg2);
34342 wxPyEndAllowThreads(__tstate);
34343 if (PyErr_Occurred()) SWIG_fail;
34344 }
34345 resultobj = SWIG_Py_Void();
34346 return resultobj;
34347 fail:
34348 return NULL;
34349 }
34350
34351
34352 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34353 PyObject *resultobj = 0;
34354 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34355 wxDragResult result;
34356 void *argp1 = 0 ;
34357 int res1 = 0 ;
34358 PyObject *swig_obj[1] ;
34359
34360 if (!args) SWIG_fail;
34361 swig_obj[0] = args;
34362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34363 if (!SWIG_IsOK(res1)) {
34364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34365 }
34366 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34367 {
34368 PyThreadState* __tstate = wxPyBeginAllowThreads();
34369 result = (wxDragResult)(arg1)->GetDefaultAction();
34370 wxPyEndAllowThreads(__tstate);
34371 if (PyErr_Occurred()) SWIG_fail;
34372 }
34373 resultobj = SWIG_From_int(static_cast< int >(result));
34374 return resultobj;
34375 fail:
34376 return NULL;
34377 }
34378
34379
34380 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34381 PyObject *obj;
34382 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34383 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34384 return SWIG_Py_Void();
34385 }
34386
34387 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34388 return SWIG_Python_InitShadowInstance(args);
34389 }
34390
34391 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34392 PyObject *resultobj = 0;
34393 wxPyTextDropTarget *result = 0 ;
34394
34395 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34396 {
34397 PyThreadState* __tstate = wxPyBeginAllowThreads();
34398 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34399 wxPyEndAllowThreads(__tstate);
34400 if (PyErr_Occurred()) SWIG_fail;
34401 }
34402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34403 return resultobj;
34404 fail:
34405 return NULL;
34406 }
34407
34408
34409 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34410 PyObject *resultobj = 0;
34411 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34412 PyObject *arg2 = (PyObject *) 0 ;
34413 PyObject *arg3 = (PyObject *) 0 ;
34414 void *argp1 = 0 ;
34415 int res1 = 0 ;
34416 PyObject * obj0 = 0 ;
34417 PyObject * obj1 = 0 ;
34418 PyObject * obj2 = 0 ;
34419 char * kwnames[] = {
34420 (char *) "self",(char *) "self",(char *) "_class", NULL
34421 };
34422
34423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34425 if (!SWIG_IsOK(res1)) {
34426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34427 }
34428 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34429 arg2 = obj1;
34430 arg3 = obj2;
34431 {
34432 PyThreadState* __tstate = wxPyBeginAllowThreads();
34433 (arg1)->_setCallbackInfo(arg2,arg3);
34434 wxPyEndAllowThreads(__tstate);
34435 if (PyErr_Occurred()) SWIG_fail;
34436 }
34437 resultobj = SWIG_Py_Void();
34438 return resultobj;
34439 fail:
34440 return NULL;
34441 }
34442
34443
34444 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34445 PyObject *resultobj = 0;
34446 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34447 int arg2 ;
34448 int arg3 ;
34449 wxString *arg4 = 0 ;
34450 bool result;
34451 void *argp1 = 0 ;
34452 int res1 = 0 ;
34453 int val2 ;
34454 int ecode2 = 0 ;
34455 int val3 ;
34456 int ecode3 = 0 ;
34457 bool temp4 = false ;
34458 PyObject * obj0 = 0 ;
34459 PyObject * obj1 = 0 ;
34460 PyObject * obj2 = 0 ;
34461 PyObject * obj3 = 0 ;
34462 char * kwnames[] = {
34463 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34464 };
34465
34466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34468 if (!SWIG_IsOK(res1)) {
34469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34470 }
34471 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34472 ecode2 = SWIG_AsVal_int(obj1, &val2);
34473 if (!SWIG_IsOK(ecode2)) {
34474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34475 }
34476 arg2 = static_cast< int >(val2);
34477 ecode3 = SWIG_AsVal_int(obj2, &val3);
34478 if (!SWIG_IsOK(ecode3)) {
34479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34480 }
34481 arg3 = static_cast< int >(val3);
34482 {
34483 arg4 = wxString_in_helper(obj3);
34484 if (arg4 == NULL) SWIG_fail;
34485 temp4 = true;
34486 }
34487 {
34488 PyThreadState* __tstate = wxPyBeginAllowThreads();
34489 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34490 wxPyEndAllowThreads(__tstate);
34491 if (PyErr_Occurred()) SWIG_fail;
34492 }
34493 {
34494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34495 }
34496 {
34497 if (temp4)
34498 delete arg4;
34499 }
34500 return resultobj;
34501 fail:
34502 {
34503 if (temp4)
34504 delete arg4;
34505 }
34506 return NULL;
34507 }
34508
34509
34510 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34511 PyObject *resultobj = 0;
34512 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34513 int arg2 ;
34514 int arg3 ;
34515 wxDragResult arg4 ;
34516 wxDragResult result;
34517 void *argp1 = 0 ;
34518 int res1 = 0 ;
34519 int val2 ;
34520 int ecode2 = 0 ;
34521 int val3 ;
34522 int ecode3 = 0 ;
34523 int val4 ;
34524 int ecode4 = 0 ;
34525 PyObject * obj0 = 0 ;
34526 PyObject * obj1 = 0 ;
34527 PyObject * obj2 = 0 ;
34528 PyObject * obj3 = 0 ;
34529 char * kwnames[] = {
34530 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34531 };
34532
34533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34535 if (!SWIG_IsOK(res1)) {
34536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34537 }
34538 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34539 ecode2 = SWIG_AsVal_int(obj1, &val2);
34540 if (!SWIG_IsOK(ecode2)) {
34541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34542 }
34543 arg2 = static_cast< int >(val2);
34544 ecode3 = SWIG_AsVal_int(obj2, &val3);
34545 if (!SWIG_IsOK(ecode3)) {
34546 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34547 }
34548 arg3 = static_cast< int >(val3);
34549 ecode4 = SWIG_AsVal_int(obj3, &val4);
34550 if (!SWIG_IsOK(ecode4)) {
34551 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34552 }
34553 arg4 = static_cast< wxDragResult >(val4);
34554 {
34555 PyThreadState* __tstate = wxPyBeginAllowThreads();
34556 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34557 wxPyEndAllowThreads(__tstate);
34558 if (PyErr_Occurred()) SWIG_fail;
34559 }
34560 resultobj = SWIG_From_int(static_cast< int >(result));
34561 return resultobj;
34562 fail:
34563 return NULL;
34564 }
34565
34566
34567 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34568 PyObject *resultobj = 0;
34569 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34570 int arg2 ;
34571 int arg3 ;
34572 wxDragResult arg4 ;
34573 wxDragResult result;
34574 void *argp1 = 0 ;
34575 int res1 = 0 ;
34576 int val2 ;
34577 int ecode2 = 0 ;
34578 int val3 ;
34579 int ecode3 = 0 ;
34580 int val4 ;
34581 int ecode4 = 0 ;
34582 PyObject * obj0 = 0 ;
34583 PyObject * obj1 = 0 ;
34584 PyObject * obj2 = 0 ;
34585 PyObject * obj3 = 0 ;
34586 char * kwnames[] = {
34587 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34588 };
34589
34590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34592 if (!SWIG_IsOK(res1)) {
34593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34594 }
34595 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34596 ecode2 = SWIG_AsVal_int(obj1, &val2);
34597 if (!SWIG_IsOK(ecode2)) {
34598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34599 }
34600 arg2 = static_cast< int >(val2);
34601 ecode3 = SWIG_AsVal_int(obj2, &val3);
34602 if (!SWIG_IsOK(ecode3)) {
34603 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34604 }
34605 arg3 = static_cast< int >(val3);
34606 ecode4 = SWIG_AsVal_int(obj3, &val4);
34607 if (!SWIG_IsOK(ecode4)) {
34608 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34609 }
34610 arg4 = static_cast< wxDragResult >(val4);
34611 {
34612 PyThreadState* __tstate = wxPyBeginAllowThreads();
34613 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34614 wxPyEndAllowThreads(__tstate);
34615 if (PyErr_Occurred()) SWIG_fail;
34616 }
34617 resultobj = SWIG_From_int(static_cast< int >(result));
34618 return resultobj;
34619 fail:
34620 return NULL;
34621 }
34622
34623
34624 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34625 PyObject *resultobj = 0;
34626 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34627 void *argp1 = 0 ;
34628 int res1 = 0 ;
34629 PyObject *swig_obj[1] ;
34630
34631 if (!args) SWIG_fail;
34632 swig_obj[0] = args;
34633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34634 if (!SWIG_IsOK(res1)) {
34635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34636 }
34637 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34638 {
34639 PyThreadState* __tstate = wxPyBeginAllowThreads();
34640 (arg1)->OnLeave();
34641 wxPyEndAllowThreads(__tstate);
34642 if (PyErr_Occurred()) SWIG_fail;
34643 }
34644 resultobj = SWIG_Py_Void();
34645 return resultobj;
34646 fail:
34647 return NULL;
34648 }
34649
34650
34651 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34652 PyObject *resultobj = 0;
34653 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34654 int arg2 ;
34655 int arg3 ;
34656 bool result;
34657 void *argp1 = 0 ;
34658 int res1 = 0 ;
34659 int val2 ;
34660 int ecode2 = 0 ;
34661 int val3 ;
34662 int ecode3 = 0 ;
34663 PyObject * obj0 = 0 ;
34664 PyObject * obj1 = 0 ;
34665 PyObject * obj2 = 0 ;
34666 char * kwnames[] = {
34667 (char *) "self",(char *) "x",(char *) "y", NULL
34668 };
34669
34670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34672 if (!SWIG_IsOK(res1)) {
34673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34674 }
34675 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34676 ecode2 = SWIG_AsVal_int(obj1, &val2);
34677 if (!SWIG_IsOK(ecode2)) {
34678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34679 }
34680 arg2 = static_cast< int >(val2);
34681 ecode3 = SWIG_AsVal_int(obj2, &val3);
34682 if (!SWIG_IsOK(ecode3)) {
34683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34684 }
34685 arg3 = static_cast< int >(val3);
34686 {
34687 PyThreadState* __tstate = wxPyBeginAllowThreads();
34688 result = (bool)(arg1)->OnDrop(arg2,arg3);
34689 wxPyEndAllowThreads(__tstate);
34690 if (PyErr_Occurred()) SWIG_fail;
34691 }
34692 {
34693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34694 }
34695 return resultobj;
34696 fail:
34697 return NULL;
34698 }
34699
34700
34701 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34702 PyObject *resultobj = 0;
34703 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34704 int arg2 ;
34705 int arg3 ;
34706 wxDragResult arg4 ;
34707 wxDragResult result;
34708 void *argp1 = 0 ;
34709 int res1 = 0 ;
34710 int val2 ;
34711 int ecode2 = 0 ;
34712 int val3 ;
34713 int ecode3 = 0 ;
34714 int val4 ;
34715 int ecode4 = 0 ;
34716 PyObject * obj0 = 0 ;
34717 PyObject * obj1 = 0 ;
34718 PyObject * obj2 = 0 ;
34719 PyObject * obj3 = 0 ;
34720 char * kwnames[] = {
34721 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34722 };
34723
34724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34726 if (!SWIG_IsOK(res1)) {
34727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34728 }
34729 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34730 ecode2 = SWIG_AsVal_int(obj1, &val2);
34731 if (!SWIG_IsOK(ecode2)) {
34732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34733 }
34734 arg2 = static_cast< int >(val2);
34735 ecode3 = SWIG_AsVal_int(obj2, &val3);
34736 if (!SWIG_IsOK(ecode3)) {
34737 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34738 }
34739 arg3 = static_cast< int >(val3);
34740 ecode4 = SWIG_AsVal_int(obj3, &val4);
34741 if (!SWIG_IsOK(ecode4)) {
34742 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34743 }
34744 arg4 = static_cast< wxDragResult >(val4);
34745 {
34746 PyThreadState* __tstate = wxPyBeginAllowThreads();
34747 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34748 wxPyEndAllowThreads(__tstate);
34749 if (PyErr_Occurred()) SWIG_fail;
34750 }
34751 resultobj = SWIG_From_int(static_cast< int >(result));
34752 return resultobj;
34753 fail:
34754 return NULL;
34755 }
34756
34757
34758 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34759 PyObject *obj;
34760 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34761 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34762 return SWIG_Py_Void();
34763 }
34764
34765 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34766 return SWIG_Python_InitShadowInstance(args);
34767 }
34768
34769 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34770 PyObject *resultobj = 0;
34771 wxPyFileDropTarget *result = 0 ;
34772
34773 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34774 {
34775 PyThreadState* __tstate = wxPyBeginAllowThreads();
34776 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34777 wxPyEndAllowThreads(__tstate);
34778 if (PyErr_Occurred()) SWIG_fail;
34779 }
34780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34781 return resultobj;
34782 fail:
34783 return NULL;
34784 }
34785
34786
34787 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34788 PyObject *resultobj = 0;
34789 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34790 PyObject *arg2 = (PyObject *) 0 ;
34791 PyObject *arg3 = (PyObject *) 0 ;
34792 void *argp1 = 0 ;
34793 int res1 = 0 ;
34794 PyObject * obj0 = 0 ;
34795 PyObject * obj1 = 0 ;
34796 PyObject * obj2 = 0 ;
34797 char * kwnames[] = {
34798 (char *) "self",(char *) "self",(char *) "_class", NULL
34799 };
34800
34801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34803 if (!SWIG_IsOK(res1)) {
34804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34805 }
34806 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34807 arg2 = obj1;
34808 arg3 = obj2;
34809 {
34810 PyThreadState* __tstate = wxPyBeginAllowThreads();
34811 (arg1)->_setCallbackInfo(arg2,arg3);
34812 wxPyEndAllowThreads(__tstate);
34813 if (PyErr_Occurred()) SWIG_fail;
34814 }
34815 resultobj = SWIG_Py_Void();
34816 return resultobj;
34817 fail:
34818 return NULL;
34819 }
34820
34821
34822 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34823 PyObject *resultobj = 0;
34824 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34825 int arg2 ;
34826 int arg3 ;
34827 wxArrayString *arg4 = 0 ;
34828 bool result;
34829 void *argp1 = 0 ;
34830 int res1 = 0 ;
34831 int val2 ;
34832 int ecode2 = 0 ;
34833 int val3 ;
34834 int ecode3 = 0 ;
34835 bool temp4 = false ;
34836 PyObject * obj0 = 0 ;
34837 PyObject * obj1 = 0 ;
34838 PyObject * obj2 = 0 ;
34839 PyObject * obj3 = 0 ;
34840 char * kwnames[] = {
34841 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
34842 };
34843
34844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34846 if (!SWIG_IsOK(res1)) {
34847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34848 }
34849 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34850 ecode2 = SWIG_AsVal_int(obj1, &val2);
34851 if (!SWIG_IsOK(ecode2)) {
34852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
34853 }
34854 arg2 = static_cast< int >(val2);
34855 ecode3 = SWIG_AsVal_int(obj2, &val3);
34856 if (!SWIG_IsOK(ecode3)) {
34857 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
34858 }
34859 arg3 = static_cast< int >(val3);
34860 {
34861 if (! PySequence_Check(obj3)) {
34862 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
34863 SWIG_fail;
34864 }
34865 arg4 = new wxArrayString;
34866 temp4 = true;
34867 int i, len=PySequence_Length(obj3);
34868 for (i=0; i<len; i++) {
34869 PyObject* item = PySequence_GetItem(obj3, i);
34870 wxString* s = wxString_in_helper(item);
34871 if (PyErr_Occurred()) SWIG_fail;
34872 arg4->Add(*s);
34873 delete s;
34874 Py_DECREF(item);
34875 }
34876 }
34877 {
34878 PyThreadState* __tstate = wxPyBeginAllowThreads();
34879 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
34880 wxPyEndAllowThreads(__tstate);
34881 if (PyErr_Occurred()) SWIG_fail;
34882 }
34883 {
34884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34885 }
34886 {
34887 if (temp4) delete arg4;
34888 }
34889 return resultobj;
34890 fail:
34891 {
34892 if (temp4) delete arg4;
34893 }
34894 return NULL;
34895 }
34896
34897
34898 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34899 PyObject *resultobj = 0;
34900 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34901 int arg2 ;
34902 int arg3 ;
34903 wxDragResult arg4 ;
34904 wxDragResult result;
34905 void *argp1 = 0 ;
34906 int res1 = 0 ;
34907 int val2 ;
34908 int ecode2 = 0 ;
34909 int val3 ;
34910 int ecode3 = 0 ;
34911 int val4 ;
34912 int ecode4 = 0 ;
34913 PyObject * obj0 = 0 ;
34914 PyObject * obj1 = 0 ;
34915 PyObject * obj2 = 0 ;
34916 PyObject * obj3 = 0 ;
34917 char * kwnames[] = {
34918 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34919 };
34920
34921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34923 if (!SWIG_IsOK(res1)) {
34924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34925 }
34926 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34927 ecode2 = SWIG_AsVal_int(obj1, &val2);
34928 if (!SWIG_IsOK(ecode2)) {
34929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34930 }
34931 arg2 = static_cast< int >(val2);
34932 ecode3 = SWIG_AsVal_int(obj2, &val3);
34933 if (!SWIG_IsOK(ecode3)) {
34934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34935 }
34936 arg3 = static_cast< int >(val3);
34937 ecode4 = SWIG_AsVal_int(obj3, &val4);
34938 if (!SWIG_IsOK(ecode4)) {
34939 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34940 }
34941 arg4 = static_cast< wxDragResult >(val4);
34942 {
34943 PyThreadState* __tstate = wxPyBeginAllowThreads();
34944 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34945 wxPyEndAllowThreads(__tstate);
34946 if (PyErr_Occurred()) SWIG_fail;
34947 }
34948 resultobj = SWIG_From_int(static_cast< int >(result));
34949 return resultobj;
34950 fail:
34951 return NULL;
34952 }
34953
34954
34955 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34956 PyObject *resultobj = 0;
34957 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34958 int arg2 ;
34959 int arg3 ;
34960 wxDragResult arg4 ;
34961 wxDragResult result;
34962 void *argp1 = 0 ;
34963 int res1 = 0 ;
34964 int val2 ;
34965 int ecode2 = 0 ;
34966 int val3 ;
34967 int ecode3 = 0 ;
34968 int val4 ;
34969 int ecode4 = 0 ;
34970 PyObject * obj0 = 0 ;
34971 PyObject * obj1 = 0 ;
34972 PyObject * obj2 = 0 ;
34973 PyObject * obj3 = 0 ;
34974 char * kwnames[] = {
34975 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34976 };
34977
34978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34980 if (!SWIG_IsOK(res1)) {
34981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34982 }
34983 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34984 ecode2 = SWIG_AsVal_int(obj1, &val2);
34985 if (!SWIG_IsOK(ecode2)) {
34986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34987 }
34988 arg2 = static_cast< int >(val2);
34989 ecode3 = SWIG_AsVal_int(obj2, &val3);
34990 if (!SWIG_IsOK(ecode3)) {
34991 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34992 }
34993 arg3 = static_cast< int >(val3);
34994 ecode4 = SWIG_AsVal_int(obj3, &val4);
34995 if (!SWIG_IsOK(ecode4)) {
34996 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34997 }
34998 arg4 = static_cast< wxDragResult >(val4);
34999 {
35000 PyThreadState* __tstate = wxPyBeginAllowThreads();
35001 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35002 wxPyEndAllowThreads(__tstate);
35003 if (PyErr_Occurred()) SWIG_fail;
35004 }
35005 resultobj = SWIG_From_int(static_cast< int >(result));
35006 return resultobj;
35007 fail:
35008 return NULL;
35009 }
35010
35011
35012 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35013 PyObject *resultobj = 0;
35014 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35015 void *argp1 = 0 ;
35016 int res1 = 0 ;
35017 PyObject *swig_obj[1] ;
35018
35019 if (!args) SWIG_fail;
35020 swig_obj[0] = args;
35021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35022 if (!SWIG_IsOK(res1)) {
35023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35024 }
35025 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35026 {
35027 PyThreadState* __tstate = wxPyBeginAllowThreads();
35028 (arg1)->OnLeave();
35029 wxPyEndAllowThreads(__tstate);
35030 if (PyErr_Occurred()) SWIG_fail;
35031 }
35032 resultobj = SWIG_Py_Void();
35033 return resultobj;
35034 fail:
35035 return NULL;
35036 }
35037
35038
35039 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35040 PyObject *resultobj = 0;
35041 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35042 int arg2 ;
35043 int arg3 ;
35044 bool result;
35045 void *argp1 = 0 ;
35046 int res1 = 0 ;
35047 int val2 ;
35048 int ecode2 = 0 ;
35049 int val3 ;
35050 int ecode3 = 0 ;
35051 PyObject * obj0 = 0 ;
35052 PyObject * obj1 = 0 ;
35053 PyObject * obj2 = 0 ;
35054 char * kwnames[] = {
35055 (char *) "self",(char *) "x",(char *) "y", NULL
35056 };
35057
35058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35060 if (!SWIG_IsOK(res1)) {
35061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35062 }
35063 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35064 ecode2 = SWIG_AsVal_int(obj1, &val2);
35065 if (!SWIG_IsOK(ecode2)) {
35066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35067 }
35068 arg2 = static_cast< int >(val2);
35069 ecode3 = SWIG_AsVal_int(obj2, &val3);
35070 if (!SWIG_IsOK(ecode3)) {
35071 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35072 }
35073 arg3 = static_cast< int >(val3);
35074 {
35075 PyThreadState* __tstate = wxPyBeginAllowThreads();
35076 result = (bool)(arg1)->OnDrop(arg2,arg3);
35077 wxPyEndAllowThreads(__tstate);
35078 if (PyErr_Occurred()) SWIG_fail;
35079 }
35080 {
35081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35082 }
35083 return resultobj;
35084 fail:
35085 return NULL;
35086 }
35087
35088
35089 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35090 PyObject *resultobj = 0;
35091 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35092 int arg2 ;
35093 int arg3 ;
35094 wxDragResult arg4 ;
35095 wxDragResult result;
35096 void *argp1 = 0 ;
35097 int res1 = 0 ;
35098 int val2 ;
35099 int ecode2 = 0 ;
35100 int val3 ;
35101 int ecode3 = 0 ;
35102 int val4 ;
35103 int ecode4 = 0 ;
35104 PyObject * obj0 = 0 ;
35105 PyObject * obj1 = 0 ;
35106 PyObject * obj2 = 0 ;
35107 PyObject * obj3 = 0 ;
35108 char * kwnames[] = {
35109 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35110 };
35111
35112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35114 if (!SWIG_IsOK(res1)) {
35115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35116 }
35117 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35118 ecode2 = SWIG_AsVal_int(obj1, &val2);
35119 if (!SWIG_IsOK(ecode2)) {
35120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35121 }
35122 arg2 = static_cast< int >(val2);
35123 ecode3 = SWIG_AsVal_int(obj2, &val3);
35124 if (!SWIG_IsOK(ecode3)) {
35125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35126 }
35127 arg3 = static_cast< int >(val3);
35128 ecode4 = SWIG_AsVal_int(obj3, &val4);
35129 if (!SWIG_IsOK(ecode4)) {
35130 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35131 }
35132 arg4 = static_cast< wxDragResult >(val4);
35133 {
35134 PyThreadState* __tstate = wxPyBeginAllowThreads();
35135 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35136 wxPyEndAllowThreads(__tstate);
35137 if (PyErr_Occurred()) SWIG_fail;
35138 }
35139 resultobj = SWIG_From_int(static_cast< int >(result));
35140 return resultobj;
35141 fail:
35142 return NULL;
35143 }
35144
35145
35146 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35147 PyObject *obj;
35148 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35149 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35150 return SWIG_Py_Void();
35151 }
35152
35153 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35154 return SWIG_Python_InitShadowInstance(args);
35155 }
35156
35157 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35158 PyObject *resultobj = 0;
35159 wxClipboard *result = 0 ;
35160
35161 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35162 {
35163 PyThreadState* __tstate = wxPyBeginAllowThreads();
35164 result = (wxClipboard *)new wxClipboard();
35165 wxPyEndAllowThreads(__tstate);
35166 if (PyErr_Occurred()) SWIG_fail;
35167 }
35168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35169 return resultobj;
35170 fail:
35171 return NULL;
35172 }
35173
35174
35175 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35176 PyObject *resultobj = 0;
35177 wxClipboard *arg1 = (wxClipboard *) 0 ;
35178 void *argp1 = 0 ;
35179 int res1 = 0 ;
35180 PyObject *swig_obj[1] ;
35181
35182 if (!args) SWIG_fail;
35183 swig_obj[0] = args;
35184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35185 if (!SWIG_IsOK(res1)) {
35186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35187 }
35188 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35189 {
35190 PyThreadState* __tstate = wxPyBeginAllowThreads();
35191 delete arg1;
35192
35193 wxPyEndAllowThreads(__tstate);
35194 if (PyErr_Occurred()) SWIG_fail;
35195 }
35196 resultobj = SWIG_Py_Void();
35197 return resultobj;
35198 fail:
35199 return NULL;
35200 }
35201
35202
35203 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35204 PyObject *resultobj = 0;
35205 wxClipboard *arg1 = (wxClipboard *) 0 ;
35206 bool result;
35207 void *argp1 = 0 ;
35208 int res1 = 0 ;
35209 PyObject *swig_obj[1] ;
35210
35211 if (!args) SWIG_fail;
35212 swig_obj[0] = args;
35213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35214 if (!SWIG_IsOK(res1)) {
35215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35216 }
35217 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35218 {
35219 PyThreadState* __tstate = wxPyBeginAllowThreads();
35220 result = (bool)(arg1)->Open();
35221 wxPyEndAllowThreads(__tstate);
35222 if (PyErr_Occurred()) SWIG_fail;
35223 }
35224 {
35225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35226 }
35227 return resultobj;
35228 fail:
35229 return NULL;
35230 }
35231
35232
35233 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35234 PyObject *resultobj = 0;
35235 wxClipboard *arg1 = (wxClipboard *) 0 ;
35236 void *argp1 = 0 ;
35237 int res1 = 0 ;
35238 PyObject *swig_obj[1] ;
35239
35240 if (!args) SWIG_fail;
35241 swig_obj[0] = args;
35242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35243 if (!SWIG_IsOK(res1)) {
35244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35245 }
35246 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35247 {
35248 PyThreadState* __tstate = wxPyBeginAllowThreads();
35249 (arg1)->Close();
35250 wxPyEndAllowThreads(__tstate);
35251 if (PyErr_Occurred()) SWIG_fail;
35252 }
35253 resultobj = SWIG_Py_Void();
35254 return resultobj;
35255 fail:
35256 return NULL;
35257 }
35258
35259
35260 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35261 PyObject *resultobj = 0;
35262 wxClipboard *arg1 = (wxClipboard *) 0 ;
35263 bool result;
35264 void *argp1 = 0 ;
35265 int res1 = 0 ;
35266 PyObject *swig_obj[1] ;
35267
35268 if (!args) SWIG_fail;
35269 swig_obj[0] = args;
35270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35271 if (!SWIG_IsOK(res1)) {
35272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35273 }
35274 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35275 {
35276 PyThreadState* __tstate = wxPyBeginAllowThreads();
35277 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35278 wxPyEndAllowThreads(__tstate);
35279 if (PyErr_Occurred()) SWIG_fail;
35280 }
35281 {
35282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35283 }
35284 return resultobj;
35285 fail:
35286 return NULL;
35287 }
35288
35289
35290 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35291 PyObject *resultobj = 0;
35292 wxClipboard *arg1 = (wxClipboard *) 0 ;
35293 wxDataObject *arg2 = (wxDataObject *) 0 ;
35294 bool result;
35295 void *argp1 = 0 ;
35296 int res1 = 0 ;
35297 int res2 = 0 ;
35298 PyObject * obj0 = 0 ;
35299 PyObject * obj1 = 0 ;
35300 char * kwnames[] = {
35301 (char *) "self",(char *) "data", NULL
35302 };
35303
35304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35306 if (!SWIG_IsOK(res1)) {
35307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35308 }
35309 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35310 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35311 if (!SWIG_IsOK(res2)) {
35312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35313 }
35314 {
35315 PyThreadState* __tstate = wxPyBeginAllowThreads();
35316 result = (bool)(arg1)->AddData(arg2);
35317 wxPyEndAllowThreads(__tstate);
35318 if (PyErr_Occurred()) SWIG_fail;
35319 }
35320 {
35321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35322 }
35323 return resultobj;
35324 fail:
35325 return NULL;
35326 }
35327
35328
35329 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35330 PyObject *resultobj = 0;
35331 wxClipboard *arg1 = (wxClipboard *) 0 ;
35332 wxDataObject *arg2 = (wxDataObject *) 0 ;
35333 bool result;
35334 void *argp1 = 0 ;
35335 int res1 = 0 ;
35336 int res2 = 0 ;
35337 PyObject * obj0 = 0 ;
35338 PyObject * obj1 = 0 ;
35339 char * kwnames[] = {
35340 (char *) "self",(char *) "data", NULL
35341 };
35342
35343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35345 if (!SWIG_IsOK(res1)) {
35346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35347 }
35348 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35349 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35350 if (!SWIG_IsOK(res2)) {
35351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35352 }
35353 {
35354 PyThreadState* __tstate = wxPyBeginAllowThreads();
35355 result = (bool)(arg1)->SetData(arg2);
35356 wxPyEndAllowThreads(__tstate);
35357 if (PyErr_Occurred()) SWIG_fail;
35358 }
35359 {
35360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35361 }
35362 return resultobj;
35363 fail:
35364 return NULL;
35365 }
35366
35367
35368 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35369 PyObject *resultobj = 0;
35370 wxClipboard *arg1 = (wxClipboard *) 0 ;
35371 wxDataFormat *arg2 = 0 ;
35372 bool result;
35373 void *argp1 = 0 ;
35374 int res1 = 0 ;
35375 void *argp2 = 0 ;
35376 int res2 = 0 ;
35377 PyObject * obj0 = 0 ;
35378 PyObject * obj1 = 0 ;
35379 char * kwnames[] = {
35380 (char *) "self",(char *) "format", NULL
35381 };
35382
35383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35385 if (!SWIG_IsOK(res1)) {
35386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35387 }
35388 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35389 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35390 if (!SWIG_IsOK(res2)) {
35391 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35392 }
35393 if (!argp2) {
35394 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35395 }
35396 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35397 {
35398 PyThreadState* __tstate = wxPyBeginAllowThreads();
35399 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35400 wxPyEndAllowThreads(__tstate);
35401 if (PyErr_Occurred()) SWIG_fail;
35402 }
35403 {
35404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35405 }
35406 return resultobj;
35407 fail:
35408 return NULL;
35409 }
35410
35411
35412 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35413 PyObject *resultobj = 0;
35414 wxClipboard *arg1 = (wxClipboard *) 0 ;
35415 wxDataObject *arg2 = 0 ;
35416 bool result;
35417 void *argp1 = 0 ;
35418 int res1 = 0 ;
35419 void *argp2 = 0 ;
35420 int res2 = 0 ;
35421 PyObject * obj0 = 0 ;
35422 PyObject * obj1 = 0 ;
35423 char * kwnames[] = {
35424 (char *) "self",(char *) "data", NULL
35425 };
35426
35427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35429 if (!SWIG_IsOK(res1)) {
35430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35431 }
35432 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35433 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35434 if (!SWIG_IsOK(res2)) {
35435 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35436 }
35437 if (!argp2) {
35438 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35439 }
35440 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35441 {
35442 PyThreadState* __tstate = wxPyBeginAllowThreads();
35443 result = (bool)(arg1)->GetData(*arg2);
35444 wxPyEndAllowThreads(__tstate);
35445 if (PyErr_Occurred()) SWIG_fail;
35446 }
35447 {
35448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35449 }
35450 return resultobj;
35451 fail:
35452 return NULL;
35453 }
35454
35455
35456 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35457 PyObject *resultobj = 0;
35458 wxClipboard *arg1 = (wxClipboard *) 0 ;
35459 void *argp1 = 0 ;
35460 int res1 = 0 ;
35461 PyObject *swig_obj[1] ;
35462
35463 if (!args) SWIG_fail;
35464 swig_obj[0] = args;
35465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35466 if (!SWIG_IsOK(res1)) {
35467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35468 }
35469 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35470 {
35471 PyThreadState* __tstate = wxPyBeginAllowThreads();
35472 (arg1)->Clear();
35473 wxPyEndAllowThreads(__tstate);
35474 if (PyErr_Occurred()) SWIG_fail;
35475 }
35476 resultobj = SWIG_Py_Void();
35477 return resultobj;
35478 fail:
35479 return NULL;
35480 }
35481
35482
35483 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35484 PyObject *resultobj = 0;
35485 wxClipboard *arg1 = (wxClipboard *) 0 ;
35486 bool result;
35487 void *argp1 = 0 ;
35488 int res1 = 0 ;
35489 PyObject *swig_obj[1] ;
35490
35491 if (!args) SWIG_fail;
35492 swig_obj[0] = args;
35493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35494 if (!SWIG_IsOK(res1)) {
35495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35496 }
35497 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35498 {
35499 PyThreadState* __tstate = wxPyBeginAllowThreads();
35500 result = (bool)(arg1)->Flush();
35501 wxPyEndAllowThreads(__tstate);
35502 if (PyErr_Occurred()) SWIG_fail;
35503 }
35504 {
35505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35506 }
35507 return resultobj;
35508 fail:
35509 return NULL;
35510 }
35511
35512
35513 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35514 PyObject *resultobj = 0;
35515 wxClipboard *arg1 = (wxClipboard *) 0 ;
35516 bool arg2 = (bool) true ;
35517 void *argp1 = 0 ;
35518 int res1 = 0 ;
35519 bool val2 ;
35520 int ecode2 = 0 ;
35521 PyObject * obj0 = 0 ;
35522 PyObject * obj1 = 0 ;
35523 char * kwnames[] = {
35524 (char *) "self",(char *) "primary", NULL
35525 };
35526
35527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35529 if (!SWIG_IsOK(res1)) {
35530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35531 }
35532 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35533 if (obj1) {
35534 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35535 if (!SWIG_IsOK(ecode2)) {
35536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35537 }
35538 arg2 = static_cast< bool >(val2);
35539 }
35540 {
35541 PyThreadState* __tstate = wxPyBeginAllowThreads();
35542 (arg1)->UsePrimarySelection(arg2);
35543 wxPyEndAllowThreads(__tstate);
35544 if (PyErr_Occurred()) SWIG_fail;
35545 }
35546 resultobj = SWIG_Py_Void();
35547 return resultobj;
35548 fail:
35549 return NULL;
35550 }
35551
35552
35553 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35554 PyObject *resultobj = 0;
35555 wxClipboard *result = 0 ;
35556
35557 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35558 {
35559 PyThreadState* __tstate = wxPyBeginAllowThreads();
35560 result = (wxClipboard *)wxClipboard::Get();
35561 wxPyEndAllowThreads(__tstate);
35562 if (PyErr_Occurred()) SWIG_fail;
35563 }
35564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35565 return resultobj;
35566 fail:
35567 return NULL;
35568 }
35569
35570
35571 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35572 PyObject *obj;
35573 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35574 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35575 return SWIG_Py_Void();
35576 }
35577
35578 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35579 return SWIG_Python_InitShadowInstance(args);
35580 }
35581
35582 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35583 PyObject *resultobj = 0;
35584 wxClipboard *arg1 = (wxClipboard *) NULL ;
35585 wxClipboardLocker *result = 0 ;
35586 void *argp1 = 0 ;
35587 int res1 = 0 ;
35588 PyObject * obj0 = 0 ;
35589 char * kwnames[] = {
35590 (char *) "clipboard", NULL
35591 };
35592
35593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35594 if (obj0) {
35595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35596 if (!SWIG_IsOK(res1)) {
35597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35598 }
35599 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35600 }
35601 {
35602 PyThreadState* __tstate = wxPyBeginAllowThreads();
35603 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35604 wxPyEndAllowThreads(__tstate);
35605 if (PyErr_Occurred()) SWIG_fail;
35606 }
35607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35608 return resultobj;
35609 fail:
35610 return NULL;
35611 }
35612
35613
35614 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35615 PyObject *resultobj = 0;
35616 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35617 void *argp1 = 0 ;
35618 int res1 = 0 ;
35619 PyObject *swig_obj[1] ;
35620
35621 if (!args) SWIG_fail;
35622 swig_obj[0] = args;
35623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35624 if (!SWIG_IsOK(res1)) {
35625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35626 }
35627 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35628 {
35629 PyThreadState* __tstate = wxPyBeginAllowThreads();
35630 delete arg1;
35631
35632 wxPyEndAllowThreads(__tstate);
35633 if (PyErr_Occurred()) SWIG_fail;
35634 }
35635 resultobj = SWIG_Py_Void();
35636 return resultobj;
35637 fail:
35638 return NULL;
35639 }
35640
35641
35642 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35643 PyObject *resultobj = 0;
35644 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35645 bool result;
35646 void *argp1 = 0 ;
35647 int res1 = 0 ;
35648 PyObject *swig_obj[1] ;
35649
35650 if (!args) SWIG_fail;
35651 swig_obj[0] = args;
35652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35653 if (!SWIG_IsOK(res1)) {
35654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35655 }
35656 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35657 {
35658 PyThreadState* __tstate = wxPyBeginAllowThreads();
35659 result = (bool)wxClipboardLocker___nonzero__(arg1);
35660 wxPyEndAllowThreads(__tstate);
35661 if (PyErr_Occurred()) SWIG_fail;
35662 }
35663 {
35664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35665 }
35666 return resultobj;
35667 fail:
35668 return NULL;
35669 }
35670
35671
35672 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35673 PyObject *obj;
35674 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35675 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35676 return SWIG_Py_Void();
35677 }
35678
35679 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35680 return SWIG_Python_InitShadowInstance(args);
35681 }
35682
35683 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35684 PyObject *resultobj = 0;
35685 int arg1 = (int) 0 ;
35686 int arg2 = (int) 0 ;
35687 int arg3 = (int) 0 ;
35688 int arg4 = (int) 0 ;
35689 wxVideoMode *result = 0 ;
35690 int val1 ;
35691 int ecode1 = 0 ;
35692 int val2 ;
35693 int ecode2 = 0 ;
35694 int val3 ;
35695 int ecode3 = 0 ;
35696 int val4 ;
35697 int ecode4 = 0 ;
35698 PyObject * obj0 = 0 ;
35699 PyObject * obj1 = 0 ;
35700 PyObject * obj2 = 0 ;
35701 PyObject * obj3 = 0 ;
35702 char * kwnames[] = {
35703 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35704 };
35705
35706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35707 if (obj0) {
35708 ecode1 = SWIG_AsVal_int(obj0, &val1);
35709 if (!SWIG_IsOK(ecode1)) {
35710 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35711 }
35712 arg1 = static_cast< int >(val1);
35713 }
35714 if (obj1) {
35715 ecode2 = SWIG_AsVal_int(obj1, &val2);
35716 if (!SWIG_IsOK(ecode2)) {
35717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35718 }
35719 arg2 = static_cast< int >(val2);
35720 }
35721 if (obj2) {
35722 ecode3 = SWIG_AsVal_int(obj2, &val3);
35723 if (!SWIG_IsOK(ecode3)) {
35724 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35725 }
35726 arg3 = static_cast< int >(val3);
35727 }
35728 if (obj3) {
35729 ecode4 = SWIG_AsVal_int(obj3, &val4);
35730 if (!SWIG_IsOK(ecode4)) {
35731 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35732 }
35733 arg4 = static_cast< int >(val4);
35734 }
35735 {
35736 PyThreadState* __tstate = wxPyBeginAllowThreads();
35737 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35738 wxPyEndAllowThreads(__tstate);
35739 if (PyErr_Occurred()) SWIG_fail;
35740 }
35741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35742 return resultobj;
35743 fail:
35744 return NULL;
35745 }
35746
35747
35748 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35749 PyObject *resultobj = 0;
35750 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35751 void *argp1 = 0 ;
35752 int res1 = 0 ;
35753 PyObject *swig_obj[1] ;
35754
35755 if (!args) SWIG_fail;
35756 swig_obj[0] = args;
35757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35758 if (!SWIG_IsOK(res1)) {
35759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35760 }
35761 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35762 {
35763 PyThreadState* __tstate = wxPyBeginAllowThreads();
35764 delete arg1;
35765
35766 wxPyEndAllowThreads(__tstate);
35767 if (PyErr_Occurred()) SWIG_fail;
35768 }
35769 resultobj = SWIG_Py_Void();
35770 return resultobj;
35771 fail:
35772 return NULL;
35773 }
35774
35775
35776 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35777 PyObject *resultobj = 0;
35778 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35779 wxVideoMode *arg2 = 0 ;
35780 bool result;
35781 void *argp1 = 0 ;
35782 int res1 = 0 ;
35783 void *argp2 = 0 ;
35784 int res2 = 0 ;
35785 PyObject * obj0 = 0 ;
35786 PyObject * obj1 = 0 ;
35787 char * kwnames[] = {
35788 (char *) "self",(char *) "other", NULL
35789 };
35790
35791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35793 if (!SWIG_IsOK(res1)) {
35794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35795 }
35796 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35797 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35798 if (!SWIG_IsOK(res2)) {
35799 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35800 }
35801 if (!argp2) {
35802 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35803 }
35804 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35805 {
35806 PyThreadState* __tstate = wxPyBeginAllowThreads();
35807 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35808 wxPyEndAllowThreads(__tstate);
35809 if (PyErr_Occurred()) SWIG_fail;
35810 }
35811 {
35812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35813 }
35814 return resultobj;
35815 fail:
35816 return NULL;
35817 }
35818
35819
35820 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35821 PyObject *resultobj = 0;
35822 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35823 int result;
35824 void *argp1 = 0 ;
35825 int res1 = 0 ;
35826 PyObject *swig_obj[1] ;
35827
35828 if (!args) SWIG_fail;
35829 swig_obj[0] = args;
35830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35831 if (!SWIG_IsOK(res1)) {
35832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35833 }
35834 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35835 {
35836 PyThreadState* __tstate = wxPyBeginAllowThreads();
35837 result = (int)((wxVideoMode const *)arg1)->GetWidth();
35838 wxPyEndAllowThreads(__tstate);
35839 if (PyErr_Occurred()) SWIG_fail;
35840 }
35841 resultobj = SWIG_From_int(static_cast< int >(result));
35842 return resultobj;
35843 fail:
35844 return NULL;
35845 }
35846
35847
35848 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35849 PyObject *resultobj = 0;
35850 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35851 int result;
35852 void *argp1 = 0 ;
35853 int res1 = 0 ;
35854 PyObject *swig_obj[1] ;
35855
35856 if (!args) SWIG_fail;
35857 swig_obj[0] = args;
35858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35859 if (!SWIG_IsOK(res1)) {
35860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35861 }
35862 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35863 {
35864 PyThreadState* __tstate = wxPyBeginAllowThreads();
35865 result = (int)((wxVideoMode const *)arg1)->GetHeight();
35866 wxPyEndAllowThreads(__tstate);
35867 if (PyErr_Occurred()) SWIG_fail;
35868 }
35869 resultobj = SWIG_From_int(static_cast< int >(result));
35870 return resultobj;
35871 fail:
35872 return NULL;
35873 }
35874
35875
35876 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35877 PyObject *resultobj = 0;
35878 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35879 int result;
35880 void *argp1 = 0 ;
35881 int res1 = 0 ;
35882 PyObject *swig_obj[1] ;
35883
35884 if (!args) SWIG_fail;
35885 swig_obj[0] = args;
35886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35887 if (!SWIG_IsOK(res1)) {
35888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35889 }
35890 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35891 {
35892 PyThreadState* __tstate = wxPyBeginAllowThreads();
35893 result = (int)((wxVideoMode const *)arg1)->GetDepth();
35894 wxPyEndAllowThreads(__tstate);
35895 if (PyErr_Occurred()) SWIG_fail;
35896 }
35897 resultobj = SWIG_From_int(static_cast< int >(result));
35898 return resultobj;
35899 fail:
35900 return NULL;
35901 }
35902
35903
35904 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35905 PyObject *resultobj = 0;
35906 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35907 bool result;
35908 void *argp1 = 0 ;
35909 int res1 = 0 ;
35910 PyObject *swig_obj[1] ;
35911
35912 if (!args) SWIG_fail;
35913 swig_obj[0] = args;
35914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35915 if (!SWIG_IsOK(res1)) {
35916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35917 }
35918 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35919 {
35920 PyThreadState* __tstate = wxPyBeginAllowThreads();
35921 result = (bool)((wxVideoMode const *)arg1)->IsOk();
35922 wxPyEndAllowThreads(__tstate);
35923 if (PyErr_Occurred()) SWIG_fail;
35924 }
35925 {
35926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35927 }
35928 return resultobj;
35929 fail:
35930 return NULL;
35931 }
35932
35933
35934 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35935 PyObject *resultobj = 0;
35936 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35937 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
35938 bool result;
35939 void *argp1 = 0 ;
35940 int res1 = 0 ;
35941 void *argp2 = 0 ;
35942 int res2 = 0 ;
35943 PyObject * obj0 = 0 ;
35944 PyObject * obj1 = 0 ;
35945 char * kwnames[] = {
35946 (char *) "self",(char *) "other", NULL
35947 };
35948
35949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
35950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35951 if (!SWIG_IsOK(res1)) {
35952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35953 }
35954 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35955 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35956 if (!SWIG_IsOK(res2)) {
35957 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
35958 }
35959 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35960 {
35961 PyThreadState* __tstate = wxPyBeginAllowThreads();
35962 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
35963 wxPyEndAllowThreads(__tstate);
35964 if (PyErr_Occurred()) SWIG_fail;
35965 }
35966 {
35967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35968 }
35969 return resultobj;
35970 fail:
35971 return NULL;
35972 }
35973
35974
35975 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35976 PyObject *resultobj = 0;
35977 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35978 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
35979 bool result;
35980 void *argp1 = 0 ;
35981 int res1 = 0 ;
35982 void *argp2 = 0 ;
35983 int res2 = 0 ;
35984 PyObject * obj0 = 0 ;
35985 PyObject * obj1 = 0 ;
35986 char * kwnames[] = {
35987 (char *) "self",(char *) "other", NULL
35988 };
35989
35990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
35991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35992 if (!SWIG_IsOK(res1)) {
35993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35994 }
35995 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35996 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35997 if (!SWIG_IsOK(res2)) {
35998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
35999 }
36000 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36001 {
36002 PyThreadState* __tstate = wxPyBeginAllowThreads();
36003 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36004 wxPyEndAllowThreads(__tstate);
36005 if (PyErr_Occurred()) SWIG_fail;
36006 }
36007 {
36008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36009 }
36010 return resultobj;
36011 fail:
36012 return NULL;
36013 }
36014
36015
36016 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36017 PyObject *resultobj = 0;
36018 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36019 int arg2 ;
36020 void *argp1 = 0 ;
36021 int res1 = 0 ;
36022 int val2 ;
36023 int ecode2 = 0 ;
36024 PyObject *swig_obj[2] ;
36025
36026 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36028 if (!SWIG_IsOK(res1)) {
36029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36030 }
36031 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36032 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36033 if (!SWIG_IsOK(ecode2)) {
36034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36035 }
36036 arg2 = static_cast< int >(val2);
36037 if (arg1) (arg1)->w = arg2;
36038
36039 resultobj = SWIG_Py_Void();
36040 return resultobj;
36041 fail:
36042 return NULL;
36043 }
36044
36045
36046 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36047 PyObject *resultobj = 0;
36048 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36049 int result;
36050 void *argp1 = 0 ;
36051 int res1 = 0 ;
36052 PyObject *swig_obj[1] ;
36053
36054 if (!args) SWIG_fail;
36055 swig_obj[0] = args;
36056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36057 if (!SWIG_IsOK(res1)) {
36058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36059 }
36060 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36061 result = (int) ((arg1)->w);
36062 resultobj = SWIG_From_int(static_cast< int >(result));
36063 return resultobj;
36064 fail:
36065 return NULL;
36066 }
36067
36068
36069 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36070 PyObject *resultobj = 0;
36071 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36072 int arg2 ;
36073 void *argp1 = 0 ;
36074 int res1 = 0 ;
36075 int val2 ;
36076 int ecode2 = 0 ;
36077 PyObject *swig_obj[2] ;
36078
36079 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36081 if (!SWIG_IsOK(res1)) {
36082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36083 }
36084 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36085 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36086 if (!SWIG_IsOK(ecode2)) {
36087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36088 }
36089 arg2 = static_cast< int >(val2);
36090 if (arg1) (arg1)->h = arg2;
36091
36092 resultobj = SWIG_Py_Void();
36093 return resultobj;
36094 fail:
36095 return NULL;
36096 }
36097
36098
36099 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36100 PyObject *resultobj = 0;
36101 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36102 int result;
36103 void *argp1 = 0 ;
36104 int res1 = 0 ;
36105 PyObject *swig_obj[1] ;
36106
36107 if (!args) SWIG_fail;
36108 swig_obj[0] = args;
36109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36110 if (!SWIG_IsOK(res1)) {
36111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36112 }
36113 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36114 result = (int) ((arg1)->h);
36115 resultobj = SWIG_From_int(static_cast< int >(result));
36116 return resultobj;
36117 fail:
36118 return NULL;
36119 }
36120
36121
36122 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36123 PyObject *resultobj = 0;
36124 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36125 int arg2 ;
36126 void *argp1 = 0 ;
36127 int res1 = 0 ;
36128 int val2 ;
36129 int ecode2 = 0 ;
36130 PyObject *swig_obj[2] ;
36131
36132 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36134 if (!SWIG_IsOK(res1)) {
36135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36136 }
36137 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36138 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36139 if (!SWIG_IsOK(ecode2)) {
36140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36141 }
36142 arg2 = static_cast< int >(val2);
36143 if (arg1) (arg1)->bpp = arg2;
36144
36145 resultobj = SWIG_Py_Void();
36146 return resultobj;
36147 fail:
36148 return NULL;
36149 }
36150
36151
36152 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36153 PyObject *resultobj = 0;
36154 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36155 int result;
36156 void *argp1 = 0 ;
36157 int res1 = 0 ;
36158 PyObject *swig_obj[1] ;
36159
36160 if (!args) SWIG_fail;
36161 swig_obj[0] = args;
36162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36163 if (!SWIG_IsOK(res1)) {
36164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36165 }
36166 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36167 result = (int) ((arg1)->bpp);
36168 resultobj = SWIG_From_int(static_cast< int >(result));
36169 return resultobj;
36170 fail:
36171 return NULL;
36172 }
36173
36174
36175 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36176 PyObject *resultobj = 0;
36177 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36178 int arg2 ;
36179 void *argp1 = 0 ;
36180 int res1 = 0 ;
36181 int val2 ;
36182 int ecode2 = 0 ;
36183 PyObject *swig_obj[2] ;
36184
36185 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36187 if (!SWIG_IsOK(res1)) {
36188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36189 }
36190 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36191 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36192 if (!SWIG_IsOK(ecode2)) {
36193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36194 }
36195 arg2 = static_cast< int >(val2);
36196 if (arg1) (arg1)->refresh = arg2;
36197
36198 resultobj = SWIG_Py_Void();
36199 return resultobj;
36200 fail:
36201 return NULL;
36202 }
36203
36204
36205 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36206 PyObject *resultobj = 0;
36207 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36208 int result;
36209 void *argp1 = 0 ;
36210 int res1 = 0 ;
36211 PyObject *swig_obj[1] ;
36212
36213 if (!args) SWIG_fail;
36214 swig_obj[0] = args;
36215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36216 if (!SWIG_IsOK(res1)) {
36217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36218 }
36219 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36220 result = (int) ((arg1)->refresh);
36221 resultobj = SWIG_From_int(static_cast< int >(result));
36222 return resultobj;
36223 fail:
36224 return NULL;
36225 }
36226
36227
36228 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36229 PyObject *obj;
36230 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36231 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36232 return SWIG_Py_Void();
36233 }
36234
36235 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36236 return SWIG_Python_InitShadowInstance(args);
36237 }
36238
36239 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36240 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36241 return 1;
36242 }
36243
36244
36245 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36246 PyObject *pyobj = 0;
36247
36248 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36249 return pyobj;
36250 }
36251
36252
36253 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36254 PyObject *resultobj = 0;
36255 size_t arg1 = (size_t) 0 ;
36256 wxDisplay *result = 0 ;
36257 size_t val1 ;
36258 int ecode1 = 0 ;
36259 PyObject * obj0 = 0 ;
36260 char * kwnames[] = {
36261 (char *) "index", NULL
36262 };
36263
36264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36265 if (obj0) {
36266 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
36267 if (!SWIG_IsOK(ecode1)) {
36268 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
36269 }
36270 arg1 = static_cast< size_t >(val1);
36271 }
36272 {
36273 PyThreadState* __tstate = wxPyBeginAllowThreads();
36274 result = (wxDisplay *)new wxDisplay(arg1);
36275 wxPyEndAllowThreads(__tstate);
36276 if (PyErr_Occurred()) SWIG_fail;
36277 }
36278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36279 return resultobj;
36280 fail:
36281 return NULL;
36282 }
36283
36284
36285 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36286 PyObject *resultobj = 0;
36287 wxDisplay *arg1 = (wxDisplay *) 0 ;
36288 void *argp1 = 0 ;
36289 int res1 = 0 ;
36290 PyObject *swig_obj[1] ;
36291
36292 if (!args) SWIG_fail;
36293 swig_obj[0] = args;
36294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36295 if (!SWIG_IsOK(res1)) {
36296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36297 }
36298 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36299 {
36300 PyThreadState* __tstate = wxPyBeginAllowThreads();
36301 delete arg1;
36302
36303 wxPyEndAllowThreads(__tstate);
36304 if (PyErr_Occurred()) SWIG_fail;
36305 }
36306 resultobj = SWIG_Py_Void();
36307 return resultobj;
36308 fail:
36309 return NULL;
36310 }
36311
36312
36313 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36314 PyObject *resultobj = 0;
36315 size_t result;
36316
36317 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36318 {
36319 PyThreadState* __tstate = wxPyBeginAllowThreads();
36320 result = (size_t)wxDisplay::GetCount();
36321 wxPyEndAllowThreads(__tstate);
36322 if (PyErr_Occurred()) SWIG_fail;
36323 }
36324 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
36325 return resultobj;
36326 fail:
36327 return NULL;
36328 }
36329
36330
36331 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36332 PyObject *resultobj = 0;
36333 wxPoint *arg1 = 0 ;
36334 int result;
36335 wxPoint temp1 ;
36336 PyObject * obj0 = 0 ;
36337 char * kwnames[] = {
36338 (char *) "pt", NULL
36339 };
36340
36341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36342 {
36343 arg1 = &temp1;
36344 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36345 }
36346 {
36347 PyThreadState* __tstate = wxPyBeginAllowThreads();
36348 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36349 wxPyEndAllowThreads(__tstate);
36350 if (PyErr_Occurred()) SWIG_fail;
36351 }
36352 resultobj = SWIG_From_int(static_cast< int >(result));
36353 return resultobj;
36354 fail:
36355 return NULL;
36356 }
36357
36358
36359 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36360 PyObject *resultobj = 0;
36361 wxWindow *arg1 = (wxWindow *) 0 ;
36362 int result;
36363 void *argp1 = 0 ;
36364 int res1 = 0 ;
36365 PyObject * obj0 = 0 ;
36366 char * kwnames[] = {
36367 (char *) "window", NULL
36368 };
36369
36370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36372 if (!SWIG_IsOK(res1)) {
36373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36374 }
36375 arg1 = reinterpret_cast< wxWindow * >(argp1);
36376 {
36377 PyThreadState* __tstate = wxPyBeginAllowThreads();
36378 result = (int)wxDisplay::GetFromWindow(arg1);
36379 wxPyEndAllowThreads(__tstate);
36380 if (PyErr_Occurred()) SWIG_fail;
36381 }
36382 resultobj = SWIG_From_int(static_cast< int >(result));
36383 return resultobj;
36384 fail:
36385 return NULL;
36386 }
36387
36388
36389 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36390 PyObject *resultobj = 0;
36391 wxDisplay *arg1 = (wxDisplay *) 0 ;
36392 bool result;
36393 void *argp1 = 0 ;
36394 int res1 = 0 ;
36395 PyObject *swig_obj[1] ;
36396
36397 if (!args) SWIG_fail;
36398 swig_obj[0] = args;
36399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36400 if (!SWIG_IsOK(res1)) {
36401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36402 }
36403 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36404 {
36405 PyThreadState* __tstate = wxPyBeginAllowThreads();
36406 result = (bool)((wxDisplay const *)arg1)->IsOk();
36407 wxPyEndAllowThreads(__tstate);
36408 if (PyErr_Occurred()) SWIG_fail;
36409 }
36410 {
36411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36412 }
36413 return resultobj;
36414 fail:
36415 return NULL;
36416 }
36417
36418
36419 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36420 PyObject *resultobj = 0;
36421 wxDisplay *arg1 = (wxDisplay *) 0 ;
36422 wxRect result;
36423 void *argp1 = 0 ;
36424 int res1 = 0 ;
36425 PyObject *swig_obj[1] ;
36426
36427 if (!args) SWIG_fail;
36428 swig_obj[0] = args;
36429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36430 if (!SWIG_IsOK(res1)) {
36431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36432 }
36433 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36434 {
36435 PyThreadState* __tstate = wxPyBeginAllowThreads();
36436 result = ((wxDisplay const *)arg1)->GetGeometry();
36437 wxPyEndAllowThreads(__tstate);
36438 if (PyErr_Occurred()) SWIG_fail;
36439 }
36440 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36441 return resultobj;
36442 fail:
36443 return NULL;
36444 }
36445
36446
36447 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36448 PyObject *resultobj = 0;
36449 wxDisplay *arg1 = (wxDisplay *) 0 ;
36450 wxRect result;
36451 void *argp1 = 0 ;
36452 int res1 = 0 ;
36453 PyObject *swig_obj[1] ;
36454
36455 if (!args) SWIG_fail;
36456 swig_obj[0] = args;
36457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36458 if (!SWIG_IsOK(res1)) {
36459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36460 }
36461 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36462 {
36463 PyThreadState* __tstate = wxPyBeginAllowThreads();
36464 result = ((wxDisplay const *)arg1)->GetClientArea();
36465 wxPyEndAllowThreads(__tstate);
36466 if (PyErr_Occurred()) SWIG_fail;
36467 }
36468 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36469 return resultobj;
36470 fail:
36471 return NULL;
36472 }
36473
36474
36475 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36476 PyObject *resultobj = 0;
36477 wxDisplay *arg1 = (wxDisplay *) 0 ;
36478 wxString result;
36479 void *argp1 = 0 ;
36480 int res1 = 0 ;
36481 PyObject *swig_obj[1] ;
36482
36483 if (!args) SWIG_fail;
36484 swig_obj[0] = args;
36485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36486 if (!SWIG_IsOK(res1)) {
36487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36488 }
36489 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36490 {
36491 PyThreadState* __tstate = wxPyBeginAllowThreads();
36492 result = ((wxDisplay const *)arg1)->GetName();
36493 wxPyEndAllowThreads(__tstate);
36494 if (PyErr_Occurred()) SWIG_fail;
36495 }
36496 {
36497 #if wxUSE_UNICODE
36498 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36499 #else
36500 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36501 #endif
36502 }
36503 return resultobj;
36504 fail:
36505 return NULL;
36506 }
36507
36508
36509 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36510 PyObject *resultobj = 0;
36511 wxDisplay *arg1 = (wxDisplay *) 0 ;
36512 bool result;
36513 void *argp1 = 0 ;
36514 int res1 = 0 ;
36515 PyObject *swig_obj[1] ;
36516
36517 if (!args) SWIG_fail;
36518 swig_obj[0] = args;
36519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36520 if (!SWIG_IsOK(res1)) {
36521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36522 }
36523 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36524 {
36525 PyThreadState* __tstate = wxPyBeginAllowThreads();
36526 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36527 wxPyEndAllowThreads(__tstate);
36528 if (PyErr_Occurred()) SWIG_fail;
36529 }
36530 {
36531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36532 }
36533 return resultobj;
36534 fail:
36535 return NULL;
36536 }
36537
36538
36539 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36540 PyObject *resultobj = 0;
36541 wxDisplay *arg1 = (wxDisplay *) 0 ;
36542 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36543 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36544 PyObject *result = 0 ;
36545 void *argp1 = 0 ;
36546 int res1 = 0 ;
36547 void *argp2 = 0 ;
36548 int res2 = 0 ;
36549 PyObject * obj0 = 0 ;
36550 PyObject * obj1 = 0 ;
36551 char * kwnames[] = {
36552 (char *) "self",(char *) "mode", NULL
36553 };
36554
36555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36557 if (!SWIG_IsOK(res1)) {
36558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36559 }
36560 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36561 if (obj1) {
36562 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36563 if (!SWIG_IsOK(res2)) {
36564 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36565 }
36566 if (!argp2) {
36567 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36568 }
36569 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36570 }
36571 {
36572 PyThreadState* __tstate = wxPyBeginAllowThreads();
36573 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36574 wxPyEndAllowThreads(__tstate);
36575 if (PyErr_Occurred()) SWIG_fail;
36576 }
36577 resultobj = result;
36578 return resultobj;
36579 fail:
36580 return NULL;
36581 }
36582
36583
36584 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36585 PyObject *resultobj = 0;
36586 wxDisplay *arg1 = (wxDisplay *) 0 ;
36587 wxVideoMode result;
36588 void *argp1 = 0 ;
36589 int res1 = 0 ;
36590 PyObject *swig_obj[1] ;
36591
36592 if (!args) SWIG_fail;
36593 swig_obj[0] = args;
36594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36595 if (!SWIG_IsOK(res1)) {
36596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36597 }
36598 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36599 {
36600 PyThreadState* __tstate = wxPyBeginAllowThreads();
36601 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36602 wxPyEndAllowThreads(__tstate);
36603 if (PyErr_Occurred()) SWIG_fail;
36604 }
36605 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36606 return resultobj;
36607 fail:
36608 return NULL;
36609 }
36610
36611
36612 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36613 PyObject *resultobj = 0;
36614 wxDisplay *arg1 = (wxDisplay *) 0 ;
36615 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36616 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36617 bool result;
36618 void *argp1 = 0 ;
36619 int res1 = 0 ;
36620 void *argp2 = 0 ;
36621 int res2 = 0 ;
36622 PyObject * obj0 = 0 ;
36623 PyObject * obj1 = 0 ;
36624 char * kwnames[] = {
36625 (char *) "self",(char *) "mode", NULL
36626 };
36627
36628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36630 if (!SWIG_IsOK(res1)) {
36631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36632 }
36633 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36634 if (obj1) {
36635 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36636 if (!SWIG_IsOK(res2)) {
36637 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36638 }
36639 if (!argp2) {
36640 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36641 }
36642 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36643 }
36644 {
36645 PyThreadState* __tstate = wxPyBeginAllowThreads();
36646 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36647 wxPyEndAllowThreads(__tstate);
36648 if (PyErr_Occurred()) SWIG_fail;
36649 }
36650 {
36651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36652 }
36653 return resultobj;
36654 fail:
36655 return NULL;
36656 }
36657
36658
36659 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36660 PyObject *resultobj = 0;
36661 wxDisplay *arg1 = (wxDisplay *) 0 ;
36662 void *argp1 = 0 ;
36663 int res1 = 0 ;
36664 PyObject *swig_obj[1] ;
36665
36666 if (!args) SWIG_fail;
36667 swig_obj[0] = args;
36668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36669 if (!SWIG_IsOK(res1)) {
36670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36671 }
36672 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36673 {
36674 PyThreadState* __tstate = wxPyBeginAllowThreads();
36675 wxDisplay_ResetMode(arg1);
36676 wxPyEndAllowThreads(__tstate);
36677 if (PyErr_Occurred()) SWIG_fail;
36678 }
36679 resultobj = SWIG_Py_Void();
36680 return resultobj;
36681 fail:
36682 return NULL;
36683 }
36684
36685
36686 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36687 PyObject *obj;
36688 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36689 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36690 return SWIG_Py_Void();
36691 }
36692
36693 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36694 return SWIG_Python_InitShadowInstance(args);
36695 }
36696
36697 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36698 PyObject *resultobj = 0;
36699 wxStandardPaths *result = 0 ;
36700
36701 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36702 {
36703 PyThreadState* __tstate = wxPyBeginAllowThreads();
36704 result = (wxStandardPaths *)wxStandardPaths_Get();
36705 wxPyEndAllowThreads(__tstate);
36706 if (PyErr_Occurred()) SWIG_fail;
36707 }
36708 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36709 return resultobj;
36710 fail:
36711 return NULL;
36712 }
36713
36714
36715 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36716 PyObject *resultobj = 0;
36717 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36718 wxString result;
36719 void *argp1 = 0 ;
36720 int res1 = 0 ;
36721 PyObject *swig_obj[1] ;
36722
36723 if (!args) SWIG_fail;
36724 swig_obj[0] = args;
36725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36726 if (!SWIG_IsOK(res1)) {
36727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36728 }
36729 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36730 {
36731 PyThreadState* __tstate = wxPyBeginAllowThreads();
36732 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36733 wxPyEndAllowThreads(__tstate);
36734 if (PyErr_Occurred()) SWIG_fail;
36735 }
36736 {
36737 #if wxUSE_UNICODE
36738 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36739 #else
36740 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36741 #endif
36742 }
36743 return resultobj;
36744 fail:
36745 return NULL;
36746 }
36747
36748
36749 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36750 PyObject *resultobj = 0;
36751 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36752 wxString result;
36753 void *argp1 = 0 ;
36754 int res1 = 0 ;
36755 PyObject *swig_obj[1] ;
36756
36757 if (!args) SWIG_fail;
36758 swig_obj[0] = args;
36759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36760 if (!SWIG_IsOK(res1)) {
36761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36762 }
36763 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36764 {
36765 PyThreadState* __tstate = wxPyBeginAllowThreads();
36766 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36767 wxPyEndAllowThreads(__tstate);
36768 if (PyErr_Occurred()) SWIG_fail;
36769 }
36770 {
36771 #if wxUSE_UNICODE
36772 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36773 #else
36774 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36775 #endif
36776 }
36777 return resultobj;
36778 fail:
36779 return NULL;
36780 }
36781
36782
36783 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36784 PyObject *resultobj = 0;
36785 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36786 wxString result;
36787 void *argp1 = 0 ;
36788 int res1 = 0 ;
36789 PyObject *swig_obj[1] ;
36790
36791 if (!args) SWIG_fail;
36792 swig_obj[0] = args;
36793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36794 if (!SWIG_IsOK(res1)) {
36795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36796 }
36797 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36798 {
36799 PyThreadState* __tstate = wxPyBeginAllowThreads();
36800 result = ((wxStandardPaths const *)arg1)->GetDataDir();
36801 wxPyEndAllowThreads(__tstate);
36802 if (PyErr_Occurred()) SWIG_fail;
36803 }
36804 {
36805 #if wxUSE_UNICODE
36806 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36807 #else
36808 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36809 #endif
36810 }
36811 return resultobj;
36812 fail:
36813 return NULL;
36814 }
36815
36816
36817 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36818 PyObject *resultobj = 0;
36819 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36820 wxString result;
36821 void *argp1 = 0 ;
36822 int res1 = 0 ;
36823 PyObject *swig_obj[1] ;
36824
36825 if (!args) SWIG_fail;
36826 swig_obj[0] = args;
36827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36828 if (!SWIG_IsOK(res1)) {
36829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36830 }
36831 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36832 {
36833 PyThreadState* __tstate = wxPyBeginAllowThreads();
36834 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
36835 wxPyEndAllowThreads(__tstate);
36836 if (PyErr_Occurred()) SWIG_fail;
36837 }
36838 {
36839 #if wxUSE_UNICODE
36840 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36841 #else
36842 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36843 #endif
36844 }
36845 return resultobj;
36846 fail:
36847 return NULL;
36848 }
36849
36850
36851 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36852 PyObject *resultobj = 0;
36853 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36854 wxString result;
36855 void *argp1 = 0 ;
36856 int res1 = 0 ;
36857 PyObject *swig_obj[1] ;
36858
36859 if (!args) SWIG_fail;
36860 swig_obj[0] = args;
36861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36862 if (!SWIG_IsOK(res1)) {
36863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36864 }
36865 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36866 {
36867 PyThreadState* __tstate = wxPyBeginAllowThreads();
36868 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
36869 wxPyEndAllowThreads(__tstate);
36870 if (PyErr_Occurred()) SWIG_fail;
36871 }
36872 {
36873 #if wxUSE_UNICODE
36874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36875 #else
36876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36877 #endif
36878 }
36879 return resultobj;
36880 fail:
36881 return NULL;
36882 }
36883
36884
36885 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36886 PyObject *resultobj = 0;
36887 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36888 wxString result;
36889 void *argp1 = 0 ;
36890 int res1 = 0 ;
36891 PyObject *swig_obj[1] ;
36892
36893 if (!args) SWIG_fail;
36894 swig_obj[0] = args;
36895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36896 if (!SWIG_IsOK(res1)) {
36897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36898 }
36899 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36900 {
36901 PyThreadState* __tstate = wxPyBeginAllowThreads();
36902 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
36903 wxPyEndAllowThreads(__tstate);
36904 if (PyErr_Occurred()) SWIG_fail;
36905 }
36906 {
36907 #if wxUSE_UNICODE
36908 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36909 #else
36910 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36911 #endif
36912 }
36913 return resultobj;
36914 fail:
36915 return NULL;
36916 }
36917
36918
36919 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36920 PyObject *resultobj = 0;
36921 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36922 wxString result;
36923 void *argp1 = 0 ;
36924 int res1 = 0 ;
36925 PyObject *swig_obj[1] ;
36926
36927 if (!args) SWIG_fail;
36928 swig_obj[0] = args;
36929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36930 if (!SWIG_IsOK(res1)) {
36931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36932 }
36933 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36934 {
36935 PyThreadState* __tstate = wxPyBeginAllowThreads();
36936 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
36937 wxPyEndAllowThreads(__tstate);
36938 if (PyErr_Occurred()) SWIG_fail;
36939 }
36940 {
36941 #if wxUSE_UNICODE
36942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36943 #else
36944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36945 #endif
36946 }
36947 return resultobj;
36948 fail:
36949 return NULL;
36950 }
36951
36952
36953 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36954 PyObject *resultobj = 0;
36955 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36956 wxString result;
36957 void *argp1 = 0 ;
36958 int res1 = 0 ;
36959 PyObject *swig_obj[1] ;
36960
36961 if (!args) SWIG_fail;
36962 swig_obj[0] = args;
36963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36964 if (!SWIG_IsOK(res1)) {
36965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36966 }
36967 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36968 {
36969 PyThreadState* __tstate = wxPyBeginAllowThreads();
36970 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
36971 wxPyEndAllowThreads(__tstate);
36972 if (PyErr_Occurred()) SWIG_fail;
36973 }
36974 {
36975 #if wxUSE_UNICODE
36976 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36977 #else
36978 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36979 #endif
36980 }
36981 return resultobj;
36982 fail:
36983 return NULL;
36984 }
36985
36986
36987 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36988 PyObject *resultobj = 0;
36989 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36990 wxString *arg2 = 0 ;
36991 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
36992 wxString result;
36993 void *argp1 = 0 ;
36994 int res1 = 0 ;
36995 bool temp2 = false ;
36996 int val3 ;
36997 int ecode3 = 0 ;
36998 PyObject * obj0 = 0 ;
36999 PyObject * obj1 = 0 ;
37000 PyObject * obj2 = 0 ;
37001 char * kwnames[] = {
37002 (char *) "self",(char *) "lang",(char *) "category", NULL
37003 };
37004
37005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37007 if (!SWIG_IsOK(res1)) {
37008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37009 }
37010 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37011 {
37012 arg2 = wxString_in_helper(obj1);
37013 if (arg2 == NULL) SWIG_fail;
37014 temp2 = true;
37015 }
37016 if (obj2) {
37017 ecode3 = SWIG_AsVal_int(obj2, &val3);
37018 if (!SWIG_IsOK(ecode3)) {
37019 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37020 }
37021 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37022 }
37023 {
37024 PyThreadState* __tstate = wxPyBeginAllowThreads();
37025 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37026 wxPyEndAllowThreads(__tstate);
37027 if (PyErr_Occurred()) SWIG_fail;
37028 }
37029 {
37030 #if wxUSE_UNICODE
37031 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37032 #else
37033 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37034 #endif
37035 }
37036 {
37037 if (temp2)
37038 delete arg2;
37039 }
37040 return resultobj;
37041 fail:
37042 {
37043 if (temp2)
37044 delete arg2;
37045 }
37046 return NULL;
37047 }
37048
37049
37050 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37051 PyObject *resultobj = 0;
37052 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37053 wxString result;
37054 void *argp1 = 0 ;
37055 int res1 = 0 ;
37056 PyObject *swig_obj[1] ;
37057
37058 if (!args) SWIG_fail;
37059 swig_obj[0] = args;
37060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37061 if (!SWIG_IsOK(res1)) {
37062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37063 }
37064 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37065 {
37066 PyThreadState* __tstate = wxPyBeginAllowThreads();
37067 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37068 wxPyEndAllowThreads(__tstate);
37069 if (PyErr_Occurred()) SWIG_fail;
37070 }
37071 {
37072 #if wxUSE_UNICODE
37073 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37074 #else
37075 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37076 #endif
37077 }
37078 return resultobj;
37079 fail:
37080 return NULL;
37081 }
37082
37083
37084 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37085 PyObject *resultobj = 0;
37086 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37087 wxString *arg2 = 0 ;
37088 void *argp1 = 0 ;
37089 int res1 = 0 ;
37090 bool temp2 = false ;
37091 PyObject * obj0 = 0 ;
37092 PyObject * obj1 = 0 ;
37093 char * kwnames[] = {
37094 (char *) "self",(char *) "prefix", NULL
37095 };
37096
37097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37099 if (!SWIG_IsOK(res1)) {
37100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37101 }
37102 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37103 {
37104 arg2 = wxString_in_helper(obj1);
37105 if (arg2 == NULL) SWIG_fail;
37106 temp2 = true;
37107 }
37108 {
37109 PyThreadState* __tstate = wxPyBeginAllowThreads();
37110 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
37111 wxPyEndAllowThreads(__tstate);
37112 if (PyErr_Occurred()) SWIG_fail;
37113 }
37114 resultobj = SWIG_Py_Void();
37115 {
37116 if (temp2)
37117 delete arg2;
37118 }
37119 return resultobj;
37120 fail:
37121 {
37122 if (temp2)
37123 delete arg2;
37124 }
37125 return NULL;
37126 }
37127
37128
37129 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37130 PyObject *resultobj = 0;
37131 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37132 wxString result;
37133 void *argp1 = 0 ;
37134 int res1 = 0 ;
37135 PyObject *swig_obj[1] ;
37136
37137 if (!args) SWIG_fail;
37138 swig_obj[0] = args;
37139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37140 if (!SWIG_IsOK(res1)) {
37141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37142 }
37143 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37144 {
37145 PyThreadState* __tstate = wxPyBeginAllowThreads();
37146 result = wxStandardPaths_GetInstallPrefix(arg1);
37147 wxPyEndAllowThreads(__tstate);
37148 if (PyErr_Occurred()) SWIG_fail;
37149 }
37150 {
37151 #if wxUSE_UNICODE
37152 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37153 #else
37154 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37155 #endif
37156 }
37157 return resultobj;
37158 fail:
37159 return NULL;
37160 }
37161
37162
37163 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37164 PyObject *obj;
37165 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37166 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37167 return SWIG_Py_Void();
37168 }
37169
37170 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37171 PyObject *resultobj = 0;
37172 wxEventType arg1 ;
37173 wxPowerEvent *result = 0 ;
37174 int val1 ;
37175 int ecode1 = 0 ;
37176 PyObject * obj0 = 0 ;
37177 char * kwnames[] = {
37178 (char *) "evtType", NULL
37179 };
37180
37181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37182 ecode1 = SWIG_AsVal_int(obj0, &val1);
37183 if (!SWIG_IsOK(ecode1)) {
37184 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37185 }
37186 arg1 = static_cast< wxEventType >(val1);
37187 {
37188 PyThreadState* __tstate = wxPyBeginAllowThreads();
37189 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37190 wxPyEndAllowThreads(__tstate);
37191 if (PyErr_Occurred()) SWIG_fail;
37192 }
37193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37194 return resultobj;
37195 fail:
37196 return NULL;
37197 }
37198
37199
37200 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37201 PyObject *resultobj = 0;
37202 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37203 void *argp1 = 0 ;
37204 int res1 = 0 ;
37205 PyObject *swig_obj[1] ;
37206
37207 if (!args) SWIG_fail;
37208 swig_obj[0] = args;
37209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37210 if (!SWIG_IsOK(res1)) {
37211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37212 }
37213 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37214 {
37215 PyThreadState* __tstate = wxPyBeginAllowThreads();
37216 (arg1)->Veto();
37217 wxPyEndAllowThreads(__tstate);
37218 if (PyErr_Occurred()) SWIG_fail;
37219 }
37220 resultobj = SWIG_Py_Void();
37221 return resultobj;
37222 fail:
37223 return NULL;
37224 }
37225
37226
37227 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37228 PyObject *resultobj = 0;
37229 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37230 bool result;
37231 void *argp1 = 0 ;
37232 int res1 = 0 ;
37233 PyObject *swig_obj[1] ;
37234
37235 if (!args) SWIG_fail;
37236 swig_obj[0] = args;
37237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37238 if (!SWIG_IsOK(res1)) {
37239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37240 }
37241 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37242 {
37243 PyThreadState* __tstate = wxPyBeginAllowThreads();
37244 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37245 wxPyEndAllowThreads(__tstate);
37246 if (PyErr_Occurred()) SWIG_fail;
37247 }
37248 {
37249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37250 }
37251 return resultobj;
37252 fail:
37253 return NULL;
37254 }
37255
37256
37257 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37258 PyObject *obj;
37259 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37260 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37261 return SWIG_Py_Void();
37262 }
37263
37264 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37265 return SWIG_Python_InitShadowInstance(args);
37266 }
37267
37268 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37269 PyObject *resultobj = 0;
37270 wxPowerType result;
37271
37272 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37273 {
37274 PyThreadState* __tstate = wxPyBeginAllowThreads();
37275 result = (wxPowerType)wxGetPowerType();
37276 wxPyEndAllowThreads(__tstate);
37277 if (PyErr_Occurred()) SWIG_fail;
37278 }
37279 resultobj = SWIG_From_int(static_cast< int >(result));
37280 return resultobj;
37281 fail:
37282 return NULL;
37283 }
37284
37285
37286 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37287 PyObject *resultobj = 0;
37288 wxBatteryState result;
37289
37290 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37291 {
37292 PyThreadState* __tstate = wxPyBeginAllowThreads();
37293 result = (wxBatteryState)wxGetBatteryState();
37294 wxPyEndAllowThreads(__tstate);
37295 if (PyErr_Occurred()) SWIG_fail;
37296 }
37297 resultobj = SWIG_From_int(static_cast< int >(result));
37298 return resultobj;
37299 fail:
37300 return NULL;
37301 }
37302
37303
37304 static PyMethodDef SwigMethods[] = {
37305 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
37306 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
37307 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
37308 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
37309 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
37310 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
37311 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
37312 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
37313 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
37314 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
37315 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
37316 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
37317 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
37318 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
37319 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
37320 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
37321 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
37322 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
37323 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
37324 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
37325 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
37326 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
37327 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
37328 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
37329 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
37330 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
37331 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
37332 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
37333 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
37334 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
37335 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
37336 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
37337 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
37338 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
37339 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
37340 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
37341 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
37342 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
37343 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
37344 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
37345 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
37346 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
37347 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
37348 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
37349 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
37350 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
37351 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
37352 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
37353 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
37354 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
37355 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37356 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37357 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37358 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37359 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37360 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37361 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
37362 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
37363 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
37364 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37365 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
37366 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
37367 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
37368 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
37369 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
37370 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
37371 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
37372 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
37373 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
37374 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37375 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
37376 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37377 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
37378 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
37379 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
37380 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37381 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37382 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
37383 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
37384 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
37385 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
37386 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
37387 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
37388 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
37389 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
37390 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
37391 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
37392 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
37393 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
37394 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
37395 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
37396 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
37397 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
37398 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
37399 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
37400 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
37401 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
37402 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
37403 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
37404 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
37405 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
37406 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
37407 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
37408 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
37409 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
37410 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
37411 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
37412 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
37413 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
37414 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
37415 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
37416 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
37417 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
37418 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
37419 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
37420 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
37421 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
37422 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
37423 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
37424 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
37425 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
37426 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
37427 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
37428 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
37429 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
37430 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
37431 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
37432 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
37433 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
37434 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
37435 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
37436 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
37437 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
37438 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
37439 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
37440 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
37441 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
37442 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
37443 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
37444 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
37445 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
37446 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37447 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
37448 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
37449 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
37450 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
37451 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
37452 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
37453 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
37454 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37455 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
37456 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
37457 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
37458 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
37459 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37460 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
37461 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
37462 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
37463 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
37464 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
37465 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37466 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
37467 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37468 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37469 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
37470 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37471 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37472 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
37473 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
37474 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
37475 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37476 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
37477 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
37478 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
37479 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
37480 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
37481 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
37482 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
37483 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
37484 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
37485 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
37486 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
37487 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
37488 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37489 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37490 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
37491 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
37492 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
37493 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
37494 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
37495 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
37496 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
37497 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
37498 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
37499 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
37500 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
37501 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
37502 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
37503 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
37504 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
37505 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
37506 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
37507 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
37508 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
37509 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
37510 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
37511 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
37512 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
37513 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
37514 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
37515 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
37516 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
37517 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
37518 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
37519 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
37520 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37521 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37522 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
37523 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
37524 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
37525 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37526 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
37527 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
37528 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37529 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
37530 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
37531 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37532 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
37533 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
37534 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
37535 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
37536 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
37537 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
37538 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
37539 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
37540 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37541 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
37542 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
37543 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
37544 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
37545 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
37546 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37547 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
37548 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
37549 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
37550 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
37551 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
37552 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
37553 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
37554 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
37555 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
37556 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
37557 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
37558 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
37559 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
37560 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
37561 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
37562 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
37563 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
37564 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
37565 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37566 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37567 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37568 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
37569 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
37570 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
37571 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
37572 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
37573 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37574 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
37575 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
37576 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
37577 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
37578 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
37579 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
37580 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
37581 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
37582 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
37583 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
37584 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
37585 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
37586 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
37587 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
37588 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
37589 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
37590 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
37591 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
37592 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
37593 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
37594 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
37595 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
37596 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
37597 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
37598 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
37599 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
37600 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
37601 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
37602 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
37603 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
37604 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
37605 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
37606 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
37607 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
37608 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
37609 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
37610 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
37611 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
37612 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
37613 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
37614 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37615 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
37616 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
37617 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
37618 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
37619 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
37620 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
37621 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
37622 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
37623 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
37624 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
37625 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
37626 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
37627 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
37628 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37629 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
37630 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
37631 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
37632 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
37633 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
37634 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
37635 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37636 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
37637 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
37638 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
37639 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
37640 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
37641 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
37642 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
37643 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
37644 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
37645 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
37646 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
37647 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
37648 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
37649 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37650 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
37651 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
37652 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
37653 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
37654 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
37655 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
37656 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
37657 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
37658 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
37659 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
37660 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
37661 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
37662 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
37663 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
37664 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
37665 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
37666 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
37667 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
37668 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
37669 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
37670 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
37671 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
37672 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
37673 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
37674 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
37675 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
37676 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
37677 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
37678 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
37679 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
37680 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
37681 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
37682 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
37683 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
37684 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
37685 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
37686 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
37687 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
37688 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
37689 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
37690 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
37691 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
37692 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
37693 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
37694 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
37695 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
37696 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
37697 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
37698 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
37699 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
37700 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
37701 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
37702 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
37703 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
37704 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
37705 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
37706 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37707 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
37708 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
37709 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
37710 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
37711 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
37712 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
37713 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
37714 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
37715 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
37716 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
37717 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
37718 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
37719 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
37720 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
37721 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
37722 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
37723 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
37724 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
37725 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
37726 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
37727 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
37728 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
37729 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
37730 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
37731 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
37732 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
37733 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
37734 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
37735 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
37736 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37737 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
37738 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
37739 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
37740 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37741 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
37742 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
37743 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
37744 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
37745 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
37746 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
37747 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
37748 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
37749 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
37750 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
37751 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
37752 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
37753 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
37754 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
37755 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
37756 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
37757 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
37758 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
37759 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
37760 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
37761 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37762 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37763 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
37764 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37765 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37766 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
37767 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37768 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
37769 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
37770 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
37771 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
37772 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
37773 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
37774 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
37775 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
37776 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
37777 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
37778 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
37779 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
37780 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
37781 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
37782 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
37783 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
37784 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
37785 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
37786 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
37787 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37788 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37789 { (char *)"ArtProvider_InsertProvider", (PyCFunction) _wrap_ArtProvider_InsertProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37790 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
37791 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37792 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
37793 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37794 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
37795 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
37796 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
37797 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
37798 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
37799 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
37800 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
37801 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
37802 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
37803 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
37804 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
37805 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
37806 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37807 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
37808 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37809 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
37810 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
37811 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37812 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37813 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
37814 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
37815 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
37816 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
37817 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
37818 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
37819 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
37820 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
37821 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
37822 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
37823 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
37824 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37825 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37826 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37827 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37828 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
37829 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37830 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
37831 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
37832 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
37833 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37834 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
37835 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
37836 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
37837 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
37838 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
37839 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
37840 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
37841 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
37842 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
37843 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
37844 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
37845 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
37846 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
37847 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
37848 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
37849 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
37850 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
37851 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
37852 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
37853 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
37854 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37855 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
37856 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
37857 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
37858 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
37859 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
37860 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37861 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
37862 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
37863 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
37864 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37865 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
37866 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
37867 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
37868 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
37869 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
37870 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
37871 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
37872 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
37873 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
37874 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
37875 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
37876 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
37877 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
37878 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
37879 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
37880 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
37881 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
37882 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
37883 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
37884 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
37885 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
37886 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
37887 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
37888 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37889 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
37890 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
37891 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
37892 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
37893 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
37894 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37895 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37896 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37897 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37898 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37899 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37900 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37901 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37902 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37903 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37904 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37905 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
37906 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
37907 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
37908 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
37909 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
37910 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
37911 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
37912 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
37913 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
37914 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
37915 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37916 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37917 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37918 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37919 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37920 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37921 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
37922 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
37923 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37924 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37925 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
37926 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
37927 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
37928 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
37929 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37930 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
37931 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37932 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
37933 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
37934 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
37935 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
37936 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
37937 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
37938 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37939 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
37940 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
37941 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
37942 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
37943 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
37944 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
37945 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
37946 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
37947 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
37948 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
37949 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
37950 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
37951 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
37952 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
37953 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
37954 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
37955 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
37956 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
37957 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
37958 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
37959 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
37960 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
37961 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37962 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37963 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
37964 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37965 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
37966 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
37967 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
37968 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
37969 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
37970 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
37971 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
37972 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
37973 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
37974 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
37975 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
37976 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
37977 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
37978 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
37979 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
37980 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
37981 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
37982 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
37983 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
37984 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
37985 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
37986 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
37987 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
37988 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
37989 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
37990 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
37991 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
37992 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
37993 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
37994 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
37995 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
37996 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
37997 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
37998 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
37999 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
38000 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
38001 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
38002 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
38003 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
38004 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
38005 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
38006 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
38007 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
38008 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
38009 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
38010 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
38011 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
38012 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
38013 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
38014 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
38015 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
38016 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
38017 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
38018 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
38019 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
38020 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
38021 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
38022 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
38023 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
38024 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
38025 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
38026 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
38027 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
38028 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
38029 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
38030 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
38031 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
38032 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
38033 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
38034 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
38035 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
38036 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
38037 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
38038 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
38039 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
38040 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
38041 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
38042 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
38043 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
38044 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
38045 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
38046 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
38047 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
38048 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
38049 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
38050 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
38051 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
38052 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
38053 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
38054 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
38055 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
38056 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
38057 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
38058 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
38059 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
38060 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
38061 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
38062 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38063 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38064 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
38065 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
38066 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
38067 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
38068 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
38069 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
38070 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
38071 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
38072 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
38073 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
38074 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38075 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
38076 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
38077 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
38078 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
38079 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
38080 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38081 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
38082 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
38083 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
38084 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38085 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
38086 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
38087 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38088 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
38089 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
38090 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
38091 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38092 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
38093 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
38094 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
38095 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
38096 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
38097 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
38098 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
38099 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38100 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
38101 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
38102 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
38103 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
38104 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
38105 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38106 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38107 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
38108 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
38109 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38110 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
38111 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
38112 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
38113 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
38114 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38115 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38116 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
38117 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
38118 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
38119 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
38120 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
38121 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
38122 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
38123 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
38124 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38125 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
38126 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
38127 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
38128 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
38129 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38130 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
38131 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
38132 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
38133 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
38134 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
38135 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
38136 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
38137 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
38138 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
38139 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
38140 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
38141 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38142 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
38143 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38144 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
38145 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
38146 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38147 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
38148 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
38149 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
38150 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
38151 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38152 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
38153 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
38154 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38155 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38156 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38157 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
38158 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38159 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
38160 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
38161 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
38162 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
38163 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
38164 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
38165 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38166 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
38167 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38168 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38169 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
38170 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38171 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
38172 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
38173 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
38174 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
38175 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38176 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
38177 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38178 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38179 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
38180 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38181 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
38182 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
38183 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
38184 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
38185 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
38186 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
38187 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
38188 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
38189 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
38190 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38191 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
38192 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
38193 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
38194 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
38195 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
38196 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
38197 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
38198 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
38199 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
38200 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
38201 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
38202 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
38203 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
38204 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
38205 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
38206 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
38207 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
38208 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
38209 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
38210 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
38211 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
38212 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
38213 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
38214 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
38215 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
38216 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
38217 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
38218 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
38219 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
38220 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
38221 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
38222 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
38223 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
38224 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
38225 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
38226 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
38227 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
38228 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
38229 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
38230 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
38231 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
38232 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
38233 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
38234 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
38235 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
38236 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
38237 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
38238 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
38239 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
38240 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
38241 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
38242 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
38243 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
38244 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
38245 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
38246 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
38247 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
38248 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
38249 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
38250 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
38251 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
38252 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
38253 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
38254 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
38255 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
38256 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
38257 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
38258 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
38259 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
38260 { NULL, NULL, 0, NULL }
38261 };
38262
38263
38264 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
38265
38266 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
38267 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
38268 }
38269 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
38270 return (void *)((wxEvent *) ((wxMenuEvent *) x));
38271 }
38272 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
38273 return (void *)((wxEvent *) ((wxCloseEvent *) x));
38274 }
38275 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
38276 return (void *)((wxEvent *) ((wxMouseEvent *) x));
38277 }
38278 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
38279 return (void *)((wxEvent *) ((wxEraseEvent *) x));
38280 }
38281 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
38282 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
38283 }
38284 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
38285 return (void *)((wxEvent *) ((wxTimerEvent *) x));
38286 }
38287 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
38288 return (void *)((wxEvent *) ((wxPowerEvent *) x));
38289 }
38290 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
38291 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
38292 }
38293 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
38294 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
38295 }
38296 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
38297 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
38298 }
38299 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
38300 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
38301 }
38302 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
38303 return (void *)((wxEvent *) ((wxPyEvent *) x));
38304 }
38305 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
38306 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
38307 }
38308 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
38309 return (void *)((wxEvent *) ((wxIdleEvent *) x));
38310 }
38311 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
38312 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
38313 }
38314 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
38315 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
38316 }
38317 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
38318 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
38319 }
38320 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
38321 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
38322 }
38323 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
38324 return (void *)((wxEvent *) ((wxActivateEvent *) x));
38325 }
38326 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
38327 return (void *)((wxEvent *) ((wxSizeEvent *) x));
38328 }
38329 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
38330 return (void *)((wxEvent *) ((wxMoveEvent *) x));
38331 }
38332 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
38333 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
38334 }
38335 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
38336 return (void *)((wxEvent *) ((wxPaintEvent *) x));
38337 }
38338 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
38339 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
38340 }
38341 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
38342 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
38343 }
38344 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
38345 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
38346 }
38347 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
38348 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
38349 }
38350 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
38351 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
38352 }
38353 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
38354 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
38355 }
38356 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
38357 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
38358 }
38359 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
38360 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
38361 }
38362 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
38363 return (void *)((wxEvent *) ((wxFocusEvent *) x));
38364 }
38365 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
38366 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
38367 }
38368 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
38369 return (void *)((wxEvent *) ((wxProcessEvent *) x));
38370 }
38371 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
38372 return (void *)((wxEvent *) ((wxShowEvent *) x));
38373 }
38374 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
38375 return (void *)((wxEvent *) ((wxCommandEvent *) x));
38376 }
38377 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
38378 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
38379 }
38380 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
38381 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
38382 }
38383 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
38384 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
38385 }
38386 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
38387 return (void *)((wxEvent *) ((wxKeyEvent *) x));
38388 }
38389 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
38390 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
38391 }
38392 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
38393 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
38394 }
38395 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
38396 return (void *)((wxConfigBase *) ((wxConfig *) x));
38397 }
38398 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
38399 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38400 }
38401 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
38402 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
38403 }
38404 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
38405 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
38406 }
38407 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
38408 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
38409 }
38410 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
38411 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
38412 }
38413 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
38414 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
38415 }
38416 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
38417 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
38418 }
38419 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
38420 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
38421 }
38422 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
38423 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38424 }
38425 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
38426 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
38427 }
38428 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
38429 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
38430 }
38431 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
38432 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
38433 }
38434 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
38435 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
38436 }
38437 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
38438 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
38439 }
38440 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
38441 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
38442 }
38443 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
38444 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
38445 }
38446 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
38447 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
38448 }
38449 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
38450 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38451 }
38452 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
38453 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
38454 }
38455 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
38456 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
38457 }
38458 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
38459 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
38460 }
38461 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
38462 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
38463 }
38464 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
38465 return (void *)((wxEvtHandler *) ((wxWindow *) x));
38466 }
38467 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
38468 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
38469 }
38470 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
38471 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
38472 }
38473 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
38474 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
38475 }
38476 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
38477 return (void *)((wxEvtHandler *) ((wxValidator *) x));
38478 }
38479 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
38480 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
38481 }
38482 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
38483 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
38484 }
38485 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
38486 return (void *)((wxEvtHandler *) ((wxMenu *) x));
38487 }
38488 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
38489 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
38490 }
38491 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
38492 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
38493 }
38494 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
38495 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
38496 }
38497 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
38498 return (void *)((wxObject *) ((wxSizerItem *) x));
38499 }
38500 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
38501 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
38502 }
38503 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
38504 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
38505 }
38506 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
38507 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
38508 }
38509 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
38510 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
38511 }
38512 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
38513 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
38514 }
38515 static void *_p_wxSizerTo_p_wxObject(void *x) {
38516 return (void *)((wxObject *) ((wxSizer *) x));
38517 }
38518 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
38519 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
38520 }
38521 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
38522 return (void *)((wxObject *) ((wxFileHistory *) x));
38523 }
38524 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
38525 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
38526 }
38527 static void *_p_wxEventTo_p_wxObject(void *x) {
38528 return (void *)((wxObject *) ((wxEvent *) x));
38529 }
38530 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
38531 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
38532 }
38533 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
38534 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
38535 }
38536 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
38537 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
38538 }
38539 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
38540 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
38541 }
38542 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
38543 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
38544 }
38545 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
38546 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
38547 }
38548 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
38549 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
38550 }
38551 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
38552 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
38553 }
38554 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
38555 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
38556 }
38557 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
38558 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
38559 }
38560 static void *_p_wxControlTo_p_wxObject(void *x) {
38561 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
38562 }
38563 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
38564 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
38565 }
38566 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
38567 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
38568 }
38569 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
38570 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
38571 }
38572 static void *_p_wxFSFileTo_p_wxObject(void *x) {
38573 return (void *)((wxObject *) ((wxFSFile *) x));
38574 }
38575 static void *_p_wxClipboardTo_p_wxObject(void *x) {
38576 return (void *)((wxObject *) ((wxClipboard *) x));
38577 }
38578 static void *_p_wxPySizerTo_p_wxObject(void *x) {
38579 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
38580 }
38581 static void *_p_wxPyEventTo_p_wxObject(void *x) {
38582 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
38583 }
38584 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
38585 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
38586 }
38587 static void *_p_wxShowEventTo_p_wxObject(void *x) {
38588 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
38589 }
38590 static void *_p_wxToolTipTo_p_wxObject(void *x) {
38591 return (void *)((wxObject *) ((wxToolTip *) x));
38592 }
38593 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
38594 return (void *)((wxObject *) ((wxMenuItem *) x));
38595 }
38596 static void *_p_wxDateEventTo_p_wxObject(void *x) {
38597 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
38598 }
38599 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
38600 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
38601 }
38602 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
38603 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
38604 }
38605 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
38606 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
38607 }
38608 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
38609 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
38610 }
38611 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
38612 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
38613 }
38614 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
38615 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
38616 }
38617 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
38618 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
38619 }
38620 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
38621 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
38622 }
38623 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
38624 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
38625 }
38626 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
38627 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
38628 }
38629 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
38630 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
38631 }
38632 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
38633 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
38634 }
38635 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
38636 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
38637 }
38638 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
38639 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
38640 }
38641 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
38642 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
38643 }
38644 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
38645 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
38646 }
38647 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
38648 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
38649 }
38650 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
38651 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
38652 }
38653 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
38654 return (void *)((wxObject *) ((wxImageHandler *) x));
38655 }
38656 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
38657 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
38658 }
38659 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
38660 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
38661 }
38662 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
38663 return (void *)((wxObject *) ((wxEvtHandler *) x));
38664 }
38665 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
38666 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
38667 }
38668 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
38669 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
38670 }
38671 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
38672 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
38673 }
38674 static void *_p_wxImageTo_p_wxObject(void *x) {
38675 return (void *)((wxObject *) ((wxImage *) x));
38676 }
38677 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
38678 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
38679 }
38680 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
38681 return (void *)((wxObject *) ((wxSystemOptions *) x));
38682 }
38683 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
38684 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
38685 }
38686 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
38687 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
38688 }
38689 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
38690 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
38691 }
38692 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
38693 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
38694 }
38695 static void *_p_wxWindowTo_p_wxObject(void *x) {
38696 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
38697 }
38698 static void *_p_wxMenuTo_p_wxObject(void *x) {
38699 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
38700 }
38701 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
38702 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
38703 }
38704 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
38705 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
38706 }
38707 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
38708 return (void *)((wxObject *) ((wxFileSystem *) x));
38709 }
38710 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
38711 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
38712 }
38713 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
38714 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
38715 }
38716 static void *_p_wxPyAppTo_p_wxObject(void *x) {
38717 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
38718 }
38719 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
38720 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
38721 }
38722 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
38723 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
38724 }
38725 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
38726 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
38727 }
38728 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
38729 return (void *)((wxObject *) ((wxBusyInfo *) x));
38730 }
38731 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
38732 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
38733 }
38734 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
38735 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
38736 }
38737 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
38738 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
38739 }
38740 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
38741 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
38742 }
38743 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
38744 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
38745 }
38746 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
38747 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
38748 }
38749 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
38750 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
38751 }
38752 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
38753 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
38754 }
38755 static void *_p_wxValidatorTo_p_wxObject(void *x) {
38756 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
38757 }
38758 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
38759 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
38760 }
38761 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
38762 return (void *)((wxLog *) ((wxLogBuffer *) x));
38763 }
38764 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
38765 return (void *)((wxLog *) ((wxLogStderr *) x));
38766 }
38767 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
38768 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
38769 }
38770 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
38771 return (void *)((wxLog *) ((wxLogWindow *) x));
38772 }
38773 static void *_p_wxLogChainTo_p_wxLog(void *x) {
38774 return (void *)((wxLog *) ((wxLogChain *) x));
38775 }
38776 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
38777 return (void *)((wxLog *) ((wxLogGui *) x));
38778 }
38779 static void *_p_wxPyLogTo_p_wxLog(void *x) {
38780 return (void *)((wxLog *) ((wxPyLog *) x));
38781 }
38782 static void *_p_wxControlTo_p_wxWindow(void *x) {
38783 return (void *)((wxWindow *) ((wxControl *) x));
38784 }
38785 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
38786 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
38787 }
38788 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
38789 return (void *)((wxWindow *) ((wxMenuBar *) x));
38790 }
38791 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
38792 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
38793 }
38794 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
38795 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
38796 }
38797 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
38798 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};
38799 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
38800 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
38801 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
38802 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
38803 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
38804 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
38805 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
38806 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
38807 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
38808 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
38809 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
38810 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
38811 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
38812 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
38813 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
38814 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
38815 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
38816 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
38817 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
38818 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
38819 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
38820 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
38821 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
38822 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
38823 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
38824 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
38825 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
38826 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
38827 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
38828 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
38829 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
38830 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
38831 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
38832 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
38833 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
38834 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
38835 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
38836 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
38837 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
38838 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
38839 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
38840 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
38841 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
38842 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
38843 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
38844 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
38845 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
38846 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
38847 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
38848 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
38849 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
38850 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
38851 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
38852 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
38853 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
38854 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
38855 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
38856 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
38857 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
38858 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
38859 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
38860 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
38861 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
38862 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
38863 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
38864 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
38865 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
38866 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
38867 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
38868 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
38869 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
38870 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
38871 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
38872 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
38873 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
38874 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
38875 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
38876 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
38877 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
38878 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
38879 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
38880 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
38881 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
38882 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
38883 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
38884 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
38885 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
38886 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
38887 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
38888 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
38889 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
38890 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
38891 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
38892 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
38893 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
38894 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
38895 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
38896 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
38897 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
38898 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
38899 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
38900 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
38901 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
38902 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
38903 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
38904 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
38905 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
38906 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
38907 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
38908 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
38909 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
38910 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
38911 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
38912 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
38913 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
38914 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
38915 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
38916 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
38917 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
38918 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
38919 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
38920 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
38921 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
38922 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
38923 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
38924 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
38925 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
38926 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
38927 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
38928 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
38929 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
38930 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
38931 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
38932 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
38933 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
38934 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
38935 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
38936 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
38937 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
38938 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
38939 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
38940 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
38941 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
38942 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
38943 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
38944 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
38945 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
38946 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
38947 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
38948 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
38949 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
38950 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
38951 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
38952 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
38953 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
38954 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
38955 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
38956 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
38957 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
38958 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
38959 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
38960 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
38961 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
38962 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
38963 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
38964 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
38965 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
38966 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
38967 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
38968 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
38969 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
38970
38971 static swig_type_info *swig_type_initial[] = {
38972 &_swigt__p_char,
38973 &_swigt__p_form_ops_t,
38974 &_swigt__p_int,
38975 &_swigt__p_unsigned_char,
38976 &_swigt__p_unsigned_int,
38977 &_swigt__p_unsigned_long,
38978 &_swigt__p_void,
38979 &_swigt__p_wxANIHandler,
38980 &_swigt__p_wxAcceleratorTable,
38981 &_swigt__p_wxActivateEvent,
38982 &_swigt__p_wxArrayString,
38983 &_swigt__p_wxBMPHandler,
38984 &_swigt__p_wxBitmap,
38985 &_swigt__p_wxBitmapDataObject,
38986 &_swigt__p_wxBoxSizer,
38987 &_swigt__p_wxBusyCursor,
38988 &_swigt__p_wxBusyInfo,
38989 &_swigt__p_wxCURHandler,
38990 &_swigt__p_wxCaret,
38991 &_swigt__p_wxChar,
38992 &_swigt__p_wxChildFocusEvent,
38993 &_swigt__p_wxClipboard,
38994 &_swigt__p_wxClipboardLocker,
38995 &_swigt__p_wxClipboardTextEvent,
38996 &_swigt__p_wxCloseEvent,
38997 &_swigt__p_wxColour,
38998 &_swigt__p_wxCommandEvent,
38999 &_swigt__p_wxConfig,
39000 &_swigt__p_wxConfigBase,
39001 &_swigt__p_wxConfigPathChanger,
39002 &_swigt__p_wxContextMenuEvent,
39003 &_swigt__p_wxControl,
39004 &_swigt__p_wxControlWithItems,
39005 &_swigt__p_wxCursor,
39006 &_swigt__p_wxCustomDataObject,
39007 &_swigt__p_wxDC,
39008 &_swigt__p_wxDataFormat,
39009 &_swigt__p_wxDataObject,
39010 &_swigt__p_wxDataObjectComposite,
39011 &_swigt__p_wxDataObjectSimple,
39012 &_swigt__p_wxDateEvent,
39013 &_swigt__p_wxDateSpan,
39014 &_swigt__p_wxDateTime,
39015 &_swigt__p_wxDateTime__TimeZone,
39016 &_swigt__p_wxDisplay,
39017 &_swigt__p_wxDisplayChangedEvent,
39018 &_swigt__p_wxDropFilesEvent,
39019 &_swigt__p_wxDuplexMode,
39020 &_swigt__p_wxEraseEvent,
39021 &_swigt__p_wxEvent,
39022 &_swigt__p_wxEvtHandler,
39023 &_swigt__p_wxFSFile,
39024 &_swigt__p_wxFileConfig,
39025 &_swigt__p_wxFileDataObject,
39026 &_swigt__p_wxFileHistory,
39027 &_swigt__p_wxFileSystem,
39028 &_swigt__p_wxFileType,
39029 &_swigt__p_wxFileTypeInfo,
39030 &_swigt__p_wxFlexGridSizer,
39031 &_swigt__p_wxFocusEvent,
39032 &_swigt__p_wxFont,
39033 &_swigt__p_wxFrame,
39034 &_swigt__p_wxGBSizerItem,
39035 &_swigt__p_wxGIFHandler,
39036 &_swigt__p_wxGridBagSizer,
39037 &_swigt__p_wxGridSizer,
39038 &_swigt__p_wxICOHandler,
39039 &_swigt__p_wxIcon,
39040 &_swigt__p_wxIconizeEvent,
39041 &_swigt__p_wxIdleEvent,
39042 &_swigt__p_wxImage,
39043 &_swigt__p_wxImageHandler,
39044 &_swigt__p_wxIndividualLayoutConstraint,
39045 &_swigt__p_wxInitDialogEvent,
39046 &_swigt__p_wxJPEGHandler,
39047 &_swigt__p_wxJoystick,
39048 &_swigt__p_wxJoystickEvent,
39049 &_swigt__p_wxKeyEvent,
39050 &_swigt__p_wxKillError,
39051 &_swigt__p_wxLayoutConstraints,
39052 &_swigt__p_wxLog,
39053 &_swigt__p_wxLogBuffer,
39054 &_swigt__p_wxLogChain,
39055 &_swigt__p_wxLogGui,
39056 &_swigt__p_wxLogNull,
39057 &_swigt__p_wxLogStderr,
39058 &_swigt__p_wxLogTextCtrl,
39059 &_swigt__p_wxLogWindow,
39060 &_swigt__p_wxMaximizeEvent,
39061 &_swigt__p_wxMenu,
39062 &_swigt__p_wxMenuBar,
39063 &_swigt__p_wxMenuEvent,
39064 &_swigt__p_wxMenuItem,
39065 &_swigt__p_wxMetafile,
39066 &_swigt__p_wxMetafileDataObject,
39067 &_swigt__p_wxMimeTypesManager,
39068 &_swigt__p_wxMouseCaptureChangedEvent,
39069 &_swigt__p_wxMouseCaptureLostEvent,
39070 &_swigt__p_wxMouseEvent,
39071 &_swigt__p_wxMouseState,
39072 &_swigt__p_wxMoveEvent,
39073 &_swigt__p_wxMutexGuiLocker,
39074 &_swigt__p_wxNavigationKeyEvent,
39075 &_swigt__p_wxNcPaintEvent,
39076 &_swigt__p_wxNotifyEvent,
39077 &_swigt__p_wxObject,
39078 &_swigt__p_wxOutputStream,
39079 &_swigt__p_wxPCXHandler,
39080 &_swigt__p_wxPNGHandler,
39081 &_swigt__p_wxPNMHandler,
39082 &_swigt__p_wxPaintEvent,
39083 &_swigt__p_wxPaletteChangedEvent,
39084 &_swigt__p_wxPaperSize,
39085 &_swigt__p_wxPlatformInfo,
39086 &_swigt__p_wxPoint,
39087 &_swigt__p_wxPowerEvent,
39088 &_swigt__p_wxProcessEvent,
39089 &_swigt__p_wxPyApp,
39090 &_swigt__p_wxPyArtProvider,
39091 &_swigt__p_wxPyBitmapDataObject,
39092 &_swigt__p_wxPyCommandEvent,
39093 &_swigt__p_wxPyDataObjectSimple,
39094 &_swigt__p_wxPyDropSource,
39095 &_swigt__p_wxPyDropTarget,
39096 &_swigt__p_wxPyEvent,
39097 &_swigt__p_wxPyFileDropTarget,
39098 &_swigt__p_wxPyImageHandler,
39099 &_swigt__p_wxPyLog,
39100 &_swigt__p_wxPyProcess,
39101 &_swigt__p_wxPySizer,
39102 &_swigt__p_wxPyTextDataObject,
39103 &_swigt__p_wxPyTextDropTarget,
39104 &_swigt__p_wxPyTimer,
39105 &_swigt__p_wxPyTipProvider,
39106 &_swigt__p_wxPyValidator,
39107 &_swigt__p_wxQueryNewPaletteEvent,
39108 &_swigt__p_wxRect,
39109 &_swigt__p_wxScrollEvent,
39110 &_swigt__p_wxScrollWinEvent,
39111 &_swigt__p_wxSetCursorEvent,
39112 &_swigt__p_wxShowEvent,
39113 &_swigt__p_wxSingleInstanceChecker,
39114 &_swigt__p_wxSize,
39115 &_swigt__p_wxSizeEvent,
39116 &_swigt__p_wxSizer,
39117 &_swigt__p_wxSizerItem,
39118 &_swigt__p_wxSound,
39119 &_swigt__p_wxStandardPaths,
39120 &_swigt__p_wxStaticBoxSizer,
39121 &_swigt__p_wxStdDialogButtonSizer,
39122 &_swigt__p_wxStopWatch,
39123 &_swigt__p_wxString,
39124 &_swigt__p_wxSysColourChangedEvent,
39125 &_swigt__p_wxSystemOptions,
39126 &_swigt__p_wxSystemSettings,
39127 &_swigt__p_wxTIFFHandler,
39128 &_swigt__p_wxTextCtrl,
39129 &_swigt__p_wxTextDataObject,
39130 &_swigt__p_wxTimeSpan,
39131 &_swigt__p_wxTimer,
39132 &_swigt__p_wxTimerEvent,
39133 &_swigt__p_wxTimerRunner,
39134 &_swigt__p_wxTipProvider,
39135 &_swigt__p_wxToolTip,
39136 &_swigt__p_wxURLDataObject,
39137 &_swigt__p_wxUpdateUIEvent,
39138 &_swigt__p_wxValidator,
39139 &_swigt__p_wxVideoMode,
39140 &_swigt__p_wxWindow,
39141 &_swigt__p_wxWindowCreateEvent,
39142 &_swigt__p_wxWindowDestroyEvent,
39143 &_swigt__p_wxWindowDisabler,
39144 &_swigt__p_wxXPMHandler,
39145 };
39146
39147 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
39148 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
39149 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
39150 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
39151 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
39152 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
39153 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
39154 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
39155 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
39156 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}};
39157 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
39158 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
39159 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
39160 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
39161 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
39162 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
39163 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
39164 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
39165 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}};
39166 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
39167 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
39168 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
39169 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
39170 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
39171 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}};
39172 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
39173 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}};
39174 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
39175 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
39176 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
39177 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
39178 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
39179 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
39180 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
39181 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
39182 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
39183 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
39184 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
39185 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
39186 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
39187 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
39188 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
39189 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
39190 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
39191 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
39192 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
39193 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39194 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39195 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
39196 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39197 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
39198 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
39199 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
39200 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
39201 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
39202 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
39203 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39204 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39205 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39206 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39207 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
39208 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
39209 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
39210 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
39211 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
39212 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
39213 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
39214 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
39215 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
39216 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
39217 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
39218 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
39219 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
39220 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
39221 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
39222 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
39223 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
39224 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}};
39225 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
39226 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
39227 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
39228 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
39229 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
39230 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
39231 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
39232 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
39233 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
39234 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
39235 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
39236 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}};
39237 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
39238 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
39239 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
39240 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
39241 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
39242 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
39243 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
39244 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
39245 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
39246 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
39247 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
39248 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
39249 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
39250 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
39251 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
39252 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
39253 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
39254 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
39255 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
39256 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
39257 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
39258 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
39259 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
39260 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
39261 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
39262 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
39263 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
39264 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
39265 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
39266 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
39267 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
39268 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
39269 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
39270 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
39271 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
39272 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
39273 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
39274 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
39275 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
39276 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
39277 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
39278 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
39279 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
39280 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
39281 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
39282 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
39283 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
39284 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
39285 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
39286 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
39287 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
39288 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
39289 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
39290 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
39291 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}};
39292 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
39293 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
39294 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
39295 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
39296 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
39297 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
39298 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
39299 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
39300 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
39301 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
39302 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
39303 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
39304 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
39305 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
39306 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
39307 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
39308 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
39309 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}};
39310 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
39311 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
39312 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
39313 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
39314 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}};
39315 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
39316 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
39317 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
39318 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}};
39319 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
39320
39321 static swig_cast_info *swig_cast_initial[] = {
39322 _swigc__p_char,
39323 _swigc__p_form_ops_t,
39324 _swigc__p_int,
39325 _swigc__p_unsigned_char,
39326 _swigc__p_unsigned_int,
39327 _swigc__p_unsigned_long,
39328 _swigc__p_void,
39329 _swigc__p_wxANIHandler,
39330 _swigc__p_wxAcceleratorTable,
39331 _swigc__p_wxActivateEvent,
39332 _swigc__p_wxArrayString,
39333 _swigc__p_wxBMPHandler,
39334 _swigc__p_wxBitmap,
39335 _swigc__p_wxBitmapDataObject,
39336 _swigc__p_wxBoxSizer,
39337 _swigc__p_wxBusyCursor,
39338 _swigc__p_wxBusyInfo,
39339 _swigc__p_wxCURHandler,
39340 _swigc__p_wxCaret,
39341 _swigc__p_wxChar,
39342 _swigc__p_wxChildFocusEvent,
39343 _swigc__p_wxClipboard,
39344 _swigc__p_wxClipboardLocker,
39345 _swigc__p_wxClipboardTextEvent,
39346 _swigc__p_wxCloseEvent,
39347 _swigc__p_wxColour,
39348 _swigc__p_wxCommandEvent,
39349 _swigc__p_wxConfig,
39350 _swigc__p_wxConfigBase,
39351 _swigc__p_wxConfigPathChanger,
39352 _swigc__p_wxContextMenuEvent,
39353 _swigc__p_wxControl,
39354 _swigc__p_wxControlWithItems,
39355 _swigc__p_wxCursor,
39356 _swigc__p_wxCustomDataObject,
39357 _swigc__p_wxDC,
39358 _swigc__p_wxDataFormat,
39359 _swigc__p_wxDataObject,
39360 _swigc__p_wxDataObjectComposite,
39361 _swigc__p_wxDataObjectSimple,
39362 _swigc__p_wxDateEvent,
39363 _swigc__p_wxDateSpan,
39364 _swigc__p_wxDateTime,
39365 _swigc__p_wxDateTime__TimeZone,
39366 _swigc__p_wxDisplay,
39367 _swigc__p_wxDisplayChangedEvent,
39368 _swigc__p_wxDropFilesEvent,
39369 _swigc__p_wxDuplexMode,
39370 _swigc__p_wxEraseEvent,
39371 _swigc__p_wxEvent,
39372 _swigc__p_wxEvtHandler,
39373 _swigc__p_wxFSFile,
39374 _swigc__p_wxFileConfig,
39375 _swigc__p_wxFileDataObject,
39376 _swigc__p_wxFileHistory,
39377 _swigc__p_wxFileSystem,
39378 _swigc__p_wxFileType,
39379 _swigc__p_wxFileTypeInfo,
39380 _swigc__p_wxFlexGridSizer,
39381 _swigc__p_wxFocusEvent,
39382 _swigc__p_wxFont,
39383 _swigc__p_wxFrame,
39384 _swigc__p_wxGBSizerItem,
39385 _swigc__p_wxGIFHandler,
39386 _swigc__p_wxGridBagSizer,
39387 _swigc__p_wxGridSizer,
39388 _swigc__p_wxICOHandler,
39389 _swigc__p_wxIcon,
39390 _swigc__p_wxIconizeEvent,
39391 _swigc__p_wxIdleEvent,
39392 _swigc__p_wxImage,
39393 _swigc__p_wxImageHandler,
39394 _swigc__p_wxIndividualLayoutConstraint,
39395 _swigc__p_wxInitDialogEvent,
39396 _swigc__p_wxJPEGHandler,
39397 _swigc__p_wxJoystick,
39398 _swigc__p_wxJoystickEvent,
39399 _swigc__p_wxKeyEvent,
39400 _swigc__p_wxKillError,
39401 _swigc__p_wxLayoutConstraints,
39402 _swigc__p_wxLog,
39403 _swigc__p_wxLogBuffer,
39404 _swigc__p_wxLogChain,
39405 _swigc__p_wxLogGui,
39406 _swigc__p_wxLogNull,
39407 _swigc__p_wxLogStderr,
39408 _swigc__p_wxLogTextCtrl,
39409 _swigc__p_wxLogWindow,
39410 _swigc__p_wxMaximizeEvent,
39411 _swigc__p_wxMenu,
39412 _swigc__p_wxMenuBar,
39413 _swigc__p_wxMenuEvent,
39414 _swigc__p_wxMenuItem,
39415 _swigc__p_wxMetafile,
39416 _swigc__p_wxMetafileDataObject,
39417 _swigc__p_wxMimeTypesManager,
39418 _swigc__p_wxMouseCaptureChangedEvent,
39419 _swigc__p_wxMouseCaptureLostEvent,
39420 _swigc__p_wxMouseEvent,
39421 _swigc__p_wxMouseState,
39422 _swigc__p_wxMoveEvent,
39423 _swigc__p_wxMutexGuiLocker,
39424 _swigc__p_wxNavigationKeyEvent,
39425 _swigc__p_wxNcPaintEvent,
39426 _swigc__p_wxNotifyEvent,
39427 _swigc__p_wxObject,
39428 _swigc__p_wxOutputStream,
39429 _swigc__p_wxPCXHandler,
39430 _swigc__p_wxPNGHandler,
39431 _swigc__p_wxPNMHandler,
39432 _swigc__p_wxPaintEvent,
39433 _swigc__p_wxPaletteChangedEvent,
39434 _swigc__p_wxPaperSize,
39435 _swigc__p_wxPlatformInfo,
39436 _swigc__p_wxPoint,
39437 _swigc__p_wxPowerEvent,
39438 _swigc__p_wxProcessEvent,
39439 _swigc__p_wxPyApp,
39440 _swigc__p_wxPyArtProvider,
39441 _swigc__p_wxPyBitmapDataObject,
39442 _swigc__p_wxPyCommandEvent,
39443 _swigc__p_wxPyDataObjectSimple,
39444 _swigc__p_wxPyDropSource,
39445 _swigc__p_wxPyDropTarget,
39446 _swigc__p_wxPyEvent,
39447 _swigc__p_wxPyFileDropTarget,
39448 _swigc__p_wxPyImageHandler,
39449 _swigc__p_wxPyLog,
39450 _swigc__p_wxPyProcess,
39451 _swigc__p_wxPySizer,
39452 _swigc__p_wxPyTextDataObject,
39453 _swigc__p_wxPyTextDropTarget,
39454 _swigc__p_wxPyTimer,
39455 _swigc__p_wxPyTipProvider,
39456 _swigc__p_wxPyValidator,
39457 _swigc__p_wxQueryNewPaletteEvent,
39458 _swigc__p_wxRect,
39459 _swigc__p_wxScrollEvent,
39460 _swigc__p_wxScrollWinEvent,
39461 _swigc__p_wxSetCursorEvent,
39462 _swigc__p_wxShowEvent,
39463 _swigc__p_wxSingleInstanceChecker,
39464 _swigc__p_wxSize,
39465 _swigc__p_wxSizeEvent,
39466 _swigc__p_wxSizer,
39467 _swigc__p_wxSizerItem,
39468 _swigc__p_wxSound,
39469 _swigc__p_wxStandardPaths,
39470 _swigc__p_wxStaticBoxSizer,
39471 _swigc__p_wxStdDialogButtonSizer,
39472 _swigc__p_wxStopWatch,
39473 _swigc__p_wxString,
39474 _swigc__p_wxSysColourChangedEvent,
39475 _swigc__p_wxSystemOptions,
39476 _swigc__p_wxSystemSettings,
39477 _swigc__p_wxTIFFHandler,
39478 _swigc__p_wxTextCtrl,
39479 _swigc__p_wxTextDataObject,
39480 _swigc__p_wxTimeSpan,
39481 _swigc__p_wxTimer,
39482 _swigc__p_wxTimerEvent,
39483 _swigc__p_wxTimerRunner,
39484 _swigc__p_wxTipProvider,
39485 _swigc__p_wxToolTip,
39486 _swigc__p_wxURLDataObject,
39487 _swigc__p_wxUpdateUIEvent,
39488 _swigc__p_wxValidator,
39489 _swigc__p_wxVideoMode,
39490 _swigc__p_wxWindow,
39491 _swigc__p_wxWindowCreateEvent,
39492 _swigc__p_wxWindowDestroyEvent,
39493 _swigc__p_wxWindowDisabler,
39494 _swigc__p_wxXPMHandler,
39495 };
39496
39497
39498 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
39499
39500 static swig_const_info swig_const_table[] = {
39501 {0, 0, 0, 0.0, 0, 0}};
39502
39503 #ifdef __cplusplus
39504 }
39505 #endif
39506 /* -----------------------------------------------------------------------------
39507 * Type initialization:
39508 * This problem is tough by the requirement that no dynamic
39509 * memory is used. Also, since swig_type_info structures store pointers to
39510 * swig_cast_info structures and swig_cast_info structures store pointers back
39511 * to swig_type_info structures, we need some lookup code at initialization.
39512 * The idea is that swig generates all the structures that are needed.
39513 * The runtime then collects these partially filled structures.
39514 * The SWIG_InitializeModule function takes these initial arrays out of
39515 * swig_module, and does all the lookup, filling in the swig_module.types
39516 * array with the correct data and linking the correct swig_cast_info
39517 * structures together.
39518 *
39519 * The generated swig_type_info structures are assigned staticly to an initial
39520 * array. We just loop though that array, and handle each type individually.
39521 * First we lookup if this type has been already loaded, and if so, use the
39522 * loaded structure instead of the generated one. Then we have to fill in the
39523 * cast linked list. The cast data is initially stored in something like a
39524 * two-dimensional array. Each row corresponds to a type (there are the same
39525 * number of rows as there are in the swig_type_initial array). Each entry in
39526 * a column is one of the swig_cast_info structures for that type.
39527 * The cast_initial array is actually an array of arrays, because each row has
39528 * a variable number of columns. So to actually build the cast linked list,
39529 * we find the array of casts associated with the type, and loop through it
39530 * adding the casts to the list. The one last trick we need to do is making
39531 * sure the type pointer in the swig_cast_info struct is correct.
39532 *
39533 * First off, we lookup the cast->type name to see if it is already loaded.
39534 * There are three cases to handle:
39535 * 1) If the cast->type has already been loaded AND the type we are adding
39536 * casting info to has not been loaded (it is in this module), THEN we
39537 * replace the cast->type pointer with the type pointer that has already
39538 * been loaded.
39539 * 2) If BOTH types (the one we are adding casting info to, and the
39540 * cast->type) are loaded, THEN the cast info has already been loaded by
39541 * the previous module so we just ignore it.
39542 * 3) Finally, if cast->type has not already been loaded, then we add that
39543 * swig_cast_info to the linked list (because the cast->type) pointer will
39544 * be correct.
39545 * ----------------------------------------------------------------------------- */
39546
39547 #ifdef __cplusplus
39548 extern "C" {
39549 #if 0
39550 } /* c-mode */
39551 #endif
39552 #endif
39553
39554 #if 0
39555 #define SWIGRUNTIME_DEBUG
39556 #endif
39557
39558 SWIGRUNTIME void
39559 SWIG_InitializeModule(void *clientdata) {
39560 size_t i;
39561 swig_module_info *module_head;
39562 static int init_run = 0;
39563
39564 clientdata = clientdata;
39565
39566 if (init_run) return;
39567 init_run = 1;
39568
39569 /* Initialize the swig_module */
39570 swig_module.type_initial = swig_type_initial;
39571 swig_module.cast_initial = swig_cast_initial;
39572
39573 /* Try and load any already created modules */
39574 module_head = SWIG_GetModule(clientdata);
39575 if (module_head) {
39576 swig_module.next = module_head->next;
39577 module_head->next = &swig_module;
39578 } else {
39579 /* This is the first module loaded */
39580 swig_module.next = &swig_module;
39581 SWIG_SetModule(clientdata, &swig_module);
39582 }
39583
39584 /* Now work on filling in swig_module.types */
39585 #ifdef SWIGRUNTIME_DEBUG
39586 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
39587 #endif
39588 for (i = 0; i < swig_module.size; ++i) {
39589 swig_type_info *type = 0;
39590 swig_type_info *ret;
39591 swig_cast_info *cast;
39592
39593 #ifdef SWIGRUNTIME_DEBUG
39594 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
39595 #endif
39596
39597 /* if there is another module already loaded */
39598 if (swig_module.next != &swig_module) {
39599 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
39600 }
39601 if (type) {
39602 /* Overwrite clientdata field */
39603 #ifdef SWIGRUNTIME_DEBUG
39604 printf("SWIG_InitializeModule: found type %s\n", type->name);
39605 #endif
39606 if (swig_module.type_initial[i]->clientdata) {
39607 type->clientdata = swig_module.type_initial[i]->clientdata;
39608 #ifdef SWIGRUNTIME_DEBUG
39609 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
39610 #endif
39611 }
39612 } else {
39613 type = swig_module.type_initial[i];
39614 }
39615
39616 /* Insert casting types */
39617 cast = swig_module.cast_initial[i];
39618 while (cast->type) {
39619 /* Don't need to add information already in the list */
39620 ret = 0;
39621 #ifdef SWIGRUNTIME_DEBUG
39622 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
39623 #endif
39624 if (swig_module.next != &swig_module) {
39625 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
39626 #ifdef SWIGRUNTIME_DEBUG
39627 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
39628 #endif
39629 }
39630 if (ret) {
39631 if (type == swig_module.type_initial[i]) {
39632 #ifdef SWIGRUNTIME_DEBUG
39633 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
39634 #endif
39635 cast->type = ret;
39636 ret = 0;
39637 } else {
39638 /* Check for casting already in the list */
39639 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
39640 #ifdef SWIGRUNTIME_DEBUG
39641 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
39642 #endif
39643 if (!ocast) ret = 0;
39644 }
39645 }
39646
39647 if (!ret) {
39648 #ifdef SWIGRUNTIME_DEBUG
39649 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
39650 #endif
39651 if (type->cast) {
39652 type->cast->prev = cast;
39653 cast->next = type->cast;
39654 }
39655 type->cast = cast;
39656 }
39657 cast++;
39658 }
39659 /* Set entry in modules->types array equal to the type */
39660 swig_module.types[i] = type;
39661 }
39662 swig_module.types[i] = 0;
39663
39664 #ifdef SWIGRUNTIME_DEBUG
39665 printf("**** SWIG_InitializeModule: Cast List ******\n");
39666 for (i = 0; i < swig_module.size; ++i) {
39667 int j = 0;
39668 swig_cast_info *cast = swig_module.cast_initial[i];
39669 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
39670 while (cast->type) {
39671 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
39672 cast++;
39673 ++j;
39674 }
39675 printf("---- Total casts: %d\n",j);
39676 }
39677 printf("**** SWIG_InitializeModule: Cast List ******\n");
39678 #endif
39679 }
39680
39681 /* This function will propagate the clientdata field of type to
39682 * any new swig_type_info structures that have been added into the list
39683 * of equivalent types. It is like calling
39684 * SWIG_TypeClientData(type, clientdata) a second time.
39685 */
39686 SWIGRUNTIME void
39687 SWIG_PropagateClientData(void) {
39688 size_t i;
39689 swig_cast_info *equiv;
39690 static int init_run = 0;
39691
39692 if (init_run) return;
39693 init_run = 1;
39694
39695 for (i = 0; i < swig_module.size; i++) {
39696 if (swig_module.types[i]->clientdata) {
39697 equiv = swig_module.types[i]->cast;
39698 while (equiv) {
39699 if (!equiv->converter) {
39700 if (equiv->type && !equiv->type->clientdata)
39701 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
39702 }
39703 equiv = equiv->next;
39704 }
39705 }
39706 }
39707 }
39708
39709 #ifdef __cplusplus
39710 #if 0
39711 {
39712 /* c-mode */
39713 #endif
39714 }
39715 #endif
39716
39717
39718
39719 #ifdef __cplusplus
39720 extern "C" {
39721 #endif
39722
39723 /* Python-specific SWIG API */
39724 #define SWIG_newvarlink() SWIG_Python_newvarlink()
39725 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
39726 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
39727
39728 /* -----------------------------------------------------------------------------
39729 * global variable support code.
39730 * ----------------------------------------------------------------------------- */
39731
39732 typedef struct swig_globalvar {
39733 char *name; /* Name of global variable */
39734 PyObject *(*get_attr)(void); /* Return the current value */
39735 int (*set_attr)(PyObject *); /* Set the value */
39736 struct swig_globalvar *next;
39737 } swig_globalvar;
39738
39739 typedef struct swig_varlinkobject {
39740 PyObject_HEAD
39741 swig_globalvar *vars;
39742 } swig_varlinkobject;
39743
39744 SWIGINTERN PyObject *
39745 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
39746 return PyString_FromString("<Swig global variables>");
39747 }
39748
39749 SWIGINTERN PyObject *
39750 swig_varlink_str(swig_varlinkobject *v) {
39751 PyObject *str = PyString_FromString("(");
39752 swig_globalvar *var;
39753 for (var = v->vars; var; var=var->next) {
39754 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
39755 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
39756 }
39757 PyString_ConcatAndDel(&str,PyString_FromString(")"));
39758 return str;
39759 }
39760
39761 SWIGINTERN int
39762 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
39763 PyObject *str = swig_varlink_str(v);
39764 fprintf(fp,"Swig global variables ");
39765 fprintf(fp,"%s\n", PyString_AsString(str));
39766 Py_DECREF(str);
39767 return 0;
39768 }
39769
39770 SWIGINTERN void
39771 swig_varlink_dealloc(swig_varlinkobject *v) {
39772 swig_globalvar *var = v->vars;
39773 while (var) {
39774 swig_globalvar *n = var->next;
39775 free(var->name);
39776 free(var);
39777 var = n;
39778 }
39779 }
39780
39781 SWIGINTERN PyObject *
39782 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
39783 PyObject *res = NULL;
39784 swig_globalvar *var = v->vars;
39785 while (var) {
39786 if (strcmp(var->name,n) == 0) {
39787 res = (*var->get_attr)();
39788 break;
39789 }
39790 var = var->next;
39791 }
39792 if (res == NULL && !PyErr_Occurred()) {
39793 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
39794 }
39795 return res;
39796 }
39797
39798 SWIGINTERN int
39799 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
39800 int res = 1;
39801 swig_globalvar *var = v->vars;
39802 while (var) {
39803 if (strcmp(var->name,n) == 0) {
39804 res = (*var->set_attr)(p);
39805 break;
39806 }
39807 var = var->next;
39808 }
39809 if (res == 1 && !PyErr_Occurred()) {
39810 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
39811 }
39812 return res;
39813 }
39814
39815 SWIGINTERN PyTypeObject*
39816 swig_varlink_type(void) {
39817 static char varlink__doc__[] = "Swig var link object";
39818 static PyTypeObject varlink_type;
39819 static int type_init = 0;
39820 if (!type_init) {
39821 const PyTypeObject tmp
39822 = {
39823 PyObject_HEAD_INIT(NULL)
39824 0, /* Number of items in variable part (ob_size) */
39825 (char *)"swigvarlink", /* Type name (tp_name) */
39826 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
39827 0, /* Itemsize (tp_itemsize) */
39828 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
39829 (printfunc) swig_varlink_print, /* Print (tp_print) */
39830 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
39831 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
39832 0, /* tp_compare */
39833 (reprfunc) swig_varlink_repr, /* tp_repr */
39834 0, /* tp_as_number */
39835 0, /* tp_as_sequence */
39836 0, /* tp_as_mapping */
39837 0, /* tp_hash */
39838 0, /* tp_call */
39839 (reprfunc)swig_varlink_str, /* tp_str */
39840 0, /* tp_getattro */
39841 0, /* tp_setattro */
39842 0, /* tp_as_buffer */
39843 0, /* tp_flags */
39844 varlink__doc__, /* tp_doc */
39845 0, /* tp_traverse */
39846 0, /* tp_clear */
39847 0, /* tp_richcompare */
39848 0, /* tp_weaklistoffset */
39849 #if PY_VERSION_HEX >= 0x02020000
39850 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
39851 #endif
39852 #if PY_VERSION_HEX >= 0x02030000
39853 0, /* tp_del */
39854 #endif
39855 #ifdef COUNT_ALLOCS
39856 0,0,0,0 /* tp_alloc -> tp_next */
39857 #endif
39858 };
39859 varlink_type = tmp;
39860 varlink_type.ob_type = &PyType_Type;
39861 type_init = 1;
39862 }
39863 return &varlink_type;
39864 }
39865
39866 /* Create a variable linking object for use later */
39867 SWIGINTERN PyObject *
39868 SWIG_Python_newvarlink(void) {
39869 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
39870 if (result) {
39871 result->vars = 0;
39872 }
39873 return ((PyObject*) result);
39874 }
39875
39876 SWIGINTERN void
39877 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
39878 swig_varlinkobject *v = (swig_varlinkobject *) p;
39879 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
39880 if (gv) {
39881 size_t size = strlen(name)+1;
39882 gv->name = (char *)malloc(size);
39883 if (gv->name) {
39884 strncpy(gv->name,name,size);
39885 gv->get_attr = get_attr;
39886 gv->set_attr = set_attr;
39887 gv->next = v->vars;
39888 }
39889 }
39890 v->vars = gv;
39891 }
39892
39893 SWIGINTERN PyObject *
39894 SWIG_globals() {
39895 static PyObject *_SWIG_globals = 0;
39896 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
39897 return _SWIG_globals;
39898 }
39899
39900 /* -----------------------------------------------------------------------------
39901 * constants/methods manipulation
39902 * ----------------------------------------------------------------------------- */
39903
39904 /* Install Constants */
39905 SWIGINTERN void
39906 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
39907 PyObject *obj = 0;
39908 size_t i;
39909 for (i = 0; constants[i].type; ++i) {
39910 switch(constants[i].type) {
39911 case SWIG_PY_POINTER:
39912 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
39913 break;
39914 case SWIG_PY_BINARY:
39915 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
39916 break;
39917 default:
39918 obj = 0;
39919 break;
39920 }
39921 if (obj) {
39922 PyDict_SetItemString(d, constants[i].name, obj);
39923 Py_DECREF(obj);
39924 }
39925 }
39926 }
39927
39928 /* -----------------------------------------------------------------------------*/
39929 /* Fix SwigMethods to carry the callback ptrs when needed */
39930 /* -----------------------------------------------------------------------------*/
39931
39932 SWIGINTERN void
39933 SWIG_Python_FixMethods(PyMethodDef *methods,
39934 swig_const_info *const_table,
39935 swig_type_info **types,
39936 swig_type_info **types_initial) {
39937 size_t i;
39938 for (i = 0; methods[i].ml_name; ++i) {
39939 const char *c = methods[i].ml_doc;
39940 if (c && (c = strstr(c, "swig_ptr: "))) {
39941 int j;
39942 swig_const_info *ci = 0;
39943 const char *name = c + 10;
39944 for (j = 0; const_table[j].type; ++j) {
39945 if (strncmp(const_table[j].name, name,
39946 strlen(const_table[j].name)) == 0) {
39947 ci = &(const_table[j]);
39948 break;
39949 }
39950 }
39951 if (ci) {
39952 size_t shift = (ci->ptype) - types;
39953 swig_type_info *ty = types_initial[shift];
39954 size_t ldoc = (c - methods[i].ml_doc);
39955 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
39956 char *ndoc = (char*)malloc(ldoc + lptr + 10);
39957 if (ndoc) {
39958 char *buff = ndoc;
39959 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
39960 if (ptr) {
39961 strncpy(buff, methods[i].ml_doc, ldoc);
39962 buff += ldoc;
39963 strncpy(buff, "swig_ptr: ", 10);
39964 buff += 10;
39965 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
39966 methods[i].ml_doc = ndoc;
39967 }
39968 }
39969 }
39970 }
39971 }
39972 }
39973
39974 #ifdef __cplusplus
39975 }
39976 #endif
39977
39978 /* -----------------------------------------------------------------------------*
39979 * Partial Init method
39980 * -----------------------------------------------------------------------------*/
39981
39982 #ifdef __cplusplus
39983 extern "C"
39984 #endif
39985 SWIGEXPORT void SWIG_init(void) {
39986 PyObject *m, *d;
39987
39988 /* Fix SwigMethods to carry the callback ptrs when needed */
39989 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
39990
39991 m = Py_InitModule((char *) SWIG_name, SwigMethods);
39992 d = PyModule_GetDict(m);
39993
39994 SWIG_InitializeModule(0);
39995 SWIG_InstallConstants(d,swig_const_table);
39996
39997
39998 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
39999 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
40000 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
40001 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
40002 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
40003 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
40004 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
40005 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
40006 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
40007 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
40008 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
40009 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
40010 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
40011 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
40012 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
40013 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
40014 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
40015 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
40016 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
40017 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
40018 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
40019 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
40020 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
40021 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
40022 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
40023 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
40024 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
40025 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
40026 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
40027 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
40028 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
40029 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
40030 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
40031 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
40032 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
40033 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
40034 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
40035 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
40036 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
40037 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
40038 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
40039 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
40040 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
40041 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
40042 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
40043 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
40044 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
40045 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
40046 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
40047 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
40048 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
40049 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
40050 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
40051 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
40052 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
40053 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
40054 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
40055 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
40056 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
40057 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
40058 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
40059 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
40060 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
40061 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
40062 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
40063 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
40064 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
40065 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
40066 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
40067 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
40068 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
40069 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
40070 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
40071 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
40072 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
40073 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
40074 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
40075 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
40076 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
40077 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
40078 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
40079 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
40080 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
40081 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
40082 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
40083 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
40084 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
40085 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
40086 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
40087 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
40088 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
40089 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
40090 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
40091 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
40092 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
40093 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
40094 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
40095 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
40096 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
40097 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
40098 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
40099 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
40100 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
40101 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
40102 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
40103 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
40104 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
40105 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
40106 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
40107 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
40108 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
40109 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
40110 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
40111 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
40112 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
40113 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
40114 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
40115 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
40116 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
40117 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
40118 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
40119 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
40120 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
40121 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
40122 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
40123 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
40124 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
40125 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
40126 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
40127 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
40128 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
40129 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
40130 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
40131 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
40132 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
40133 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
40134 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
40135 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
40136 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
40137 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
40138 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
40139 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
40140 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
40141 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
40142 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
40143 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
40144 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
40145 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
40146
40147 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
40148
40149 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
40150 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
40151 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
40152 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
40153 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
40154 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
40155 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
40156 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
40157 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
40158 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
40159 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
40160 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
40161 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
40162 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
40163 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
40164 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
40165 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
40166 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
40167 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
40168 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
40169 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
40170 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
40171 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
40172 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
40173 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
40174 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
40175 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
40176 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
40177 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
40178 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
40179 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
40180 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
40181 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
40182 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
40183 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
40184 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
40185 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
40186 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
40187 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
40188 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
40189 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
40190 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
40191 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
40192 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
40193 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
40194 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
40195 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
40196 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
40197 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
40198 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
40199 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
40200 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
40201 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
40202
40203 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
40204
40205 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
40206 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
40207 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
40208 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
40209 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
40210 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
40211 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
40212 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
40213 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
40214 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
40215 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
40216 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
40217 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
40218 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
40219 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
40220 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
40221 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
40222 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
40223 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
40224 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
40225 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
40226 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
40227 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
40228 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
40229 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
40230 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
40231 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
40232 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
40233 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
40234 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
40235 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
40236 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
40237 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
40238 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
40239 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
40240 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
40241 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
40242 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
40243 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
40244 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
40245 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
40246 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
40247 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
40248 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
40249 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
40250 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
40251 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
40252 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
40253 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
40254 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
40255 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
40256 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
40257 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
40258 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
40259 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
40260 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
40261 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
40262 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
40263 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
40264 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
40265 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
40266 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
40267 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
40268 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
40269 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
40270 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
40271 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
40272 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
40273 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
40274 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
40275 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
40276 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
40277 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
40278 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
40279 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
40280 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
40281
40282 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
40283
40284 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
40285 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
40286 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
40287 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
40288 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
40289 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
40290 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
40291 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
40292 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
40293 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
40294 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
40295 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
40296 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
40297 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
40298 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
40299 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
40300 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
40301 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
40302 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
40303 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
40304 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
40305 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
40306 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
40307 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
40308 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
40309 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
40310 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
40311 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
40312 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
40313 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
40314 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
40315 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
40316 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
40317 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
40318 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
40319 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
40320 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
40321 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
40322 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
40323 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
40324 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
40325 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
40326 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
40327 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
40328 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
40329 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
40330 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
40331 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
40332 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
40333 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
40334 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
40335 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
40336 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
40337 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
40338 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
40339 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
40340 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
40341 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
40342 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
40343 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
40344 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
40345 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
40346 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
40347 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
40348 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
40349 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
40350 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
40351 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
40352 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
40353 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
40354 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
40355 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
40356 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
40357 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
40358 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
40359 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
40360 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
40361 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
40362 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
40363 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
40364 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
40365 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
40366 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
40367 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
40368 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
40369 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
40370 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
40371 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
40372 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
40373 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
40374 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
40375 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
40376 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
40377 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
40378 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
40379 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
40380 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
40381 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
40382 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
40383 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
40384 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
40385 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
40386 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
40387 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
40388 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
40389 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
40390 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
40391 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
40392 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
40393 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
40394 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
40395 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
40396 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
40397 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
40398 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
40399 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
40400 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
40401 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
40402 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
40403 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
40404 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
40405 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
40406 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
40407 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
40408 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
40409 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
40410 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
40411 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
40412 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
40413 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
40414 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
40415 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
40416 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
40417 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
40418 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
40419 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
40420 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
40421 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
40422 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
40423 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
40424 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
40425 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
40426 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
40427 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
40428 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
40429 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
40430 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
40431 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
40432 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
40433 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
40434 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
40435 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
40436 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
40437 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
40438 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
40439 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
40440 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
40441 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
40442 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
40443 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
40444 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
40445 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
40446 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
40447 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
40448 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
40449 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
40450 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
40451 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
40452 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
40453 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
40454 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
40455 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
40456 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
40457 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
40458 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
40459 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
40460 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
40461 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
40462 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
40463 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
40464 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
40465 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
40466 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
40467 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
40468 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
40469 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
40470 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
40471 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
40472 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
40473 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
40474 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
40475 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
40476 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
40477 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
40478 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
40479 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
40480 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
40481 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
40482 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
40483 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
40484
40485 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
40486 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
40487 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
40488 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
40489
40490 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
40491 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
40492 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
40493 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
40494 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
40495 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
40496 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
40497 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
40498 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
40499 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
40500 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
40501 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
40502 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
40503 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
40504 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
40505 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
40506 }
40507
wxWidgets (Impactor)