]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_char swig_types[0]
2463 #define SWIGTYPE_p_form_ops_t swig_types[1]
2464 #define SWIGTYPE_p_int swig_types[2]
2465 #define SWIGTYPE_p_unsigned_char swig_types[3]
2466 #define SWIGTYPE_p_unsigned_int swig_types[4]
2467 #define SWIGTYPE_p_unsigned_long swig_types[5]
2468 #define SWIGTYPE_p_void swig_types[6]
2469 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2470 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2471 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2472 #define SWIGTYPE_p_wxArrayString swig_types[10]
2473 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2474 #define SWIGTYPE_p_wxBitmap swig_types[12]
2475 #define SWIGTYPE_p_wxBitmapDataObject swig_types[13]
2476 #define SWIGTYPE_p_wxBoxSizer swig_types[14]
2477 #define SWIGTYPE_p_wxBusyCursor swig_types[15]
2478 #define SWIGTYPE_p_wxBusyInfo swig_types[16]
2479 #define SWIGTYPE_p_wxCURHandler swig_types[17]
2480 #define SWIGTYPE_p_wxCaret swig_types[18]
2481 #define SWIGTYPE_p_wxChar swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxClipboard swig_types[21]
2484 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
2485 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[23]
2486 #define SWIGTYPE_p_wxCloseEvent swig_types[24]
2487 #define SWIGTYPE_p_wxColour swig_types[25]
2488 #define SWIGTYPE_p_wxCommandEvent swig_types[26]
2489 #define SWIGTYPE_p_wxConfig swig_types[27]
2490 #define SWIGTYPE_p_wxConfigBase swig_types[28]
2491 #define SWIGTYPE_p_wxConfigPathChanger swig_types[29]
2492 #define SWIGTYPE_p_wxContextMenuEvent swig_types[30]
2493 #define SWIGTYPE_p_wxControl swig_types[31]
2494 #define SWIGTYPE_p_wxControlWithItems swig_types[32]
2495 #define SWIGTYPE_p_wxCursor swig_types[33]
2496 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
2497 #define SWIGTYPE_p_wxDC swig_types[35]
2498 #define SWIGTYPE_p_wxDataFormat swig_types[36]
2499 #define SWIGTYPE_p_wxDataObject swig_types[37]
2500 #define SWIGTYPE_p_wxDataObjectComposite swig_types[38]
2501 #define SWIGTYPE_p_wxDataObjectSimple swig_types[39]
2502 #define SWIGTYPE_p_wxDateEvent swig_types[40]
2503 #define SWIGTYPE_p_wxDateSpan swig_types[41]
2504 #define SWIGTYPE_p_wxDateTime swig_types[42]
2505 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[43]
2506 #define SWIGTYPE_p_wxDisplay swig_types[44]
2507 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[45]
2508 #define SWIGTYPE_p_wxDropFilesEvent swig_types[46]
2509 #define SWIGTYPE_p_wxDuplexMode swig_types[47]
2510 #define SWIGTYPE_p_wxEraseEvent swig_types[48]
2511 #define SWIGTYPE_p_wxEvent swig_types[49]
2512 #define SWIGTYPE_p_wxEvtHandler swig_types[50]
2513 #define SWIGTYPE_p_wxFSFile swig_types[51]
2514 #define SWIGTYPE_p_wxFileConfig swig_types[52]
2515 #define SWIGTYPE_p_wxFileDataObject swig_types[53]
2516 #define SWIGTYPE_p_wxFileHistory swig_types[54]
2517 #define SWIGTYPE_p_wxFileSystem swig_types[55]
2518 #define SWIGTYPE_p_wxFileType swig_types[56]
2519 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
2520 #define SWIGTYPE_p_wxFlexGridSizer swig_types[58]
2521 #define SWIGTYPE_p_wxFocusEvent swig_types[59]
2522 #define SWIGTYPE_p_wxFont swig_types[60]
2523 #define SWIGTYPE_p_wxFrame swig_types[61]
2524 #define SWIGTYPE_p_wxGBSizerItem swig_types[62]
2525 #define SWIGTYPE_p_wxGIFHandler swig_types[63]
2526 #define SWIGTYPE_p_wxGridBagSizer swig_types[64]
2527 #define SWIGTYPE_p_wxGridSizer swig_types[65]
2528 #define SWIGTYPE_p_wxICOHandler swig_types[66]
2529 #define SWIGTYPE_p_wxIcon swig_types[67]
2530 #define SWIGTYPE_p_wxIconizeEvent swig_types[68]
2531 #define SWIGTYPE_p_wxIdleEvent swig_types[69]
2532 #define SWIGTYPE_p_wxImage swig_types[70]
2533 #define SWIGTYPE_p_wxImageHandler swig_types[71]
2534 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[72]
2535 #define SWIGTYPE_p_wxInitDialogEvent swig_types[73]
2536 #define SWIGTYPE_p_wxJPEGHandler swig_types[74]
2537 #define SWIGTYPE_p_wxJoystick swig_types[75]
2538 #define SWIGTYPE_p_wxJoystickEvent swig_types[76]
2539 #define SWIGTYPE_p_wxKeyEvent swig_types[77]
2540 #define SWIGTYPE_p_wxKillError swig_types[78]
2541 #define SWIGTYPE_p_wxLayoutConstraints swig_types[79]
2542 #define SWIGTYPE_p_wxLog swig_types[80]
2543 #define SWIGTYPE_p_wxLogBuffer swig_types[81]
2544 #define SWIGTYPE_p_wxLogChain swig_types[82]
2545 #define SWIGTYPE_p_wxLogGui swig_types[83]
2546 #define SWIGTYPE_p_wxLogNull swig_types[84]
2547 #define SWIGTYPE_p_wxLogStderr swig_types[85]
2548 #define SWIGTYPE_p_wxLogTextCtrl swig_types[86]
2549 #define SWIGTYPE_p_wxLogWindow swig_types[87]
2550 #define SWIGTYPE_p_wxMaximizeEvent swig_types[88]
2551 #define SWIGTYPE_p_wxMemorySize swig_types[89]
2552 #define SWIGTYPE_p_wxMenu swig_types[90]
2553 #define SWIGTYPE_p_wxMenuBar swig_types[91]
2554 #define SWIGTYPE_p_wxMenuEvent swig_types[92]
2555 #define SWIGTYPE_p_wxMenuItem swig_types[93]
2556 #define SWIGTYPE_p_wxMetafileDataObject swig_types[94]
2557 #define SWIGTYPE_p_wxMimeTypesManager swig_types[95]
2558 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[96]
2559 #define SWIGTYPE_p_wxMouseEvent swig_types[97]
2560 #define SWIGTYPE_p_wxMouseState swig_types[98]
2561 #define SWIGTYPE_p_wxMoveEvent swig_types[99]
2562 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[100]
2563 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
2564 #define SWIGTYPE_p_wxNcPaintEvent swig_types[102]
2565 #define SWIGTYPE_p_wxNotifyEvent swig_types[103]
2566 #define SWIGTYPE_p_wxObject swig_types[104]
2567 #define SWIGTYPE_p_wxOutputStream swig_types[105]
2568 #define SWIGTYPE_p_wxPCXHandler swig_types[106]
2569 #define SWIGTYPE_p_wxPNGHandler swig_types[107]
2570 #define SWIGTYPE_p_wxPNMHandler swig_types[108]
2571 #define SWIGTYPE_p_wxPaintEvent swig_types[109]
2572 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[110]
2573 #define SWIGTYPE_p_wxPaperSize swig_types[111]
2574 #define SWIGTYPE_p_wxPoint swig_types[112]
2575 #define SWIGTYPE_p_wxPowerEvent swig_types[113]
2576 #define SWIGTYPE_p_wxProcessEvent swig_types[114]
2577 #define SWIGTYPE_p_wxPyApp swig_types[115]
2578 #define SWIGTYPE_p_wxPyArtProvider swig_types[116]
2579 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[117]
2580 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
2581 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[119]
2582 #define SWIGTYPE_p_wxPyDropSource swig_types[120]
2583 #define SWIGTYPE_p_wxPyDropTarget swig_types[121]
2584 #define SWIGTYPE_p_wxPyEvent swig_types[122]
2585 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[123]
2586 #define SWIGTYPE_p_wxPyImageHandler swig_types[124]
2587 #define SWIGTYPE_p_wxPyLog swig_types[125]
2588 #define SWIGTYPE_p_wxPyProcess swig_types[126]
2589 #define SWIGTYPE_p_wxPySizer swig_types[127]
2590 #define SWIGTYPE_p_wxPyTextDataObject swig_types[128]
2591 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[129]
2592 #define SWIGTYPE_p_wxPyTimer swig_types[130]
2593 #define SWIGTYPE_p_wxPyTipProvider swig_types[131]
2594 #define SWIGTYPE_p_wxPyValidator swig_types[132]
2595 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[133]
2596 #define SWIGTYPE_p_wxRect swig_types[134]
2597 #define SWIGTYPE_p_wxScrollEvent swig_types[135]
2598 #define SWIGTYPE_p_wxScrollWinEvent swig_types[136]
2599 #define SWIGTYPE_p_wxSetCursorEvent swig_types[137]
2600 #define SWIGTYPE_p_wxShowEvent swig_types[138]
2601 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[139]
2602 #define SWIGTYPE_p_wxSize swig_types[140]
2603 #define SWIGTYPE_p_wxSizeEvent swig_types[141]
2604 #define SWIGTYPE_p_wxSizer swig_types[142]
2605 #define SWIGTYPE_p_wxSizerItem swig_types[143]
2606 #define SWIGTYPE_p_wxSound swig_types[144]
2607 #define SWIGTYPE_p_wxStandardPaths swig_types[145]
2608 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[146]
2609 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[147]
2610 #define SWIGTYPE_p_wxStopWatch swig_types[148]
2611 #define SWIGTYPE_p_wxString swig_types[149]
2612 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[150]
2613 #define SWIGTYPE_p_wxSystemOptions swig_types[151]
2614 #define SWIGTYPE_p_wxSystemSettings swig_types[152]
2615 #define SWIGTYPE_p_wxTIFFHandler swig_types[153]
2616 #define SWIGTYPE_p_wxTextCtrl swig_types[154]
2617 #define SWIGTYPE_p_wxTextDataObject swig_types[155]
2618 #define SWIGTYPE_p_wxTimeSpan swig_types[156]
2619 #define SWIGTYPE_p_wxTimer swig_types[157]
2620 #define SWIGTYPE_p_wxTimerEvent swig_types[158]
2621 #define SWIGTYPE_p_wxTimerRunner swig_types[159]
2622 #define SWIGTYPE_p_wxTipProvider swig_types[160]
2623 #define SWIGTYPE_p_wxToolTip swig_types[161]
2624 #define SWIGTYPE_p_wxURLDataObject swig_types[162]
2625 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[163]
2626 #define SWIGTYPE_p_wxValidator swig_types[164]
2627 #define SWIGTYPE_p_wxVideoMode swig_types[165]
2628 #define SWIGTYPE_p_wxWindow swig_types[166]
2629 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[167]
2630 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[168]
2631 #define SWIGTYPE_p_wxWindowDisabler swig_types[169]
2632 #define SWIGTYPE_p_wxXPMHandler swig_types[170]
2633 static swig_type_info *swig_types[172];
2634 static swig_module_info swig_module = {swig_types, 171, 0, 0, 0, 0};
2635 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2636 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2637
2638 /* -------- TYPES TABLE (END) -------- */
2639
2640 #if (PY_VERSION_HEX <= 0x02000000)
2641 # if !defined(SWIG_PYTHON_CLASSIC)
2642 # error "This python version requires to use swig with the '-classic' option"
2643 # endif
2644 #endif
2645 #if (PY_VERSION_HEX <= 0x02020000)
2646 # error "This python version requires to use swig with the '-nomodern' option"
2647 #endif
2648 #if (PY_VERSION_HEX <= 0x02020000)
2649 # error "This python version requires to use swig with the '-nomodernargs' option"
2650 #endif
2651 #ifndef METH_O
2652 # error "This python version requires to use swig with the '-nofastunpack' option"
2653 #endif
2654
2655 /*-----------------------------------------------
2656 @(target):= _misc_.so
2657 ------------------------------------------------*/
2658 #define SWIG_init init_misc_
2659
2660 #define SWIG_name "_misc_"
2661
2662 #define SWIGVERSION 0x010329
2663
2664
2665 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2666 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2667
2668
2669 #include <stdexcept>
2670
2671
2672 namespace swig {
2673 class PyObject_ptr {
2674 protected:
2675 PyObject *_obj;
2676
2677 public:
2678 PyObject_ptr() :_obj(0)
2679 {
2680 }
2681
2682 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2683 {
2684 Py_XINCREF(_obj);
2685 }
2686
2687 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2688 {
2689 if (initial_ref) Py_XINCREF(_obj);
2690 }
2691
2692 PyObject_ptr & operator=(const PyObject_ptr& item)
2693 {
2694 Py_XINCREF(item._obj);
2695 Py_XDECREF(_obj);
2696 _obj = item._obj;
2697 return *this;
2698 }
2699
2700 ~PyObject_ptr()
2701 {
2702 Py_XDECREF(_obj);
2703 }
2704
2705 operator PyObject *() const
2706 {
2707 return _obj;
2708 }
2709
2710 PyObject *operator->() const
2711 {
2712 return _obj;
2713 }
2714 };
2715 }
2716
2717
2718 namespace swig {
2719 struct PyObject_var : PyObject_ptr {
2720 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2721
2722 PyObject_var & operator = (PyObject* obj)
2723 {
2724 Py_XDECREF(_obj);
2725 _obj = obj;
2726 return *this;
2727 }
2728 };
2729 }
2730
2731
2732 #include "wx/wxPython/wxPython.h"
2733 #include "wx/wxPython/pyclasses.h"
2734 #include "wx/wxPython/pyistream.h"
2735
2736 static const wxString wxPyEmptyString(wxEmptyString);
2737
2738
2739
2740 #define SWIG_From_long PyInt_FromLong
2741
2742
2743 SWIGINTERNINLINE PyObject *
2744 SWIG_From_int (int value)
2745 {
2746 return SWIG_From_long (value);
2747 }
2748
2749
2750 #include <limits.h>
2751 #ifndef LLONG_MIN
2752 # define LLONG_MIN LONG_LONG_MIN
2753 #endif
2754 #ifndef LLONG_MAX
2755 # define LLONG_MAX LONG_LONG_MAX
2756 #endif
2757 #ifndef ULLONG_MAX
2758 # define ULLONG_MAX ULONG_LONG_MAX
2759 #endif
2760
2761
2762 SWIGINTERN int
2763 SWIG_AsVal_long (PyObject* obj, long* val)
2764 {
2765 if (PyNumber_Check(obj)) {
2766 if (val) *val = PyInt_AsLong(obj);
2767 return SWIG_OK;
2768 }
2769 return SWIG_TypeError;
2770 }
2771
2772
2773 SWIGINTERN int
2774 SWIG_AsVal_int (PyObject * obj, int *val)
2775 {
2776 long v;
2777 int res = SWIG_AsVal_long (obj, &v);
2778 if (SWIG_IsOK(res)) {
2779 if ((v < INT_MIN || v > INT_MAX)) {
2780 return SWIG_OverflowError;
2781 } else {
2782 if (val) *val = static_cast< int >(v);
2783 }
2784 }
2785 return res;
2786 }
2787
2788 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2789
2790 #include <wx/stockitem.h>
2791
2792 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2793 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2794 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2795
2796 SWIGINTERN int
2797 SWIG_AsVal_bool (PyObject *obj, bool *val)
2798 {
2799 if (obj == Py_True) {
2800 if (val) *val = true;
2801 return SWIG_OK;
2802 } else if (obj == Py_False) {
2803 if (val) *val = false;
2804 return SWIG_OK;
2805 } else {
2806 long v = 0;
2807 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2808 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2809 return res;
2810 }
2811 }
2812
2813
2814 wxMemorySize wxGetFreeMemory()
2815 { wxPyRaiseNotImplemented(); return 0; }
2816
2817
2818 SWIGINTERN int
2819 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2820 {
2821 long v = 0;
2822 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2823 return SWIG_TypeError;
2824 }
2825 else if (val)
2826 *val = (unsigned long)v;
2827 return SWIG_OK;
2828 }
2829
2830
2831 SWIGINTERNINLINE PyObject*
2832 SWIG_From_unsigned_SS_long (unsigned long value)
2833 {
2834 return (value > LONG_MAX) ?
2835 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2836 }
2837
2838
2839 void* wxGetXDisplay()
2840 {
2841 #ifdef __WXGTK__
2842 return wxGetDisplay();
2843 #else
2844 return NULL;
2845 #endif
2846 }
2847
2848
2849 wxWindow* FindWindowAtPointer() {
2850 wxPoint unused;
2851 return wxFindWindowAtPointer(unused);
2852 }
2853
2854
2855 void wxWakeUpMainThread() {}
2856
2857
2858 bool wxThread_IsMain() {
2859 #ifdef WXP_WITH_THREAD
2860 return wxThread::IsMain();
2861 #else
2862 return true;
2863 #endif
2864 }
2865
2866 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2867 delete self;
2868 }
2869
2870 #include <wx/snglinst.h>
2871
2872
2873 #ifdef __WXMSW__
2874 #include <wx/msw/private.h>
2875 #include <wx/dynload.h>
2876 #endif
2877
2878
2879
2880 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2881 #if 0
2882 , int method
2883 #endif
2884 )
2885 {
2886 #ifdef __WXMSW__
2887 #if 0
2888 switch (method)
2889 {
2890 case 1:
2891 // This one only partially works. Appears to be an undocumented
2892 // "standard" convention that not all widgets adhear to. For
2893 // example, for some widgets backgrounds or non-client areas may
2894 // not be painted.
2895 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2896 break;
2897
2898 case 2:
2899 #endif
2900 // This one works much better, nearly all widgets and their
2901 // children are captured correctly[**]. Prior to the big
2902 // background erase changes that Vadim did in 2004-2005 this
2903 // method failed badly on XP with Themes activated, most native
2904 // widgets draw only partially, if at all. Without themes it
2905 // worked just like on Win2k. After those changes this method
2906 // works very well.
2907 //
2908 // ** For example the radio buttons in a wxRadioBox are not its
2909 // children by default, but you can capture it via the panel
2910 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2911 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2912 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2913 PRF_ERASEBKGND | PRF_OWNED );
2914 return true;
2915 #if 0
2916 break;
2917
2918 case 3:
2919 // This one is only defined in the latest SDK and is only
2920 // available on XP. MSDN says it is similar to sending WM_PRINT
2921 // so I expect that it will work similar to the above. Since it
2922 // is avaialble only on XP, it can't be compiled like this and
2923 // will have to be loaded dynamically.
2924 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2925
2926 // fall through
2927
2928 case 4:
2929 // Use PrintWindow if available, or fallback to WM_PRINT
2930 // otherwise. Unfortunately using PrintWindow is even worse than
2931 // WM_PRINT. For most native widgets nothing is drawn to the dc
2932 // at all, with or without Themes.
2933 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2934 static bool s_triedToLoad = false;
2935 static PrintWindow_t pfnPrintWindow = NULL;
2936 if ( !s_triedToLoad )
2937 {
2938
2939 s_triedToLoad = true;
2940 wxDynamicLibrary dllUser32(_T("user32.dll"));
2941 if ( dllUser32.IsLoaded() )
2942 {
2943 wxLogNull nolog; // Don't report errors here
2944 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2945 }
2946 }
2947 if (pfnPrintWindow)
2948 {
2949 //printf("Using PrintWindow\n");
2950 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2951 }
2952 else
2953 {
2954 //printf("Using WM_PRINT\n");
2955 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2956 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2957 PRF_ERASEBKGND | PRF_OWNED );
2958 }
2959 }
2960 #endif // 0
2961 #else
2962 return false;
2963 #endif // __WXMSW__
2964 }
2965
2966
2967
2968 #include <wx/tipdlg.h>
2969
2970
2971 SWIGINTERNINLINE PyObject *
2972 SWIG_From_size_t (size_t value)
2973 {
2974 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2975 }
2976
2977
2978 class wxPyTipProvider : public wxTipProvider {
2979 public:
2980 wxPyTipProvider(size_t currentTip)
2981 : wxTipProvider(currentTip) {}
2982
2983 DEC_PYCALLBACK_STRING__pure(GetTip);
2984 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2985 PYPRIVATE;
2986 };
2987
2988 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2989 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2990
2991
2992 SWIGINTERNINLINE int
2993 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2994 {
2995 unsigned long v;
2996 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2997 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2998 return res;
2999 }
3000
3001
3002 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3003
3004 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3005
3006 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3007 : wxTimer(owner, id)
3008 {
3009 if (owner == NULL)
3010 SetOwner(this);
3011 }
3012
3013
3014 SWIGINTERN swig_type_info*
3015 SWIG_pchar_descriptor()
3016 {
3017 static int init = 0;
3018 static swig_type_info* info = 0;
3019 if (!init) {
3020 info = SWIG_TypeQuery("_p_char");
3021 init = 1;
3022 }
3023 return info;
3024 }
3025
3026
3027 SWIGINTERNINLINE PyObject *
3028 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3029 {
3030 if (carray) {
3031 if (size > INT_MAX) {
3032 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3033 return pchar_descriptor ?
3034 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3035 } else {
3036 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3037 }
3038 } else {
3039 return SWIG_Py_Void();
3040 }
3041 }
3042
3043
3044 SWIGINTERNINLINE PyObject *
3045 SWIG_FromCharPtr(const char *cptr)
3046 {
3047 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3048 }
3049
3050
3051 SWIGINTERN int
3052 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3053 {
3054 unsigned long v;
3055 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3056 if (SWIG_IsOK(res)) {
3057 if ((v > UINT_MAX)) {
3058 return SWIG_OverflowError;
3059 } else {
3060 if (val) *val = static_cast< unsigned int >(v);
3061 }
3062 }
3063 return res;
3064 }
3065
3066 SWIGINTERN wxString wxLog_TimeStamp(){
3067 wxString msg;
3068 wxLog::TimeStamp(&msg);
3069 return msg;
3070 }
3071 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3072 // Make some wrappers that double any % signs so they are 'escaped'
3073 void wxPyLogFatalError(const wxString& msg)
3074 {
3075 wxString m(msg);
3076 m.Replace(wxT("%"), wxT("%%"));
3077 wxLogFatalError(m);
3078 }
3079
3080 void wxPyLogError(const wxString& msg)
3081 {
3082 wxString m(msg);
3083 m.Replace(wxT("%"), wxT("%%"));
3084 wxLogError(m);
3085 }
3086
3087 void wxPyLogWarning(const wxString& msg)
3088 {
3089 wxString m(msg);
3090 m.Replace(wxT("%"), wxT("%%"));
3091 wxLogWarning(m);
3092 }
3093
3094 void wxPyLogMessage(const wxString& msg)
3095 {
3096 wxString m(msg);
3097 m.Replace(wxT("%"), wxT("%%"));
3098 wxLogMessage(m);
3099 }
3100
3101 void wxPyLogInfo(const wxString& msg)
3102 {
3103 wxString m(msg);
3104 m.Replace(wxT("%"), wxT("%%"));
3105 wxLogInfo(m);
3106 }
3107
3108 void wxPyLogDebug(const wxString& msg)
3109 {
3110 wxString m(msg);
3111 m.Replace(wxT("%"), wxT("%%"));
3112 wxLogDebug(m);
3113 }
3114
3115 void wxPyLogVerbose(const wxString& msg)
3116 {
3117 wxString m(msg);
3118 m.Replace(wxT("%"), wxT("%%"));
3119 wxLogVerbose(m);
3120 }
3121
3122 void wxPyLogStatus(const wxString& msg)
3123 {
3124 wxString m(msg);
3125 m.Replace(wxT("%"), wxT("%%"));
3126 wxLogStatus(m);
3127 }
3128
3129 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3130 {
3131 wxString m(msg);
3132 m.Replace(wxT("%"), wxT("%%"));
3133 wxLogStatus(pFrame, m);
3134 }
3135
3136 void wxPyLogSysError(const wxString& msg)
3137 {
3138 wxString m(msg);
3139 m.Replace(wxT("%"), wxT("%%"));
3140 wxLogSysError(m);
3141 }
3142
3143 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3144 {
3145 wxString m(msg);
3146 m.Replace(wxT("%"), wxT("%%"));
3147 wxLogGeneric(level, m);
3148 }
3149
3150 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3151 {
3152 wxString m(msg);
3153 m.Replace(wxT("%"), wxT("%%"));
3154 wxLogTrace(mask, m);
3155 }
3156
3157 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3158 {
3159 wxString m(msg);
3160 m.Replace(wxT("%"), wxT("%%"));
3161 wxLogTrace(mask, m);
3162 }
3163
3164
3165
3166 // A wxLog class that can be derived from in wxPython
3167 class wxPyLog : public wxLog {
3168 public:
3169 wxPyLog() : wxLog() {}
3170
3171 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3172 bool found;
3173 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3174 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3175 PyObject* s = wx2PyString(szString);
3176 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3177 Py_DECREF(s);
3178 }
3179 wxPyEndBlockThreads(blocked);
3180 if (! found)
3181 wxLog::DoLog(level, szString, t);
3182 }
3183
3184 virtual void DoLogString(const wxChar *szString, time_t t) {
3185 bool found;
3186 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3187 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3188 PyObject* s = wx2PyString(szString);
3189 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3190 Py_DECREF(s);
3191 }
3192 wxPyEndBlockThreads(blocked);
3193 if (! found)
3194 wxLog::DoLogString(szString, t);
3195 }
3196
3197 DEC_PYCALLBACK_VOID_(Flush);
3198 PYPRIVATE;
3199 };
3200 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3201
3202
3203
3204
3205 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3206
3207
3208 #include <wx/joystick.h>
3209
3210
3211 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3212 // A C++ stub class for wxJoystick for platforms that don't have it.
3213 class wxJoystick : public wxObject {
3214 public:
3215 wxJoystick(int joystick = wxJOYSTICK1) {
3216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3217 PyErr_SetString(PyExc_NotImplementedError,
3218 "wxJoystick is not available on this platform.");
3219 wxPyEndBlockThreads(blocked);
3220 }
3221 wxPoint GetPosition() { return wxPoint(-1,-1); }
3222 int GetZPosition() { return -1; }
3223 int GetButtonState() { return -1; }
3224 int GetPOVPosition() { return -1; }
3225 int GetPOVCTSPosition() { return -1; }
3226 int GetRudderPosition() { return -1; }
3227 int GetUPosition() { return -1; }
3228 int GetVPosition() { return -1; }
3229 int GetMovementThreshold() { return -1; }
3230 void SetMovementThreshold(int threshold) {}
3231
3232 bool IsOk(void) { return false; }
3233 int GetNumberJoysticks() { return -1; }
3234 int GetManufacturerId() { return -1; }
3235 int GetProductId() { return -1; }
3236 wxString GetProductName() { return wxEmptyString; }
3237 int GetXMin() { return -1; }
3238 int GetYMin() { return -1; }
3239 int GetZMin() { return -1; }
3240 int GetXMax() { return -1; }
3241 int GetYMax() { return -1; }
3242 int GetZMax() { return -1; }
3243 int GetNumberButtons() { return -1; }
3244 int GetNumberAxes() { return -1; }
3245 int GetMaxButtons() { return -1; }
3246 int GetMaxAxes() { return -1; }
3247 int GetPollingMin() { return -1; }
3248 int GetPollingMax() { return -1; }
3249 int GetRudderMin() { return -1; }
3250 int GetRudderMax() { return -1; }
3251 int GetUMin() { return -1; }
3252 int GetUMax() { return -1; }
3253 int GetVMin() { return -1; }
3254 int GetVMax() { return -1; }
3255
3256 bool HasRudder() { return false; }
3257 bool HasZ() { return false; }
3258 bool HasU() { return false; }
3259 bool HasV() { return false; }
3260 bool HasPOV() { return false; }
3261 bool HasPOV4Dir() { return false; }
3262 bool HasPOVCTS() { return false; }
3263
3264 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3265 bool ReleaseCapture() { return false; }
3266 };
3267 #endif
3268
3269
3270 #include <wx/sound.h>
3271
3272
3273 #if !wxUSE_SOUND
3274 // A C++ stub class for wxWave for platforms that don't have it.
3275 class wxSound : public wxObject
3276 {
3277 public:
3278 wxSound() {
3279 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3280 PyErr_SetString(PyExc_NotImplementedError,
3281 "wxSound is not available on this platform.");
3282 wxPyEndBlockThreads(blocked);
3283 }
3284 wxSound(const wxString&/*, bool*/) {
3285 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3286 PyErr_SetString(PyExc_NotImplementedError,
3287 "wxSound is not available on this platform.");
3288 wxPyEndBlockThreads(blocked);
3289 }
3290 wxSound(int, const wxByte*) {
3291 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3292 PyErr_SetString(PyExc_NotImplementedError,
3293 "wxSound is not available on this platform.");
3294 wxPyEndBlockThreads(blocked);
3295 }
3296
3297 ~wxSound() {};
3298
3299 bool Create(const wxString&/*, bool*/) { return false; }
3300 bool Create(int, const wxByte*) { return false; };
3301 bool IsOk() { return false; };
3302 bool Play(unsigned) const { return false; }
3303 static bool Play(const wxString&, unsigned) { return false; }
3304 static void Stop() {}
3305 };
3306
3307 #endif
3308
3309 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3310 if (fileName.Length() == 0)
3311 return new wxSound;
3312 else
3313 return new wxSound(fileName);
3314 }
3315 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3316 unsigned char* buffer; int size;
3317 wxSound *sound = NULL;
3318
3319 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3320 if (!PyArg_Parse(data, "t#", &buffer, &size))
3321 goto done;
3322 sound = new wxSound(size, buffer);
3323 done:
3324 wxPyEndBlockThreads(blocked);
3325 return sound;
3326 }
3327 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3328 #ifndef __WXMAC__
3329 unsigned char* buffer;
3330 int size;
3331 bool rv = false;
3332
3333 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3334 if (!PyArg_Parse(data, "t#", &buffer, &size))
3335 goto done;
3336 rv = self->Create(size, buffer);
3337 done:
3338 wxPyEndBlockThreads(blocked);
3339 return rv;
3340 #else
3341 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3342 PyErr_SetString(PyExc_NotImplementedError,
3343 "Create from data is not available on this platform.");
3344 wxPyEndBlockThreads(blocked);
3345 return false;
3346 #endif
3347 }
3348
3349 #include <wx/mimetype.h>
3350
3351 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3352 wxString str;
3353 if (self->GetMimeType(&str))
3354 return wx2PyString(str);
3355 else
3356 RETURN_NONE();
3357 }
3358 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3359 wxArrayString arr;
3360 if (self->GetMimeTypes(arr))
3361 return wxArrayString2PyList_helper(arr);
3362 else
3363 RETURN_NONE();
3364 }
3365 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3366 wxArrayString arr;
3367 if (self->GetExtensions(arr))
3368 return wxArrayString2PyList_helper(arr);
3369 else
3370 RETURN_NONE();
3371 }
3372 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3373 wxIconLocation loc;
3374 if (self->GetIcon(&loc))
3375 return new wxIcon(loc);
3376 else
3377 return NULL;
3378 }
3379 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3380 wxIconLocation loc;
3381 if (self->GetIcon(&loc)) {
3382 wxString iconFile = loc.GetFileName();
3383 int iconIndex = -1;
3384
3385
3386
3387 // Make a tuple and put the values in it
3388 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3389 PyObject* tuple = PyTuple_New(3);
3390 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3391 wxT("wxIcon"), true));
3392 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3393 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3394 wxPyEndBlockThreads(blocked);
3395 return tuple;
3396 }
3397 else
3398 RETURN_NONE();
3399 }
3400 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3401 wxString str;
3402 if (self->GetDescription(&str))
3403 return wx2PyString(str);
3404 else
3405 RETURN_NONE();
3406 }
3407 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3408 wxString str;
3409 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3410 return wx2PyString(str);
3411 else
3412 RETURN_NONE();
3413 }
3414 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3415 wxString str;
3416 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3417 return wx2PyString(str);
3418 else
3419 RETURN_NONE();
3420 }
3421 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3422 wxArrayString verbs;
3423 wxArrayString commands;
3424 if (self->GetAllCommands(&verbs, &commands,
3425 wxFileType::MessageParameters(filename, mimetype))) {
3426 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3427 PyObject* tuple = PyTuple_New(2);
3428 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3429 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3430 wxPyEndBlockThreads(blocked);
3431 return tuple;
3432 }
3433 else
3434 RETURN_NONE();
3435 }
3436 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3437 return wxFileType::ExpandCommand(command,
3438 wxFileType::MessageParameters(filename, mimetype));
3439 }
3440 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3441 wxArrayString arr;
3442 self->EnumAllFileTypes(arr);
3443 return wxArrayString2PyList_helper(arr);
3444 }
3445
3446 #include <wx/artprov.h>
3447
3448 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3449 static const wxString wxPyART_MENU(wxART_MENU);
3450 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3451 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3452 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3453 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3454 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3455 static const wxString wxPyART_OTHER(wxART_OTHER);
3456 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3457 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3458 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3459 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3460 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3461 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3462 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3463 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3464 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3465 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3466 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3467 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3468 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3469 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3470 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3471 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3472 static const wxString wxPyART_PRINT(wxART_PRINT);
3473 static const wxString wxPyART_HELP(wxART_HELP);
3474 static const wxString wxPyART_TIP(wxART_TIP);
3475 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3476 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3477 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3478 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3479 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3480 static const wxString wxPyART_CDROM(wxART_CDROM);
3481 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3482 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3483 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3484 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3485 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3486 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3487 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3488 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3489 static const wxString wxPyART_ERROR(wxART_ERROR);
3490 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3491 static const wxString wxPyART_WARNING(wxART_WARNING);
3492 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3493 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3494 static const wxString wxPyART_COPY(wxART_COPY);
3495 static const wxString wxPyART_CUT(wxART_CUT);
3496 static const wxString wxPyART_PASTE(wxART_PASTE);
3497 static const wxString wxPyART_DELETE(wxART_DELETE);
3498 static const wxString wxPyART_NEW(wxART_NEW);
3499 static const wxString wxPyART_UNDO(wxART_UNDO);
3500 static const wxString wxPyART_REDO(wxART_REDO);
3501 static const wxString wxPyART_QUIT(wxART_QUIT);
3502 static const wxString wxPyART_FIND(wxART_FIND);
3503 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3504 // Python aware wxArtProvider
3505 class wxPyArtProvider : public wxArtProvider {
3506 public:
3507
3508 virtual wxBitmap CreateBitmap(const wxArtID& id,
3509 const wxArtClient& client,
3510 const wxSize& size) {
3511 wxBitmap rval = wxNullBitmap;
3512 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3513 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3514 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3515 PyObject* ro;
3516 wxBitmap* ptr;
3517 PyObject* s1, *s2;
3518 s1 = wx2PyString(id);
3519 s2 = wx2PyString(client);
3520 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3521 Py_DECREF(so);
3522 Py_DECREF(s1);
3523 Py_DECREF(s2);
3524 if (ro) {
3525 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3526 rval = *ptr;
3527 Py_DECREF(ro);
3528 }
3529 }
3530 wxPyEndBlockThreads(blocked);
3531 return rval;
3532 }
3533
3534 PYPRIVATE;
3535 };
3536
3537 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3538
3539
3540
3541 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3542 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3543 PyObject* ret = PyTuple_New(3);
3544 if (ret) {
3545 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3546 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3547 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3548 }
3549 wxPyEndBlockThreads(blocked);
3550 return ret;
3551 }
3552
3553 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3554 bool cont;
3555 long index = 0;
3556 wxString value;
3557
3558 cont = self->GetFirstGroup(value, index);
3559 return __EnumerationHelper(cont, value, index);
3560 }
3561 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3562 bool cont;
3563 wxString value;
3564
3565 cont = self->GetNextGroup(value, index);
3566 return __EnumerationHelper(cont, value, index);
3567 }
3568 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3569 bool cont;
3570 long index = 0;
3571 wxString value;
3572
3573 cont = self->GetFirstEntry(value, index);
3574 return __EnumerationHelper(cont, value, index);
3575 }
3576 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3577 bool cont;
3578 wxString value;
3579
3580 cont = self->GetNextEntry(value, index);
3581 return __EnumerationHelper(cont, value, index);
3582 }
3583 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3584 long rv;
3585 self->Read(key, &rv, defaultVal);
3586 return rv;
3587 }
3588
3589 SWIGINTERN int
3590 SWIG_AsVal_double (PyObject *obj, double* val)
3591 {
3592 if (PyNumber_Check(obj)) {
3593 if (val) *val = PyFloat_AsDouble(obj);
3594 return SWIG_OK;
3595 }
3596 return SWIG_TypeError;
3597 }
3598
3599 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3600 double rv;
3601 self->Read(key, &rv, defaultVal);
3602 return rv;
3603 }
3604
3605 #define SWIG_From_double PyFloat_FromDouble
3606
3607 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3608 bool rv;
3609 self->Read(key, &rv, defaultVal);
3610 return rv;
3611 }
3612
3613 #include <wx/datetime.h>
3614
3615 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3616 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3617
3618 #define LOCAL_TZ wxDateTime::Local
3619
3620 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3621 wxString am;
3622 wxString pm;
3623 wxDateTime::GetAmPmStrings(&am, &pm);
3624 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3625 PyObject* tup = PyTuple_New(2);
3626 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3627 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3628 wxPyEndBlockThreads(blocked);
3629 return tup;
3630 }
3631
3632 SWIGINTERNINLINE PyObject *
3633 SWIG_From_unsigned_SS_int (unsigned int value)
3634 {
3635 return SWIG_From_unsigned_SS_long (value);
3636 }
3637
3638 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3639 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3640 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3641 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3642 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3643 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3644 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3645 return (*self < *other);
3646 }
3647 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3648 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3649 return (*self <= *other);
3650 }
3651 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3652 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3653 return (*self > *other);
3654 }
3655 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3656 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3657 return (*self >= *other);
3658 }
3659 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3660 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3661 return (*self == *other);
3662 }
3663 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3664 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3665 return (*self != *other);
3666 }
3667 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3668 const wxChar* rv;
3669 const wxChar* _date = date;
3670 rv = self->ParseRfc822Date(_date);
3671 if (rv == NULL) return -1;
3672 return rv - _date;
3673 }
3674 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3675 const wxChar* rv;
3676 const wxChar* _date = date;
3677 rv = self->ParseFormat(_date, format, dateDef);
3678 if (rv == NULL) return -1;
3679 return rv - _date;
3680 }
3681 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3682 const wxChar* rv;
3683 const wxChar* _datetime = datetime;
3684 rv = self->ParseDateTime(_datetime);
3685 if (rv == NULL) return -1;
3686 return rv - _datetime;
3687 }
3688 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3689 const wxChar* rv;
3690 const wxChar* _date = date;
3691 rv = self->ParseDate(_date);
3692 if (rv == NULL) return -1;
3693 return rv - _date;
3694 }
3695 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3696 const wxChar* rv;
3697 const wxChar* _time = time;
3698 rv = self->ParseTime(_time);
3699 if (rv == NULL) return -1;
3700 return rv - _time;
3701 }
3702 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3703 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3704 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3705 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3706 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3707 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3708 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3709 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3710 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3711 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3712 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3713 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3714 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3715 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3716 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3717 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3718
3719 #include <wx/dataobj.h>
3720
3721 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3722 size_t count = self->GetFormatCount(dir);
3723 wxDataFormat* formats = new wxDataFormat[count];
3724 self->GetAllFormats(formats, dir);
3725
3726 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3727 PyObject* list = PyList_New(count);
3728 for (size_t i=0; i<count; i++) {
3729 wxDataFormat* format = new wxDataFormat(formats[i]);
3730 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3731 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3732 }
3733 wxPyEndBlockThreads(blocked);
3734 delete [] formats;
3735 return list;
3736 }
3737 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3738 PyObject* rval = NULL;
3739 size_t size = self->GetDataSize(format);
3740 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3741 if (size) {
3742 char* buf = new char[size];
3743 if (self->GetDataHere(format, buf))
3744 rval = PyString_FromStringAndSize(buf, size);
3745 delete [] buf;
3746 }
3747 if (! rval) {
3748 rval = Py_None;
3749 Py_INCREF(rval);
3750 }
3751 wxPyEndBlockThreads(blocked);
3752 return rval;
3753 }
3754 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3755 bool rval;
3756 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3757 if (PyString_Check(data)) {
3758 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3759 }
3760 else {
3761 // raise a TypeError if not a string
3762 PyErr_SetString(PyExc_TypeError, "String expected.");
3763 rval = false;
3764 }
3765 wxPyEndBlockThreads(blocked);
3766 return rval;
3767 }
3768 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3769 PyObject* rval = NULL;
3770 size_t size = self->GetDataSize();
3771 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3772 if (size) {
3773 char* buf = new char[size];
3774 if (self->GetDataHere(buf))
3775 rval = PyString_FromStringAndSize(buf, size);
3776 delete [] buf;
3777 }
3778 if (! rval) {
3779 rval = Py_None;
3780 Py_INCREF(rval);
3781 }
3782 wxPyEndBlockThreads(blocked);
3783 return rval;
3784 }
3785 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3786 bool rval;
3787 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3788 if (PyString_Check(data)) {
3789 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3790 }
3791 else {
3792 // raise a TypeError if not a string
3793 PyErr_SetString(PyExc_TypeError, "String expected.");
3794 rval = false;
3795 }
3796 wxPyEndBlockThreads(blocked);
3797 return rval;
3798 }
3799 // Create a new class for wxPython to use
3800 class wxPyDataObjectSimple : public wxDataObjectSimple {
3801 public:
3802 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3803 : wxDataObjectSimple(format) {}
3804
3805 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3806 bool GetDataHere(void *buf) const;
3807 bool SetData(size_t len, const void *buf) const;
3808 PYPRIVATE;
3809 };
3810
3811 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3812
3813 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3814 // We need to get the data for this object and write it to buf. I think
3815 // the best way to do this for wxPython is to have the Python method
3816 // return either a string or None and then act appropriately with the
3817 // C++ version.
3818
3819 bool rval = false;
3820 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3821 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3822 PyObject* ro;
3823 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3824 if (ro) {
3825 rval = (ro != Py_None && PyString_Check(ro));
3826 if (rval)
3827 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3828 Py_DECREF(ro);
3829 }
3830 }
3831 wxPyEndBlockThreads(blocked);
3832 return rval;
3833 }
3834
3835 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
3836 // For this one we simply need to make a string from buf and len
3837 // and send it to the Python method.
3838 bool rval = false;
3839 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3840 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3841 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3842 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3843 Py_DECREF(data);
3844 }
3845 wxPyEndBlockThreads(blocked);
3846 return rval;
3847 }
3848
3849 // Create a new class for wxPython to use
3850 class wxPyTextDataObject : public wxTextDataObject {
3851 public:
3852 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3853 : wxTextDataObject(text) {}
3854
3855 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3856 DEC_PYCALLBACK_STRING__const(GetText);
3857 DEC_PYCALLBACK__STRING(SetText);
3858 PYPRIVATE;
3859 };
3860
3861 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3862 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3863 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3864
3865
3866 // Create a new class for wxPython to use
3867 class wxPyBitmapDataObject : public wxBitmapDataObject {
3868 public:
3869 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3870 : wxBitmapDataObject(bitmap) {}
3871
3872 wxBitmap GetBitmap() const;
3873 void SetBitmap(const wxBitmap& bitmap);
3874 PYPRIVATE;
3875 };
3876
3877 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3878 wxBitmap* rval = &wxNullBitmap;
3879 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3880 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3881 PyObject* ro;
3882 wxBitmap* ptr;
3883 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3884 if (ro) {
3885 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3886 rval = ptr;
3887 Py_DECREF(ro);
3888 }
3889 }
3890 wxPyEndBlockThreads(blocked);
3891 return *rval;
3892 }
3893
3894 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3895 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3896 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3897 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3898 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3899 Py_DECREF(bo);
3900 }
3901 wxPyEndBlockThreads(blocked);
3902 }
3903
3904 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3905 return new wxCustomDataObject(wxDataFormat(formatName));
3906 }
3907 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3908 bool rval;
3909 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3910 if (PyString_Check(data)) {
3911 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3912 }
3913 else {
3914 // raise a TypeError if not a string
3915 PyErr_SetString(PyExc_TypeError, "String expected.");
3916 rval = false;
3917 }
3918 wxPyEndBlockThreads(blocked);
3919 return rval;
3920 }
3921 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3922 PyObject* obj;
3923 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3924 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3925 wxPyEndBlockThreads(blocked);
3926 return obj;
3927 }
3928
3929 class wxMetafileDataObject : public wxDataObjectSimple
3930 {
3931 public:
3932 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3933 };
3934
3935
3936 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3937
3938
3939 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3940 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3941 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3942 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3943 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3944
3945
3946 class wxPyTextDropTarget : public wxTextDropTarget {
3947 public:
3948 wxPyTextDropTarget() {}
3949
3950 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3951
3952 DEC_PYCALLBACK__(OnLeave);
3953 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3954 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3955 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3956 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3957
3958 PYPRIVATE;
3959 };
3960
3961 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3962 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3963 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3964 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3965 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3966 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3967
3968
3969
3970 class wxPyFileDropTarget : public wxFileDropTarget {
3971 public:
3972 wxPyFileDropTarget() {}
3973
3974 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3975
3976 DEC_PYCALLBACK__(OnLeave);
3977 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3978 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3979 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3980 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3981
3982 PYPRIVATE;
3983 };
3984
3985 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3986 const wxArrayString& filenames) {
3987 bool rval = false;
3988 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3989 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3990 PyObject* list = wxArrayString2PyList_helper(filenames);
3991 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3992 Py_DECREF(list);
3993 }
3994 wxPyEndBlockThreads(blocked);
3995 return rval;
3996 }
3997
3998
3999
4000 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4001 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4002 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4003 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4004 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4005
4006
4007
4008
4009 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4010
4011 #include <wx/display.h>
4012
4013 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4014 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4015
4016 #if !wxUSE_DISPLAY
4017 const wxVideoMode wxDefaultVideoMode;
4018 #endif
4019
4020 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4021 #if wxUSE_DISPLAY
4022 PyObject* pyList = NULL;
4023 wxArrayVideoModes arr = self->GetModes(mode);
4024 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4025 pyList = PyList_New(0);
4026 for (size_t i=0; i < arr.GetCount(); i++)
4027 {
4028 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4029 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4030 PyList_Append(pyList, pyObj);
4031 Py_DECREF(pyObj);
4032 }
4033 wxPyEndBlockThreads(blocked);
4034 return pyList;
4035 #else
4036 wxPyRaiseNotImplemented();
4037 return NULL;
4038 #endif
4039 }
4040 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4041 #if wxUSE_DISPLAY
4042 return self->GetCurrentMode();
4043 #else
4044 wxPyRaiseNotImplemented();
4045 return wxDefaultVideoMode;
4046 #endif
4047 }
4048 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4049 #if wxUSE_DISPLAY
4050 return self->ChangeMode(mode);
4051 #else
4052 wxPyRaiseNotImplemented();
4053 return false;
4054 #endif
4055 }
4056 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4057 #if wxUSE_DISPLAY
4058 self->ResetMode();
4059 #else
4060 wxPyRaiseNotImplemented();
4061 #endif
4062 }
4063
4064 #include <wx/stdpaths.h>
4065
4066 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4067 return (wxStandardPaths*) &wxStandardPaths::Get();
4068 }
4069
4070 #include <wx/power.h>
4071
4072
4073 #ifndef wxHAS_POWER_EVENTS
4074 // Dummy class and other definitions for platforms that don't have them
4075
4076 class wxPowerEvent : public wxEvent
4077 {
4078 public:
4079 wxPowerEvent(wxEventType evtType) : wxEvent(wxID_NONE, evtType) {}
4080 void Veto() {}
4081 bool IsVetoed() const { return false; }
4082
4083 virtual wxEvent *Clone() const { return new wxPowerEvent(*this); }
4084 };
4085
4086 enum {
4087 wxEVT_POWER_SUSPENDING,
4088 wxEVT_POWER_SUSPENDED,
4089 wxEVT_POWER_SUSPEND_CANCEL,
4090 wxEVT_POWER_RESUME,
4091 };
4092
4093 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4094 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4095
4096 #endif
4097
4098 #ifdef __cplusplus
4099 extern "C" {
4100 #endif
4101 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4102 PyObject *resultobj = 0;
4103 wxSystemColour arg1 ;
4104 wxColour result;
4105 int val1 ;
4106 int ecode1 = 0 ;
4107 PyObject * obj0 = 0 ;
4108 char * kwnames[] = {
4109 (char *) "index", NULL
4110 };
4111
4112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4113 ecode1 = SWIG_AsVal_int(obj0, &val1);
4114 if (!SWIG_IsOK(ecode1)) {
4115 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4116 }
4117 arg1 = static_cast< wxSystemColour >(val1);
4118 {
4119 if (!wxPyCheckForApp()) SWIG_fail;
4120 PyThreadState* __tstate = wxPyBeginAllowThreads();
4121 result = wxSystemSettings::GetColour(arg1);
4122 wxPyEndAllowThreads(__tstate);
4123 if (PyErr_Occurred()) SWIG_fail;
4124 }
4125 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4126 return resultobj;
4127 fail:
4128 return NULL;
4129 }
4130
4131
4132 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4133 PyObject *resultobj = 0;
4134 wxSystemFont arg1 ;
4135 wxFont result;
4136 int val1 ;
4137 int ecode1 = 0 ;
4138 PyObject * obj0 = 0 ;
4139 char * kwnames[] = {
4140 (char *) "index", NULL
4141 };
4142
4143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4144 ecode1 = SWIG_AsVal_int(obj0, &val1);
4145 if (!SWIG_IsOK(ecode1)) {
4146 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4147 }
4148 arg1 = static_cast< wxSystemFont >(val1);
4149 {
4150 if (!wxPyCheckForApp()) SWIG_fail;
4151 PyThreadState* __tstate = wxPyBeginAllowThreads();
4152 result = wxSystemSettings::GetFont(arg1);
4153 wxPyEndAllowThreads(__tstate);
4154 if (PyErr_Occurred()) SWIG_fail;
4155 }
4156 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4157 return resultobj;
4158 fail:
4159 return NULL;
4160 }
4161
4162
4163 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4164 PyObject *resultobj = 0;
4165 wxSystemMetric arg1 ;
4166 wxWindow *arg2 = (wxWindow *) NULL ;
4167 int result;
4168 int val1 ;
4169 int ecode1 = 0 ;
4170 void *argp2 = 0 ;
4171 int res2 = 0 ;
4172 PyObject * obj0 = 0 ;
4173 PyObject * obj1 = 0 ;
4174 char * kwnames[] = {
4175 (char *) "index",(char *) "win", NULL
4176 };
4177
4178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4179 ecode1 = SWIG_AsVal_int(obj0, &val1);
4180 if (!SWIG_IsOK(ecode1)) {
4181 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4182 }
4183 arg1 = static_cast< wxSystemMetric >(val1);
4184 if (obj1) {
4185 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4186 if (!SWIG_IsOK(res2)) {
4187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4188 }
4189 arg2 = reinterpret_cast< wxWindow * >(argp2);
4190 }
4191 {
4192 if (!wxPyCheckForApp()) SWIG_fail;
4193 PyThreadState* __tstate = wxPyBeginAllowThreads();
4194 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4195 wxPyEndAllowThreads(__tstate);
4196 if (PyErr_Occurred()) SWIG_fail;
4197 }
4198 resultobj = SWIG_From_int(static_cast< int >(result));
4199 return resultobj;
4200 fail:
4201 return NULL;
4202 }
4203
4204
4205 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4206 PyObject *resultobj = 0;
4207 wxSystemFeature arg1 ;
4208 bool result;
4209 int val1 ;
4210 int ecode1 = 0 ;
4211 PyObject * obj0 = 0 ;
4212 char * kwnames[] = {
4213 (char *) "index", NULL
4214 };
4215
4216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4217 ecode1 = SWIG_AsVal_int(obj0, &val1);
4218 if (!SWIG_IsOK(ecode1)) {
4219 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4220 }
4221 arg1 = static_cast< wxSystemFeature >(val1);
4222 {
4223 if (!wxPyCheckForApp()) SWIG_fail;
4224 PyThreadState* __tstate = wxPyBeginAllowThreads();
4225 result = (bool)wxSystemSettings::HasFeature(arg1);
4226 wxPyEndAllowThreads(__tstate);
4227 if (PyErr_Occurred()) SWIG_fail;
4228 }
4229 {
4230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4231 }
4232 return resultobj;
4233 fail:
4234 return NULL;
4235 }
4236
4237
4238 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4239 PyObject *resultobj = 0;
4240 wxSystemScreenType result;
4241
4242 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4243 {
4244 if (!wxPyCheckForApp()) SWIG_fail;
4245 PyThreadState* __tstate = wxPyBeginAllowThreads();
4246 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4247 wxPyEndAllowThreads(__tstate);
4248 if (PyErr_Occurred()) SWIG_fail;
4249 }
4250 resultobj = SWIG_From_int(static_cast< int >(result));
4251 return resultobj;
4252 fail:
4253 return NULL;
4254 }
4255
4256
4257 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4258 PyObject *resultobj = 0;
4259 wxSystemScreenType arg1 ;
4260 int val1 ;
4261 int ecode1 = 0 ;
4262 PyObject * obj0 = 0 ;
4263 char * kwnames[] = {
4264 (char *) "screen", NULL
4265 };
4266
4267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4268 ecode1 = SWIG_AsVal_int(obj0, &val1);
4269 if (!SWIG_IsOK(ecode1)) {
4270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4271 }
4272 arg1 = static_cast< wxSystemScreenType >(val1);
4273 {
4274 if (!wxPyCheckForApp()) SWIG_fail;
4275 PyThreadState* __tstate = wxPyBeginAllowThreads();
4276 wxSystemSettings::SetScreenType(arg1);
4277 wxPyEndAllowThreads(__tstate);
4278 if (PyErr_Occurred()) SWIG_fail;
4279 }
4280 resultobj = SWIG_Py_Void();
4281 return resultobj;
4282 fail:
4283 return NULL;
4284 }
4285
4286
4287 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4288 PyObject *obj;
4289 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4290 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4291 return SWIG_Py_Void();
4292 }
4293
4294 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4295 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4296 return 1;
4297 }
4298
4299
4300 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4301 PyObject *pyobj = 0;
4302
4303 {
4304 #if wxUSE_UNICODE
4305 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4306 #else
4307 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4308 #endif
4309 }
4310 return pyobj;
4311 }
4312
4313
4314 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4315 PyObject *resultobj = 0;
4316 wxSystemOptions *result = 0 ;
4317
4318 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4319 {
4320 PyThreadState* __tstate = wxPyBeginAllowThreads();
4321 result = (wxSystemOptions *)new wxSystemOptions();
4322 wxPyEndAllowThreads(__tstate);
4323 if (PyErr_Occurred()) SWIG_fail;
4324 }
4325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4326 return resultobj;
4327 fail:
4328 return NULL;
4329 }
4330
4331
4332 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4333 PyObject *resultobj = 0;
4334 wxString *arg1 = 0 ;
4335 wxString *arg2 = 0 ;
4336 bool temp1 = false ;
4337 bool temp2 = false ;
4338 PyObject * obj0 = 0 ;
4339 PyObject * obj1 = 0 ;
4340 char * kwnames[] = {
4341 (char *) "name",(char *) "value", NULL
4342 };
4343
4344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4345 {
4346 arg1 = wxString_in_helper(obj0);
4347 if (arg1 == NULL) SWIG_fail;
4348 temp1 = true;
4349 }
4350 {
4351 arg2 = wxString_in_helper(obj1);
4352 if (arg2 == NULL) SWIG_fail;
4353 temp2 = true;
4354 }
4355 {
4356 PyThreadState* __tstate = wxPyBeginAllowThreads();
4357 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4358 wxPyEndAllowThreads(__tstate);
4359 if (PyErr_Occurred()) SWIG_fail;
4360 }
4361 resultobj = SWIG_Py_Void();
4362 {
4363 if (temp1)
4364 delete arg1;
4365 }
4366 {
4367 if (temp2)
4368 delete arg2;
4369 }
4370 return resultobj;
4371 fail:
4372 {
4373 if (temp1)
4374 delete arg1;
4375 }
4376 {
4377 if (temp2)
4378 delete arg2;
4379 }
4380 return NULL;
4381 }
4382
4383
4384 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4385 PyObject *resultobj = 0;
4386 wxString *arg1 = 0 ;
4387 int arg2 ;
4388 bool temp1 = false ;
4389 int val2 ;
4390 int ecode2 = 0 ;
4391 PyObject * obj0 = 0 ;
4392 PyObject * obj1 = 0 ;
4393 char * kwnames[] = {
4394 (char *) "name",(char *) "value", NULL
4395 };
4396
4397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4398 {
4399 arg1 = wxString_in_helper(obj0);
4400 if (arg1 == NULL) SWIG_fail;
4401 temp1 = true;
4402 }
4403 ecode2 = SWIG_AsVal_int(obj1, &val2);
4404 if (!SWIG_IsOK(ecode2)) {
4405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4406 }
4407 arg2 = static_cast< int >(val2);
4408 {
4409 PyThreadState* __tstate = wxPyBeginAllowThreads();
4410 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4411 wxPyEndAllowThreads(__tstate);
4412 if (PyErr_Occurred()) SWIG_fail;
4413 }
4414 resultobj = SWIG_Py_Void();
4415 {
4416 if (temp1)
4417 delete arg1;
4418 }
4419 return resultobj;
4420 fail:
4421 {
4422 if (temp1)
4423 delete arg1;
4424 }
4425 return NULL;
4426 }
4427
4428
4429 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4430 PyObject *resultobj = 0;
4431 wxString *arg1 = 0 ;
4432 wxString result;
4433 bool temp1 = false ;
4434 PyObject * obj0 = 0 ;
4435 char * kwnames[] = {
4436 (char *) "name", NULL
4437 };
4438
4439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4440 {
4441 arg1 = wxString_in_helper(obj0);
4442 if (arg1 == NULL) SWIG_fail;
4443 temp1 = true;
4444 }
4445 {
4446 PyThreadState* __tstate = wxPyBeginAllowThreads();
4447 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4448 wxPyEndAllowThreads(__tstate);
4449 if (PyErr_Occurred()) SWIG_fail;
4450 }
4451 {
4452 #if wxUSE_UNICODE
4453 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4454 #else
4455 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4456 #endif
4457 }
4458 {
4459 if (temp1)
4460 delete arg1;
4461 }
4462 return resultobj;
4463 fail:
4464 {
4465 if (temp1)
4466 delete arg1;
4467 }
4468 return NULL;
4469 }
4470
4471
4472 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4473 PyObject *resultobj = 0;
4474 wxString *arg1 = 0 ;
4475 int result;
4476 bool temp1 = false ;
4477 PyObject * obj0 = 0 ;
4478 char * kwnames[] = {
4479 (char *) "name", NULL
4480 };
4481
4482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4483 {
4484 arg1 = wxString_in_helper(obj0);
4485 if (arg1 == NULL) SWIG_fail;
4486 temp1 = true;
4487 }
4488 {
4489 PyThreadState* __tstate = wxPyBeginAllowThreads();
4490 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4491 wxPyEndAllowThreads(__tstate);
4492 if (PyErr_Occurred()) SWIG_fail;
4493 }
4494 resultobj = SWIG_From_int(static_cast< int >(result));
4495 {
4496 if (temp1)
4497 delete arg1;
4498 }
4499 return resultobj;
4500 fail:
4501 {
4502 if (temp1)
4503 delete arg1;
4504 }
4505 return NULL;
4506 }
4507
4508
4509 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4510 PyObject *resultobj = 0;
4511 wxString *arg1 = 0 ;
4512 bool result;
4513 bool temp1 = false ;
4514 PyObject * obj0 = 0 ;
4515 char * kwnames[] = {
4516 (char *) "name", NULL
4517 };
4518
4519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4520 {
4521 arg1 = wxString_in_helper(obj0);
4522 if (arg1 == NULL) SWIG_fail;
4523 temp1 = true;
4524 }
4525 {
4526 PyThreadState* __tstate = wxPyBeginAllowThreads();
4527 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4528 wxPyEndAllowThreads(__tstate);
4529 if (PyErr_Occurred()) SWIG_fail;
4530 }
4531 {
4532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4533 }
4534 {
4535 if (temp1)
4536 delete arg1;
4537 }
4538 return resultobj;
4539 fail:
4540 {
4541 if (temp1)
4542 delete arg1;
4543 }
4544 return NULL;
4545 }
4546
4547
4548 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4549 PyObject *resultobj = 0;
4550 wxString *arg1 = 0 ;
4551 bool result;
4552 bool temp1 = false ;
4553 PyObject * obj0 = 0 ;
4554 char * kwnames[] = {
4555 (char *) "name", NULL
4556 };
4557
4558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4559 {
4560 arg1 = wxString_in_helper(obj0);
4561 if (arg1 == NULL) SWIG_fail;
4562 temp1 = true;
4563 }
4564 {
4565 PyThreadState* __tstate = wxPyBeginAllowThreads();
4566 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4567 wxPyEndAllowThreads(__tstate);
4568 if (PyErr_Occurred()) SWIG_fail;
4569 }
4570 {
4571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4572 }
4573 {
4574 if (temp1)
4575 delete arg1;
4576 }
4577 return resultobj;
4578 fail:
4579 {
4580 if (temp1)
4581 delete arg1;
4582 }
4583 return NULL;
4584 }
4585
4586
4587 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4588 PyObject *obj;
4589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4590 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4591 return SWIG_Py_Void();
4592 }
4593
4594 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4595 return SWIG_Python_InitShadowInstance(args);
4596 }
4597
4598 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4599 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4600 return 1;
4601 }
4602
4603
4604 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4605 PyObject *pyobj = 0;
4606
4607 {
4608 #if wxUSE_UNICODE
4609 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4610 #else
4611 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4612 #endif
4613 }
4614 return pyobj;
4615 }
4616
4617
4618 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4619 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4620 return 1;
4621 }
4622
4623
4624 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4625 PyObject *pyobj = 0;
4626
4627 {
4628 #if wxUSE_UNICODE
4629 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4630 #else
4631 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4632 #endif
4633 }
4634 return pyobj;
4635 }
4636
4637
4638 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4639 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4640 return 1;
4641 }
4642
4643
4644 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4645 PyObject *pyobj = 0;
4646
4647 {
4648 #if wxUSE_UNICODE
4649 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4650 #else
4651 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4652 #endif
4653 }
4654 return pyobj;
4655 }
4656
4657
4658 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4659 PyObject *resultobj = 0;
4660 long result;
4661
4662 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4663 {
4664 PyThreadState* __tstate = wxPyBeginAllowThreads();
4665 result = (long)wxNewId();
4666 wxPyEndAllowThreads(__tstate);
4667 if (PyErr_Occurred()) SWIG_fail;
4668 }
4669 resultobj = SWIG_From_long(static_cast< long >(result));
4670 return resultobj;
4671 fail:
4672 return NULL;
4673 }
4674
4675
4676 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4677 PyObject *resultobj = 0;
4678 long arg1 ;
4679 long val1 ;
4680 int ecode1 = 0 ;
4681 PyObject * obj0 = 0 ;
4682 char * kwnames[] = {
4683 (char *) "id", NULL
4684 };
4685
4686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4687 ecode1 = SWIG_AsVal_long(obj0, &val1);
4688 if (!SWIG_IsOK(ecode1)) {
4689 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4690 }
4691 arg1 = static_cast< long >(val1);
4692 {
4693 PyThreadState* __tstate = wxPyBeginAllowThreads();
4694 wxRegisterId(arg1);
4695 wxPyEndAllowThreads(__tstate);
4696 if (PyErr_Occurred()) SWIG_fail;
4697 }
4698 resultobj = SWIG_Py_Void();
4699 return resultobj;
4700 fail:
4701 return NULL;
4702 }
4703
4704
4705 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4706 PyObject *resultobj = 0;
4707 long result;
4708
4709 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4710 {
4711 PyThreadState* __tstate = wxPyBeginAllowThreads();
4712 result = (long)wxGetCurrentId();
4713 wxPyEndAllowThreads(__tstate);
4714 if (PyErr_Occurred()) SWIG_fail;
4715 }
4716 resultobj = SWIG_From_long(static_cast< long >(result));
4717 return resultobj;
4718 fail:
4719 return NULL;
4720 }
4721
4722
4723 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4724 PyObject *resultobj = 0;
4725 int arg1 ;
4726 bool result;
4727 int val1 ;
4728 int ecode1 = 0 ;
4729 PyObject * obj0 = 0 ;
4730 char * kwnames[] = {
4731 (char *) "id", NULL
4732 };
4733
4734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4735 ecode1 = SWIG_AsVal_int(obj0, &val1);
4736 if (!SWIG_IsOK(ecode1)) {
4737 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4738 }
4739 arg1 = static_cast< int >(val1);
4740 {
4741 PyThreadState* __tstate = wxPyBeginAllowThreads();
4742 result = (bool)wxIsStockID(arg1);
4743 wxPyEndAllowThreads(__tstate);
4744 if (PyErr_Occurred()) SWIG_fail;
4745 }
4746 {
4747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4748 }
4749 return resultobj;
4750 fail:
4751 return NULL;
4752 }
4753
4754
4755 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4756 PyObject *resultobj = 0;
4757 int arg1 ;
4758 wxString *arg2 = 0 ;
4759 bool result;
4760 int val1 ;
4761 int ecode1 = 0 ;
4762 bool temp2 = false ;
4763 PyObject * obj0 = 0 ;
4764 PyObject * obj1 = 0 ;
4765 char * kwnames[] = {
4766 (char *) "id",(char *) "label", NULL
4767 };
4768
4769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4770 ecode1 = SWIG_AsVal_int(obj0, &val1);
4771 if (!SWIG_IsOK(ecode1)) {
4772 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4773 }
4774 arg1 = static_cast< int >(val1);
4775 {
4776 arg2 = wxString_in_helper(obj1);
4777 if (arg2 == NULL) SWIG_fail;
4778 temp2 = true;
4779 }
4780 {
4781 PyThreadState* __tstate = wxPyBeginAllowThreads();
4782 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4783 wxPyEndAllowThreads(__tstate);
4784 if (PyErr_Occurred()) SWIG_fail;
4785 }
4786 {
4787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4788 }
4789 {
4790 if (temp2)
4791 delete arg2;
4792 }
4793 return resultobj;
4794 fail:
4795 {
4796 if (temp2)
4797 delete arg2;
4798 }
4799 return NULL;
4800 }
4801
4802
4803 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4804 PyObject *resultobj = 0;
4805 int arg1 ;
4806 bool arg2 = (bool) true ;
4807 wxString arg3 = (wxString) wxPyEmptyString ;
4808 wxString result;
4809 int val1 ;
4810 int ecode1 = 0 ;
4811 bool val2 ;
4812 int ecode2 = 0 ;
4813 PyObject * obj0 = 0 ;
4814 PyObject * obj1 = 0 ;
4815 PyObject * obj2 = 0 ;
4816 char * kwnames[] = {
4817 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4818 };
4819
4820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4821 ecode1 = SWIG_AsVal_int(obj0, &val1);
4822 if (!SWIG_IsOK(ecode1)) {
4823 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4824 }
4825 arg1 = static_cast< int >(val1);
4826 if (obj1) {
4827 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4828 if (!SWIG_IsOK(ecode2)) {
4829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4830 }
4831 arg2 = static_cast< bool >(val2);
4832 }
4833 if (obj2) {
4834 {
4835 wxString* sptr = wxString_in_helper(obj2);
4836 if (sptr == NULL) SWIG_fail;
4837 arg3 = *sptr;
4838 delete sptr;
4839 }
4840 }
4841 {
4842 PyThreadState* __tstate = wxPyBeginAllowThreads();
4843 result = wxGetStockLabel(arg1,arg2,arg3);
4844 wxPyEndAllowThreads(__tstate);
4845 if (PyErr_Occurred()) SWIG_fail;
4846 }
4847 {
4848 #if wxUSE_UNICODE
4849 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4850 #else
4851 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4852 #endif
4853 }
4854 return resultobj;
4855 fail:
4856 return NULL;
4857 }
4858
4859
4860 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4861 PyObject *resultobj = 0;
4862
4863 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4864 {
4865 if (!wxPyCheckForApp()) SWIG_fail;
4866 PyThreadState* __tstate = wxPyBeginAllowThreads();
4867 wxBell();
4868 wxPyEndAllowThreads(__tstate);
4869 if (PyErr_Occurred()) SWIG_fail;
4870 }
4871 resultobj = SWIG_Py_Void();
4872 return resultobj;
4873 fail:
4874 return NULL;
4875 }
4876
4877
4878 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4879 PyObject *resultobj = 0;
4880
4881 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4882 {
4883 if (!wxPyCheckForApp()) SWIG_fail;
4884 PyThreadState* __tstate = wxPyBeginAllowThreads();
4885 wxEndBusyCursor();
4886 wxPyEndAllowThreads(__tstate);
4887 if (PyErr_Occurred()) SWIG_fail;
4888 }
4889 resultobj = SWIG_Py_Void();
4890 return resultobj;
4891 fail:
4892 return NULL;
4893 }
4894
4895
4896 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4897 PyObject *resultobj = 0;
4898 bool arg1 = (bool) true ;
4899 long result;
4900 bool val1 ;
4901 int ecode1 = 0 ;
4902 PyObject * obj0 = 0 ;
4903 char * kwnames[] = {
4904 (char *) "resetTimer", NULL
4905 };
4906
4907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4908 if (obj0) {
4909 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4910 if (!SWIG_IsOK(ecode1)) {
4911 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4912 }
4913 arg1 = static_cast< bool >(val1);
4914 }
4915 {
4916 PyThreadState* __tstate = wxPyBeginAllowThreads();
4917 result = (long)wxGetElapsedTime(arg1);
4918 wxPyEndAllowThreads(__tstate);
4919 if (PyErr_Occurred()) SWIG_fail;
4920 }
4921 resultobj = SWIG_From_long(static_cast< long >(result));
4922 return resultobj;
4923 fail:
4924 return NULL;
4925 }
4926
4927
4928 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4929 PyObject *resultobj = 0;
4930 bool result;
4931
4932 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4933 {
4934 PyThreadState* __tstate = wxPyBeginAllowThreads();
4935 result = (bool)wxIsBusy();
4936 wxPyEndAllowThreads(__tstate);
4937 if (PyErr_Occurred()) SWIG_fail;
4938 }
4939 {
4940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4941 }
4942 return resultobj;
4943 fail:
4944 return NULL;
4945 }
4946
4947
4948 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4949 PyObject *resultobj = 0;
4950 wxString result;
4951
4952 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4953 {
4954 PyThreadState* __tstate = wxPyBeginAllowThreads();
4955 result = wxNow();
4956 wxPyEndAllowThreads(__tstate);
4957 if (PyErr_Occurred()) SWIG_fail;
4958 }
4959 {
4960 #if wxUSE_UNICODE
4961 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4962 #else
4963 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4964 #endif
4965 }
4966 return resultobj;
4967 fail:
4968 return NULL;
4969 }
4970
4971
4972 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4973 PyObject *resultobj = 0;
4974 wxString const &arg1_defvalue = wxPyEmptyString ;
4975 wxString *arg1 = (wxString *) &arg1_defvalue ;
4976 bool result;
4977 bool temp1 = false ;
4978 PyObject * obj0 = 0 ;
4979 char * kwnames[] = {
4980 (char *) "command", NULL
4981 };
4982
4983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4984 if (obj0) {
4985 {
4986 arg1 = wxString_in_helper(obj0);
4987 if (arg1 == NULL) SWIG_fail;
4988 temp1 = true;
4989 }
4990 }
4991 {
4992 PyThreadState* __tstate = wxPyBeginAllowThreads();
4993 result = (bool)wxShell((wxString const &)*arg1);
4994 wxPyEndAllowThreads(__tstate);
4995 if (PyErr_Occurred()) SWIG_fail;
4996 }
4997 {
4998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4999 }
5000 {
5001 if (temp1)
5002 delete arg1;
5003 }
5004 return resultobj;
5005 fail:
5006 {
5007 if (temp1)
5008 delete arg1;
5009 }
5010 return NULL;
5011 }
5012
5013
5014 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5015 PyObject *resultobj = 0;
5016
5017 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5018 {
5019 PyThreadState* __tstate = wxPyBeginAllowThreads();
5020 wxStartTimer();
5021 wxPyEndAllowThreads(__tstate);
5022 if (PyErr_Occurred()) SWIG_fail;
5023 }
5024 resultobj = SWIG_Py_Void();
5025 return resultobj;
5026 fail:
5027 return NULL;
5028 }
5029
5030
5031 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5032 PyObject *resultobj = 0;
5033 int *arg1 = (int *) 0 ;
5034 int *arg2 = (int *) 0 ;
5035 int result;
5036 int temp1 ;
5037 int res1 = SWIG_TMPOBJ ;
5038 int temp2 ;
5039 int res2 = SWIG_TMPOBJ ;
5040
5041 arg1 = &temp1;
5042 arg2 = &temp2;
5043 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5044 {
5045 PyThreadState* __tstate = wxPyBeginAllowThreads();
5046 result = (int)wxGetOsVersion(arg1,arg2);
5047 wxPyEndAllowThreads(__tstate);
5048 if (PyErr_Occurred()) SWIG_fail;
5049 }
5050 resultobj = SWIG_From_int(static_cast< int >(result));
5051 if (SWIG_IsTmpObj(res1)) {
5052 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5053 } else {
5054 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5055 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5056 }
5057 if (SWIG_IsTmpObj(res2)) {
5058 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5059 } else {
5060 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5061 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5062 }
5063 return resultobj;
5064 fail:
5065 return NULL;
5066 }
5067
5068
5069 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5070 PyObject *resultobj = 0;
5071 wxString result;
5072
5073 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5074 {
5075 PyThreadState* __tstate = wxPyBeginAllowThreads();
5076 result = wxGetOsDescription();
5077 wxPyEndAllowThreads(__tstate);
5078 if (PyErr_Occurred()) SWIG_fail;
5079 }
5080 {
5081 #if wxUSE_UNICODE
5082 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5083 #else
5084 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5085 #endif
5086 }
5087 return resultobj;
5088 fail:
5089 return NULL;
5090 }
5091
5092
5093 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5094 PyObject *resultobj = 0;
5095 wxMemorySize result;
5096
5097 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5098 {
5099 PyThreadState* __tstate = wxPyBeginAllowThreads();
5100 result = wxGetFreeMemory();
5101 wxPyEndAllowThreads(__tstate);
5102 if (PyErr_Occurred()) SWIG_fail;
5103 }
5104 resultobj = SWIG_NewPointerObj((new wxMemorySize(static_cast< const wxMemorySize& >(result))), SWIGTYPE_p_wxMemorySize, SWIG_POINTER_OWN | 0 );
5105 return resultobj;
5106 fail:
5107 return NULL;
5108 }
5109
5110
5111 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5112 PyObject *resultobj = 0;
5113 wxShutdownFlags arg1 ;
5114 bool result;
5115 int val1 ;
5116 int ecode1 = 0 ;
5117 PyObject * obj0 = 0 ;
5118 char * kwnames[] = {
5119 (char *) "wFlags", NULL
5120 };
5121
5122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5123 ecode1 = SWIG_AsVal_int(obj0, &val1);
5124 if (!SWIG_IsOK(ecode1)) {
5125 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5126 }
5127 arg1 = static_cast< wxShutdownFlags >(val1);
5128 {
5129 if (!wxPyCheckForApp()) SWIG_fail;
5130 PyThreadState* __tstate = wxPyBeginAllowThreads();
5131 result = (bool)wxShutdown(arg1);
5132 wxPyEndAllowThreads(__tstate);
5133 if (PyErr_Occurred()) SWIG_fail;
5134 }
5135 {
5136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5137 }
5138 return resultobj;
5139 fail:
5140 return NULL;
5141 }
5142
5143
5144 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5145 PyObject *resultobj = 0;
5146 int arg1 ;
5147 int val1 ;
5148 int ecode1 = 0 ;
5149 PyObject * obj0 = 0 ;
5150 char * kwnames[] = {
5151 (char *) "secs", NULL
5152 };
5153
5154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5155 ecode1 = SWIG_AsVal_int(obj0, &val1);
5156 if (!SWIG_IsOK(ecode1)) {
5157 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5158 }
5159 arg1 = static_cast< int >(val1);
5160 {
5161 PyThreadState* __tstate = wxPyBeginAllowThreads();
5162 wxSleep(arg1);
5163 wxPyEndAllowThreads(__tstate);
5164 if (PyErr_Occurred()) SWIG_fail;
5165 }
5166 resultobj = SWIG_Py_Void();
5167 return resultobj;
5168 fail:
5169 return NULL;
5170 }
5171
5172
5173 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5174 PyObject *resultobj = 0;
5175 unsigned long arg1 ;
5176 unsigned long val1 ;
5177 int ecode1 = 0 ;
5178 PyObject * obj0 = 0 ;
5179 char * kwnames[] = {
5180 (char *) "milliseconds", NULL
5181 };
5182
5183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5184 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5185 if (!SWIG_IsOK(ecode1)) {
5186 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5187 }
5188 arg1 = static_cast< unsigned long >(val1);
5189 {
5190 PyThreadState* __tstate = wxPyBeginAllowThreads();
5191 wxMilliSleep(arg1);
5192 wxPyEndAllowThreads(__tstate);
5193 if (PyErr_Occurred()) SWIG_fail;
5194 }
5195 resultobj = SWIG_Py_Void();
5196 return resultobj;
5197 fail:
5198 return NULL;
5199 }
5200
5201
5202 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5203 PyObject *resultobj = 0;
5204 unsigned long arg1 ;
5205 unsigned long val1 ;
5206 int ecode1 = 0 ;
5207 PyObject * obj0 = 0 ;
5208 char * kwnames[] = {
5209 (char *) "microseconds", NULL
5210 };
5211
5212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5213 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5214 if (!SWIG_IsOK(ecode1)) {
5215 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5216 }
5217 arg1 = static_cast< unsigned long >(val1);
5218 {
5219 PyThreadState* __tstate = wxPyBeginAllowThreads();
5220 wxMicroSleep(arg1);
5221 wxPyEndAllowThreads(__tstate);
5222 if (PyErr_Occurred()) SWIG_fail;
5223 }
5224 resultobj = SWIG_Py_Void();
5225 return resultobj;
5226 fail:
5227 return NULL;
5228 }
5229
5230
5231 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5232 PyObject *resultobj = 0;
5233 bool arg1 ;
5234 bool val1 ;
5235 int ecode1 = 0 ;
5236 PyObject * obj0 = 0 ;
5237 char * kwnames[] = {
5238 (char *) "enable", NULL
5239 };
5240
5241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5242 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5243 if (!SWIG_IsOK(ecode1)) {
5244 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5245 }
5246 arg1 = static_cast< bool >(val1);
5247 {
5248 PyThreadState* __tstate = wxPyBeginAllowThreads();
5249 wxEnableTopLevelWindows(arg1);
5250 wxPyEndAllowThreads(__tstate);
5251 if (PyErr_Occurred()) SWIG_fail;
5252 }
5253 resultobj = SWIG_Py_Void();
5254 return resultobj;
5255 fail:
5256 return NULL;
5257 }
5258
5259
5260 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5261 PyObject *resultobj = 0;
5262 wxString *arg1 = 0 ;
5263 wxString result;
5264 bool temp1 = false ;
5265 PyObject * obj0 = 0 ;
5266 char * kwnames[] = {
5267 (char *) "in", NULL
5268 };
5269
5270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5271 {
5272 arg1 = wxString_in_helper(obj0);
5273 if (arg1 == NULL) SWIG_fail;
5274 temp1 = true;
5275 }
5276 {
5277 PyThreadState* __tstate = wxPyBeginAllowThreads();
5278 result = wxStripMenuCodes((wxString const &)*arg1);
5279 wxPyEndAllowThreads(__tstate);
5280 if (PyErr_Occurred()) SWIG_fail;
5281 }
5282 {
5283 #if wxUSE_UNICODE
5284 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5285 #else
5286 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5287 #endif
5288 }
5289 {
5290 if (temp1)
5291 delete arg1;
5292 }
5293 return resultobj;
5294 fail:
5295 {
5296 if (temp1)
5297 delete arg1;
5298 }
5299 return NULL;
5300 }
5301
5302
5303 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5304 PyObject *resultobj = 0;
5305 wxString result;
5306
5307 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5308 {
5309 PyThreadState* __tstate = wxPyBeginAllowThreads();
5310 result = wxGetEmailAddress();
5311 wxPyEndAllowThreads(__tstate);
5312 if (PyErr_Occurred()) SWIG_fail;
5313 }
5314 {
5315 #if wxUSE_UNICODE
5316 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5317 #else
5318 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5319 #endif
5320 }
5321 return resultobj;
5322 fail:
5323 return NULL;
5324 }
5325
5326
5327 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5328 PyObject *resultobj = 0;
5329 wxString result;
5330
5331 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5332 {
5333 PyThreadState* __tstate = wxPyBeginAllowThreads();
5334 result = wxGetHostName();
5335 wxPyEndAllowThreads(__tstate);
5336 if (PyErr_Occurred()) SWIG_fail;
5337 }
5338 {
5339 #if wxUSE_UNICODE
5340 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5341 #else
5342 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5343 #endif
5344 }
5345 return resultobj;
5346 fail:
5347 return NULL;
5348 }
5349
5350
5351 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5352 PyObject *resultobj = 0;
5353 wxString result;
5354
5355 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5356 {
5357 PyThreadState* __tstate = wxPyBeginAllowThreads();
5358 result = wxGetFullHostName();
5359 wxPyEndAllowThreads(__tstate);
5360 if (PyErr_Occurred()) SWIG_fail;
5361 }
5362 {
5363 #if wxUSE_UNICODE
5364 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5365 #else
5366 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5367 #endif
5368 }
5369 return resultobj;
5370 fail:
5371 return NULL;
5372 }
5373
5374
5375 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5376 PyObject *resultobj = 0;
5377 wxString result;
5378
5379 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5380 {
5381 PyThreadState* __tstate = wxPyBeginAllowThreads();
5382 result = wxGetUserId();
5383 wxPyEndAllowThreads(__tstate);
5384 if (PyErr_Occurred()) SWIG_fail;
5385 }
5386 {
5387 #if wxUSE_UNICODE
5388 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5389 #else
5390 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5391 #endif
5392 }
5393 return resultobj;
5394 fail:
5395 return NULL;
5396 }
5397
5398
5399 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5400 PyObject *resultobj = 0;
5401 wxString result;
5402
5403 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5404 {
5405 PyThreadState* __tstate = wxPyBeginAllowThreads();
5406 result = wxGetUserName();
5407 wxPyEndAllowThreads(__tstate);
5408 if (PyErr_Occurred()) SWIG_fail;
5409 }
5410 {
5411 #if wxUSE_UNICODE
5412 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5413 #else
5414 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5415 #endif
5416 }
5417 return resultobj;
5418 fail:
5419 return NULL;
5420 }
5421
5422
5423 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5424 PyObject *resultobj = 0;
5425 wxString result;
5426
5427 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5428 {
5429 PyThreadState* __tstate = wxPyBeginAllowThreads();
5430 result = wxGetHomeDir();
5431 wxPyEndAllowThreads(__tstate);
5432 if (PyErr_Occurred()) SWIG_fail;
5433 }
5434 {
5435 #if wxUSE_UNICODE
5436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5437 #else
5438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5439 #endif
5440 }
5441 return resultobj;
5442 fail:
5443 return NULL;
5444 }
5445
5446
5447 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5448 PyObject *resultobj = 0;
5449 wxString const &arg1_defvalue = wxPyEmptyString ;
5450 wxString *arg1 = (wxString *) &arg1_defvalue ;
5451 wxString result;
5452 bool temp1 = false ;
5453 PyObject * obj0 = 0 ;
5454 char * kwnames[] = {
5455 (char *) "user", NULL
5456 };
5457
5458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5459 if (obj0) {
5460 {
5461 arg1 = wxString_in_helper(obj0);
5462 if (arg1 == NULL) SWIG_fail;
5463 temp1 = true;
5464 }
5465 }
5466 {
5467 PyThreadState* __tstate = wxPyBeginAllowThreads();
5468 result = wxGetUserHome((wxString const &)*arg1);
5469 wxPyEndAllowThreads(__tstate);
5470 if (PyErr_Occurred()) SWIG_fail;
5471 }
5472 {
5473 #if wxUSE_UNICODE
5474 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5475 #else
5476 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5477 #endif
5478 }
5479 {
5480 if (temp1)
5481 delete arg1;
5482 }
5483 return resultobj;
5484 fail:
5485 {
5486 if (temp1)
5487 delete arg1;
5488 }
5489 return NULL;
5490 }
5491
5492
5493 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5494 PyObject *resultobj = 0;
5495 unsigned long result;
5496
5497 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5498 {
5499 PyThreadState* __tstate = wxPyBeginAllowThreads();
5500 result = (unsigned long)wxGetProcessId();
5501 wxPyEndAllowThreads(__tstate);
5502 if (PyErr_Occurred()) SWIG_fail;
5503 }
5504 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5505 return resultobj;
5506 fail:
5507 return NULL;
5508 }
5509
5510
5511 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5512 PyObject *resultobj = 0;
5513
5514 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5515 {
5516 PyThreadState* __tstate = wxPyBeginAllowThreads();
5517 wxTrap();
5518 wxPyEndAllowThreads(__tstate);
5519 if (PyErr_Occurred()) SWIG_fail;
5520 }
5521 resultobj = SWIG_Py_Void();
5522 return resultobj;
5523 fail:
5524 return NULL;
5525 }
5526
5527
5528 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5529 PyObject *resultobj = 0;
5530 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5531 wxString *arg1 = (wxString *) &arg1_defvalue ;
5532 wxString const &arg2_defvalue = wxPyEmptyString ;
5533 wxString *arg2 = (wxString *) &arg2_defvalue ;
5534 wxString const &arg3_defvalue = wxPyEmptyString ;
5535 wxString *arg3 = (wxString *) &arg3_defvalue ;
5536 wxString const &arg4_defvalue = wxPyEmptyString ;
5537 wxString *arg4 = (wxString *) &arg4_defvalue ;
5538 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5539 wxString *arg5 = (wxString *) &arg5_defvalue ;
5540 int arg6 = (int) 0 ;
5541 wxWindow *arg7 = (wxWindow *) NULL ;
5542 int arg8 = (int) -1 ;
5543 int arg9 = (int) -1 ;
5544 wxString result;
5545 bool temp1 = false ;
5546 bool temp2 = false ;
5547 bool temp3 = false ;
5548 bool temp4 = false ;
5549 bool temp5 = false ;
5550 int val6 ;
5551 int ecode6 = 0 ;
5552 void *argp7 = 0 ;
5553 int res7 = 0 ;
5554 int val8 ;
5555 int ecode8 = 0 ;
5556 int val9 ;
5557 int ecode9 = 0 ;
5558 PyObject * obj0 = 0 ;
5559 PyObject * obj1 = 0 ;
5560 PyObject * obj2 = 0 ;
5561 PyObject * obj3 = 0 ;
5562 PyObject * obj4 = 0 ;
5563 PyObject * obj5 = 0 ;
5564 PyObject * obj6 = 0 ;
5565 PyObject * obj7 = 0 ;
5566 PyObject * obj8 = 0 ;
5567 char * kwnames[] = {
5568 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5569 };
5570
5571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5572 if (obj0) {
5573 {
5574 arg1 = wxString_in_helper(obj0);
5575 if (arg1 == NULL) SWIG_fail;
5576 temp1 = true;
5577 }
5578 }
5579 if (obj1) {
5580 {
5581 arg2 = wxString_in_helper(obj1);
5582 if (arg2 == NULL) SWIG_fail;
5583 temp2 = true;
5584 }
5585 }
5586 if (obj2) {
5587 {
5588 arg3 = wxString_in_helper(obj2);
5589 if (arg3 == NULL) SWIG_fail;
5590 temp3 = true;
5591 }
5592 }
5593 if (obj3) {
5594 {
5595 arg4 = wxString_in_helper(obj3);
5596 if (arg4 == NULL) SWIG_fail;
5597 temp4 = true;
5598 }
5599 }
5600 if (obj4) {
5601 {
5602 arg5 = wxString_in_helper(obj4);
5603 if (arg5 == NULL) SWIG_fail;
5604 temp5 = true;
5605 }
5606 }
5607 if (obj5) {
5608 ecode6 = SWIG_AsVal_int(obj5, &val6);
5609 if (!SWIG_IsOK(ecode6)) {
5610 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5611 }
5612 arg6 = static_cast< int >(val6);
5613 }
5614 if (obj6) {
5615 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5616 if (!SWIG_IsOK(res7)) {
5617 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5618 }
5619 arg7 = reinterpret_cast< wxWindow * >(argp7);
5620 }
5621 if (obj7) {
5622 ecode8 = SWIG_AsVal_int(obj7, &val8);
5623 if (!SWIG_IsOK(ecode8)) {
5624 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5625 }
5626 arg8 = static_cast< int >(val8);
5627 }
5628 if (obj8) {
5629 ecode9 = SWIG_AsVal_int(obj8, &val9);
5630 if (!SWIG_IsOK(ecode9)) {
5631 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5632 }
5633 arg9 = static_cast< int >(val9);
5634 }
5635 {
5636 if (!wxPyCheckForApp()) SWIG_fail;
5637 PyThreadState* __tstate = wxPyBeginAllowThreads();
5638 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5639 wxPyEndAllowThreads(__tstate);
5640 if (PyErr_Occurred()) SWIG_fail;
5641 }
5642 {
5643 #if wxUSE_UNICODE
5644 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5645 #else
5646 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5647 #endif
5648 }
5649 {
5650 if (temp1)
5651 delete arg1;
5652 }
5653 {
5654 if (temp2)
5655 delete arg2;
5656 }
5657 {
5658 if (temp3)
5659 delete arg3;
5660 }
5661 {
5662 if (temp4)
5663 delete arg4;
5664 }
5665 {
5666 if (temp5)
5667 delete arg5;
5668 }
5669 return resultobj;
5670 fail:
5671 {
5672 if (temp1)
5673 delete arg1;
5674 }
5675 {
5676 if (temp2)
5677 delete arg2;
5678 }
5679 {
5680 if (temp3)
5681 delete arg3;
5682 }
5683 {
5684 if (temp4)
5685 delete arg4;
5686 }
5687 {
5688 if (temp5)
5689 delete arg5;
5690 }
5691 return NULL;
5692 }
5693
5694
5695 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5696 PyObject *resultobj = 0;
5697 wxString *arg1 = 0 ;
5698 wxString *arg2 = 0 ;
5699 wxString const &arg3_defvalue = wxPyEmptyString ;
5700 wxString *arg3 = (wxString *) &arg3_defvalue ;
5701 wxWindow *arg4 = (wxWindow *) NULL ;
5702 wxString result;
5703 bool temp1 = false ;
5704 bool temp2 = false ;
5705 bool temp3 = false ;
5706 void *argp4 = 0 ;
5707 int res4 = 0 ;
5708 PyObject * obj0 = 0 ;
5709 PyObject * obj1 = 0 ;
5710 PyObject * obj2 = 0 ;
5711 PyObject * obj3 = 0 ;
5712 char * kwnames[] = {
5713 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5714 };
5715
5716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5717 {
5718 arg1 = wxString_in_helper(obj0);
5719 if (arg1 == NULL) SWIG_fail;
5720 temp1 = true;
5721 }
5722 {
5723 arg2 = wxString_in_helper(obj1);
5724 if (arg2 == NULL) SWIG_fail;
5725 temp2 = true;
5726 }
5727 if (obj2) {
5728 {
5729 arg3 = wxString_in_helper(obj2);
5730 if (arg3 == NULL) SWIG_fail;
5731 temp3 = true;
5732 }
5733 }
5734 if (obj3) {
5735 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5736 if (!SWIG_IsOK(res4)) {
5737 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5738 }
5739 arg4 = reinterpret_cast< wxWindow * >(argp4);
5740 }
5741 {
5742 if (!wxPyCheckForApp()) SWIG_fail;
5743 PyThreadState* __tstate = wxPyBeginAllowThreads();
5744 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5745 wxPyEndAllowThreads(__tstate);
5746 if (PyErr_Occurred()) SWIG_fail;
5747 }
5748 {
5749 #if wxUSE_UNICODE
5750 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5751 #else
5752 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5753 #endif
5754 }
5755 {
5756 if (temp1)
5757 delete arg1;
5758 }
5759 {
5760 if (temp2)
5761 delete arg2;
5762 }
5763 {
5764 if (temp3)
5765 delete arg3;
5766 }
5767 return resultobj;
5768 fail:
5769 {
5770 if (temp1)
5771 delete arg1;
5772 }
5773 {
5774 if (temp2)
5775 delete arg2;
5776 }
5777 {
5778 if (temp3)
5779 delete arg3;
5780 }
5781 return NULL;
5782 }
5783
5784
5785 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5786 PyObject *resultobj = 0;
5787 wxString *arg1 = 0 ;
5788 wxString *arg2 = 0 ;
5789 wxString const &arg3_defvalue = wxPyEmptyString ;
5790 wxString *arg3 = (wxString *) &arg3_defvalue ;
5791 wxWindow *arg4 = (wxWindow *) NULL ;
5792 wxString result;
5793 bool temp1 = false ;
5794 bool temp2 = false ;
5795 bool temp3 = false ;
5796 void *argp4 = 0 ;
5797 int res4 = 0 ;
5798 PyObject * obj0 = 0 ;
5799 PyObject * obj1 = 0 ;
5800 PyObject * obj2 = 0 ;
5801 PyObject * obj3 = 0 ;
5802 char * kwnames[] = {
5803 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5804 };
5805
5806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5807 {
5808 arg1 = wxString_in_helper(obj0);
5809 if (arg1 == NULL) SWIG_fail;
5810 temp1 = true;
5811 }
5812 {
5813 arg2 = wxString_in_helper(obj1);
5814 if (arg2 == NULL) SWIG_fail;
5815 temp2 = true;
5816 }
5817 if (obj2) {
5818 {
5819 arg3 = wxString_in_helper(obj2);
5820 if (arg3 == NULL) SWIG_fail;
5821 temp3 = true;
5822 }
5823 }
5824 if (obj3) {
5825 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5826 if (!SWIG_IsOK(res4)) {
5827 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5828 }
5829 arg4 = reinterpret_cast< wxWindow * >(argp4);
5830 }
5831 {
5832 if (!wxPyCheckForApp()) SWIG_fail;
5833 PyThreadState* __tstate = wxPyBeginAllowThreads();
5834 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5835 wxPyEndAllowThreads(__tstate);
5836 if (PyErr_Occurred()) SWIG_fail;
5837 }
5838 {
5839 #if wxUSE_UNICODE
5840 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5841 #else
5842 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5843 #endif
5844 }
5845 {
5846 if (temp1)
5847 delete arg1;
5848 }
5849 {
5850 if (temp2)
5851 delete arg2;
5852 }
5853 {
5854 if (temp3)
5855 delete arg3;
5856 }
5857 return resultobj;
5858 fail:
5859 {
5860 if (temp1)
5861 delete arg1;
5862 }
5863 {
5864 if (temp2)
5865 delete arg2;
5866 }
5867 {
5868 if (temp3)
5869 delete arg3;
5870 }
5871 return NULL;
5872 }
5873
5874
5875 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5876 PyObject *resultobj = 0;
5877 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5878 wxString *arg1 = (wxString *) &arg1_defvalue ;
5879 wxString const &arg2_defvalue = wxPyEmptyString ;
5880 wxString *arg2 = (wxString *) &arg2_defvalue ;
5881 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5882 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5883 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5884 wxWindow *arg5 = (wxWindow *) NULL ;
5885 wxString result;
5886 bool temp1 = false ;
5887 bool temp2 = false ;
5888 long val3 ;
5889 int ecode3 = 0 ;
5890 wxPoint temp4 ;
5891 void *argp5 = 0 ;
5892 int res5 = 0 ;
5893 PyObject * obj0 = 0 ;
5894 PyObject * obj1 = 0 ;
5895 PyObject * obj2 = 0 ;
5896 PyObject * obj3 = 0 ;
5897 PyObject * obj4 = 0 ;
5898 char * kwnames[] = {
5899 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5900 };
5901
5902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5903 if (obj0) {
5904 {
5905 arg1 = wxString_in_helper(obj0);
5906 if (arg1 == NULL) SWIG_fail;
5907 temp1 = true;
5908 }
5909 }
5910 if (obj1) {
5911 {
5912 arg2 = wxString_in_helper(obj1);
5913 if (arg2 == NULL) SWIG_fail;
5914 temp2 = true;
5915 }
5916 }
5917 if (obj2) {
5918 ecode3 = SWIG_AsVal_long(obj2, &val3);
5919 if (!SWIG_IsOK(ecode3)) {
5920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5921 }
5922 arg3 = static_cast< long >(val3);
5923 }
5924 if (obj3) {
5925 {
5926 arg4 = &temp4;
5927 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5928 }
5929 }
5930 if (obj4) {
5931 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5932 if (!SWIG_IsOK(res5)) {
5933 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5934 }
5935 arg5 = reinterpret_cast< wxWindow * >(argp5);
5936 }
5937 {
5938 if (!wxPyCheckForApp()) SWIG_fail;
5939 PyThreadState* __tstate = wxPyBeginAllowThreads();
5940 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5941 wxPyEndAllowThreads(__tstate);
5942 if (PyErr_Occurred()) SWIG_fail;
5943 }
5944 {
5945 #if wxUSE_UNICODE
5946 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5947 #else
5948 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5949 #endif
5950 }
5951 {
5952 if (temp1)
5953 delete arg1;
5954 }
5955 {
5956 if (temp2)
5957 delete arg2;
5958 }
5959 return resultobj;
5960 fail:
5961 {
5962 if (temp1)
5963 delete arg1;
5964 }
5965 {
5966 if (temp2)
5967 delete arg2;
5968 }
5969 return NULL;
5970 }
5971
5972
5973 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5974 PyObject *resultobj = 0;
5975 wxString *arg1 = 0 ;
5976 wxString const &arg2_defvalue = wxPyEmptyString ;
5977 wxString *arg2 = (wxString *) &arg2_defvalue ;
5978 wxString const &arg3_defvalue = wxPyEmptyString ;
5979 wxString *arg3 = (wxString *) &arg3_defvalue ;
5980 wxWindow *arg4 = (wxWindow *) NULL ;
5981 int arg5 = (int) -1 ;
5982 int arg6 = (int) -1 ;
5983 bool arg7 = (bool) true ;
5984 wxString result;
5985 bool temp1 = false ;
5986 bool temp2 = false ;
5987 bool temp3 = false ;
5988 void *argp4 = 0 ;
5989 int res4 = 0 ;
5990 int val5 ;
5991 int ecode5 = 0 ;
5992 int val6 ;
5993 int ecode6 = 0 ;
5994 bool val7 ;
5995 int ecode7 = 0 ;
5996 PyObject * obj0 = 0 ;
5997 PyObject * obj1 = 0 ;
5998 PyObject * obj2 = 0 ;
5999 PyObject * obj3 = 0 ;
6000 PyObject * obj4 = 0 ;
6001 PyObject * obj5 = 0 ;
6002 PyObject * obj6 = 0 ;
6003 char * kwnames[] = {
6004 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6005 };
6006
6007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6008 {
6009 arg1 = wxString_in_helper(obj0);
6010 if (arg1 == NULL) SWIG_fail;
6011 temp1 = true;
6012 }
6013 if (obj1) {
6014 {
6015 arg2 = wxString_in_helper(obj1);
6016 if (arg2 == NULL) SWIG_fail;
6017 temp2 = true;
6018 }
6019 }
6020 if (obj2) {
6021 {
6022 arg3 = wxString_in_helper(obj2);
6023 if (arg3 == NULL) SWIG_fail;
6024 temp3 = true;
6025 }
6026 }
6027 if (obj3) {
6028 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6029 if (!SWIG_IsOK(res4)) {
6030 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6031 }
6032 arg4 = reinterpret_cast< wxWindow * >(argp4);
6033 }
6034 if (obj4) {
6035 ecode5 = SWIG_AsVal_int(obj4, &val5);
6036 if (!SWIG_IsOK(ecode5)) {
6037 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6038 }
6039 arg5 = static_cast< int >(val5);
6040 }
6041 if (obj5) {
6042 ecode6 = SWIG_AsVal_int(obj5, &val6);
6043 if (!SWIG_IsOK(ecode6)) {
6044 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6045 }
6046 arg6 = static_cast< int >(val6);
6047 }
6048 if (obj6) {
6049 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6050 if (!SWIG_IsOK(ecode7)) {
6051 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6052 }
6053 arg7 = static_cast< bool >(val7);
6054 }
6055 {
6056 if (!wxPyCheckForApp()) SWIG_fail;
6057 PyThreadState* __tstate = wxPyBeginAllowThreads();
6058 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6059 wxPyEndAllowThreads(__tstate);
6060 if (PyErr_Occurred()) SWIG_fail;
6061 }
6062 {
6063 #if wxUSE_UNICODE
6064 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6065 #else
6066 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6067 #endif
6068 }
6069 {
6070 if (temp1)
6071 delete arg1;
6072 }
6073 {
6074 if (temp2)
6075 delete arg2;
6076 }
6077 {
6078 if (temp3)
6079 delete arg3;
6080 }
6081 return resultobj;
6082 fail:
6083 {
6084 if (temp1)
6085 delete arg1;
6086 }
6087 {
6088 if (temp2)
6089 delete arg2;
6090 }
6091 {
6092 if (temp3)
6093 delete arg3;
6094 }
6095 return NULL;
6096 }
6097
6098
6099 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6100 PyObject *resultobj = 0;
6101 wxString *arg1 = 0 ;
6102 wxString const &arg2_defvalue = wxPyEmptyString ;
6103 wxString *arg2 = (wxString *) &arg2_defvalue ;
6104 wxString const &arg3_defvalue = wxPyEmptyString ;
6105 wxString *arg3 = (wxString *) &arg3_defvalue ;
6106 wxWindow *arg4 = (wxWindow *) NULL ;
6107 wxString result;
6108 bool temp1 = false ;
6109 bool temp2 = false ;
6110 bool temp3 = false ;
6111 void *argp4 = 0 ;
6112 int res4 = 0 ;
6113 PyObject * obj0 = 0 ;
6114 PyObject * obj1 = 0 ;
6115 PyObject * obj2 = 0 ;
6116 PyObject * obj3 = 0 ;
6117 char * kwnames[] = {
6118 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6119 };
6120
6121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6122 {
6123 arg1 = wxString_in_helper(obj0);
6124 if (arg1 == NULL) SWIG_fail;
6125 temp1 = true;
6126 }
6127 if (obj1) {
6128 {
6129 arg2 = wxString_in_helper(obj1);
6130 if (arg2 == NULL) SWIG_fail;
6131 temp2 = true;
6132 }
6133 }
6134 if (obj2) {
6135 {
6136 arg3 = wxString_in_helper(obj2);
6137 if (arg3 == NULL) SWIG_fail;
6138 temp3 = true;
6139 }
6140 }
6141 if (obj3) {
6142 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6143 if (!SWIG_IsOK(res4)) {
6144 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6145 }
6146 arg4 = reinterpret_cast< wxWindow * >(argp4);
6147 }
6148 {
6149 if (!wxPyCheckForApp()) SWIG_fail;
6150 PyThreadState* __tstate = wxPyBeginAllowThreads();
6151 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6152 wxPyEndAllowThreads(__tstate);
6153 if (PyErr_Occurred()) SWIG_fail;
6154 }
6155 {
6156 #if wxUSE_UNICODE
6157 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6158 #else
6159 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6160 #endif
6161 }
6162 {
6163 if (temp1)
6164 delete arg1;
6165 }
6166 {
6167 if (temp2)
6168 delete arg2;
6169 }
6170 {
6171 if (temp3)
6172 delete arg3;
6173 }
6174 return resultobj;
6175 fail:
6176 {
6177 if (temp1)
6178 delete arg1;
6179 }
6180 {
6181 if (temp2)
6182 delete arg2;
6183 }
6184 {
6185 if (temp3)
6186 delete arg3;
6187 }
6188 return NULL;
6189 }
6190
6191
6192 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6193 PyObject *resultobj = 0;
6194 wxString *arg1 = 0 ;
6195 wxString *arg2 = 0 ;
6196 int arg3 ;
6197 wxString *arg4 = (wxString *) 0 ;
6198 wxWindow *arg5 = (wxWindow *) NULL ;
6199 int arg6 = (int) -1 ;
6200 int arg7 = (int) -1 ;
6201 bool arg8 = (bool) true ;
6202 int arg9 = (int) 150 ;
6203 int arg10 = (int) 200 ;
6204 wxString result;
6205 bool temp1 = false ;
6206 bool temp2 = false ;
6207 void *argp5 = 0 ;
6208 int res5 = 0 ;
6209 int val6 ;
6210 int ecode6 = 0 ;
6211 int val7 ;
6212 int ecode7 = 0 ;
6213 bool val8 ;
6214 int ecode8 = 0 ;
6215 int val9 ;
6216 int ecode9 = 0 ;
6217 int val10 ;
6218 int ecode10 = 0 ;
6219 PyObject * obj0 = 0 ;
6220 PyObject * obj1 = 0 ;
6221 PyObject * obj2 = 0 ;
6222 PyObject * obj3 = 0 ;
6223 PyObject * obj4 = 0 ;
6224 PyObject * obj5 = 0 ;
6225 PyObject * obj6 = 0 ;
6226 PyObject * obj7 = 0 ;
6227 PyObject * obj8 = 0 ;
6228 char * kwnames[] = {
6229 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6230 };
6231
6232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6233 {
6234 arg1 = wxString_in_helper(obj0);
6235 if (arg1 == NULL) SWIG_fail;
6236 temp1 = true;
6237 }
6238 {
6239 arg2 = wxString_in_helper(obj1);
6240 if (arg2 == NULL) SWIG_fail;
6241 temp2 = true;
6242 }
6243 {
6244 arg3 = PyList_Size(obj2);
6245 arg4 = wxString_LIST_helper(obj2);
6246 if (arg4 == NULL) SWIG_fail;
6247 }
6248 if (obj3) {
6249 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6250 if (!SWIG_IsOK(res5)) {
6251 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6252 }
6253 arg5 = reinterpret_cast< wxWindow * >(argp5);
6254 }
6255 if (obj4) {
6256 ecode6 = SWIG_AsVal_int(obj4, &val6);
6257 if (!SWIG_IsOK(ecode6)) {
6258 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6259 }
6260 arg6 = static_cast< int >(val6);
6261 }
6262 if (obj5) {
6263 ecode7 = SWIG_AsVal_int(obj5, &val7);
6264 if (!SWIG_IsOK(ecode7)) {
6265 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6266 }
6267 arg7 = static_cast< int >(val7);
6268 }
6269 if (obj6) {
6270 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6271 if (!SWIG_IsOK(ecode8)) {
6272 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6273 }
6274 arg8 = static_cast< bool >(val8);
6275 }
6276 if (obj7) {
6277 ecode9 = SWIG_AsVal_int(obj7, &val9);
6278 if (!SWIG_IsOK(ecode9)) {
6279 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6280 }
6281 arg9 = static_cast< int >(val9);
6282 }
6283 if (obj8) {
6284 ecode10 = SWIG_AsVal_int(obj8, &val10);
6285 if (!SWIG_IsOK(ecode10)) {
6286 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6287 }
6288 arg10 = static_cast< int >(val10);
6289 }
6290 {
6291 if (!wxPyCheckForApp()) SWIG_fail;
6292 PyThreadState* __tstate = wxPyBeginAllowThreads();
6293 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6294 wxPyEndAllowThreads(__tstate);
6295 if (PyErr_Occurred()) SWIG_fail;
6296 }
6297 {
6298 #if wxUSE_UNICODE
6299 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6300 #else
6301 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6302 #endif
6303 }
6304 {
6305 if (temp1)
6306 delete arg1;
6307 }
6308 {
6309 if (temp2)
6310 delete arg2;
6311 }
6312 {
6313 if (arg4) delete [] arg4;
6314 }
6315 return resultobj;
6316 fail:
6317 {
6318 if (temp1)
6319 delete arg1;
6320 }
6321 {
6322 if (temp2)
6323 delete arg2;
6324 }
6325 {
6326 if (arg4) delete [] arg4;
6327 }
6328 return NULL;
6329 }
6330
6331
6332 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6333 PyObject *resultobj = 0;
6334 wxString *arg1 = 0 ;
6335 wxString *arg2 = 0 ;
6336 int arg3 ;
6337 wxString *arg4 = (wxString *) 0 ;
6338 wxWindow *arg5 = (wxWindow *) NULL ;
6339 int arg6 = (int) -1 ;
6340 int arg7 = (int) -1 ;
6341 bool arg8 = (bool) true ;
6342 int arg9 = (int) 150 ;
6343 int arg10 = (int) 200 ;
6344 int result;
6345 bool temp1 = false ;
6346 bool temp2 = false ;
6347 void *argp5 = 0 ;
6348 int res5 = 0 ;
6349 int val6 ;
6350 int ecode6 = 0 ;
6351 int val7 ;
6352 int ecode7 = 0 ;
6353 bool val8 ;
6354 int ecode8 = 0 ;
6355 int val9 ;
6356 int ecode9 = 0 ;
6357 int val10 ;
6358 int ecode10 = 0 ;
6359 PyObject * obj0 = 0 ;
6360 PyObject * obj1 = 0 ;
6361 PyObject * obj2 = 0 ;
6362 PyObject * obj3 = 0 ;
6363 PyObject * obj4 = 0 ;
6364 PyObject * obj5 = 0 ;
6365 PyObject * obj6 = 0 ;
6366 PyObject * obj7 = 0 ;
6367 PyObject * obj8 = 0 ;
6368 char * kwnames[] = {
6369 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6370 };
6371
6372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6373 {
6374 arg1 = wxString_in_helper(obj0);
6375 if (arg1 == NULL) SWIG_fail;
6376 temp1 = true;
6377 }
6378 {
6379 arg2 = wxString_in_helper(obj1);
6380 if (arg2 == NULL) SWIG_fail;
6381 temp2 = true;
6382 }
6383 {
6384 arg3 = PyList_Size(obj2);
6385 arg4 = wxString_LIST_helper(obj2);
6386 if (arg4 == NULL) SWIG_fail;
6387 }
6388 if (obj3) {
6389 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6390 if (!SWIG_IsOK(res5)) {
6391 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6392 }
6393 arg5 = reinterpret_cast< wxWindow * >(argp5);
6394 }
6395 if (obj4) {
6396 ecode6 = SWIG_AsVal_int(obj4, &val6);
6397 if (!SWIG_IsOK(ecode6)) {
6398 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6399 }
6400 arg6 = static_cast< int >(val6);
6401 }
6402 if (obj5) {
6403 ecode7 = SWIG_AsVal_int(obj5, &val7);
6404 if (!SWIG_IsOK(ecode7)) {
6405 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6406 }
6407 arg7 = static_cast< int >(val7);
6408 }
6409 if (obj6) {
6410 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6411 if (!SWIG_IsOK(ecode8)) {
6412 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6413 }
6414 arg8 = static_cast< bool >(val8);
6415 }
6416 if (obj7) {
6417 ecode9 = SWIG_AsVal_int(obj7, &val9);
6418 if (!SWIG_IsOK(ecode9)) {
6419 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6420 }
6421 arg9 = static_cast< int >(val9);
6422 }
6423 if (obj8) {
6424 ecode10 = SWIG_AsVal_int(obj8, &val10);
6425 if (!SWIG_IsOK(ecode10)) {
6426 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6427 }
6428 arg10 = static_cast< int >(val10);
6429 }
6430 {
6431 if (!wxPyCheckForApp()) SWIG_fail;
6432 PyThreadState* __tstate = wxPyBeginAllowThreads();
6433 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6434 wxPyEndAllowThreads(__tstate);
6435 if (PyErr_Occurred()) SWIG_fail;
6436 }
6437 resultobj = SWIG_From_int(static_cast< int >(result));
6438 {
6439 if (temp1)
6440 delete arg1;
6441 }
6442 {
6443 if (temp2)
6444 delete arg2;
6445 }
6446 {
6447 if (arg4) delete [] arg4;
6448 }
6449 return resultobj;
6450 fail:
6451 {
6452 if (temp1)
6453 delete arg1;
6454 }
6455 {
6456 if (temp2)
6457 delete arg2;
6458 }
6459 {
6460 if (arg4) delete [] arg4;
6461 }
6462 return NULL;
6463 }
6464
6465
6466 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6467 PyObject *resultobj = 0;
6468 wxString *arg1 = 0 ;
6469 wxString const &arg2_defvalue = wxPyEmptyString ;
6470 wxString *arg2 = (wxString *) &arg2_defvalue ;
6471 int arg3 = (int) wxOK|wxCENTRE ;
6472 wxWindow *arg4 = (wxWindow *) NULL ;
6473 int arg5 = (int) -1 ;
6474 int arg6 = (int) -1 ;
6475 int result;
6476 bool temp1 = false ;
6477 bool temp2 = false ;
6478 int val3 ;
6479 int ecode3 = 0 ;
6480 void *argp4 = 0 ;
6481 int res4 = 0 ;
6482 int val5 ;
6483 int ecode5 = 0 ;
6484 int val6 ;
6485 int ecode6 = 0 ;
6486 PyObject * obj0 = 0 ;
6487 PyObject * obj1 = 0 ;
6488 PyObject * obj2 = 0 ;
6489 PyObject * obj3 = 0 ;
6490 PyObject * obj4 = 0 ;
6491 PyObject * obj5 = 0 ;
6492 char * kwnames[] = {
6493 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6494 };
6495
6496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6497 {
6498 arg1 = wxString_in_helper(obj0);
6499 if (arg1 == NULL) SWIG_fail;
6500 temp1 = true;
6501 }
6502 if (obj1) {
6503 {
6504 arg2 = wxString_in_helper(obj1);
6505 if (arg2 == NULL) SWIG_fail;
6506 temp2 = true;
6507 }
6508 }
6509 if (obj2) {
6510 ecode3 = SWIG_AsVal_int(obj2, &val3);
6511 if (!SWIG_IsOK(ecode3)) {
6512 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6513 }
6514 arg3 = static_cast< int >(val3);
6515 }
6516 if (obj3) {
6517 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6518 if (!SWIG_IsOK(res4)) {
6519 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6520 }
6521 arg4 = reinterpret_cast< wxWindow * >(argp4);
6522 }
6523 if (obj4) {
6524 ecode5 = SWIG_AsVal_int(obj4, &val5);
6525 if (!SWIG_IsOK(ecode5)) {
6526 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6527 }
6528 arg5 = static_cast< int >(val5);
6529 }
6530 if (obj5) {
6531 ecode6 = SWIG_AsVal_int(obj5, &val6);
6532 if (!SWIG_IsOK(ecode6)) {
6533 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6534 }
6535 arg6 = static_cast< int >(val6);
6536 }
6537 {
6538 if (!wxPyCheckForApp()) SWIG_fail;
6539 PyThreadState* __tstate = wxPyBeginAllowThreads();
6540 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6541 wxPyEndAllowThreads(__tstate);
6542 if (PyErr_Occurred()) SWIG_fail;
6543 }
6544 resultobj = SWIG_From_int(static_cast< int >(result));
6545 {
6546 if (temp1)
6547 delete arg1;
6548 }
6549 {
6550 if (temp2)
6551 delete arg2;
6552 }
6553 return resultobj;
6554 fail:
6555 {
6556 if (temp1)
6557 delete arg1;
6558 }
6559 {
6560 if (temp2)
6561 delete arg2;
6562 }
6563 return NULL;
6564 }
6565
6566
6567 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6568 PyObject *resultobj = 0;
6569 bool result;
6570
6571 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6572 {
6573 if (!wxPyCheckForApp()) SWIG_fail;
6574 PyThreadState* __tstate = wxPyBeginAllowThreads();
6575 result = (bool)wxColourDisplay();
6576 wxPyEndAllowThreads(__tstate);
6577 if (PyErr_Occurred()) SWIG_fail;
6578 }
6579 {
6580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6581 }
6582 return resultobj;
6583 fail:
6584 return NULL;
6585 }
6586
6587
6588 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6589 PyObject *resultobj = 0;
6590 int result;
6591
6592 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6593 {
6594 if (!wxPyCheckForApp()) SWIG_fail;
6595 PyThreadState* __tstate = wxPyBeginAllowThreads();
6596 result = (int)wxDisplayDepth();
6597 wxPyEndAllowThreads(__tstate);
6598 if (PyErr_Occurred()) SWIG_fail;
6599 }
6600 resultobj = SWIG_From_int(static_cast< int >(result));
6601 return resultobj;
6602 fail:
6603 return NULL;
6604 }
6605
6606
6607 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6608 PyObject *resultobj = 0;
6609 int result;
6610
6611 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6612 {
6613 if (!wxPyCheckForApp()) SWIG_fail;
6614 PyThreadState* __tstate = wxPyBeginAllowThreads();
6615 result = (int)wxGetDisplayDepth();
6616 wxPyEndAllowThreads(__tstate);
6617 if (PyErr_Occurred()) SWIG_fail;
6618 }
6619 resultobj = SWIG_From_int(static_cast< int >(result));
6620 return resultobj;
6621 fail:
6622 return NULL;
6623 }
6624
6625
6626 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6627 PyObject *resultobj = 0;
6628 int *arg1 = (int *) 0 ;
6629 int *arg2 = (int *) 0 ;
6630 int temp1 ;
6631 int res1 = SWIG_TMPOBJ ;
6632 int temp2 ;
6633 int res2 = SWIG_TMPOBJ ;
6634
6635 arg1 = &temp1;
6636 arg2 = &temp2;
6637 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6638 {
6639 if (!wxPyCheckForApp()) SWIG_fail;
6640 PyThreadState* __tstate = wxPyBeginAllowThreads();
6641 wxDisplaySize(arg1,arg2);
6642 wxPyEndAllowThreads(__tstate);
6643 if (PyErr_Occurred()) SWIG_fail;
6644 }
6645 resultobj = SWIG_Py_Void();
6646 if (SWIG_IsTmpObj(res1)) {
6647 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6648 } else {
6649 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6650 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6651 }
6652 if (SWIG_IsTmpObj(res2)) {
6653 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6654 } else {
6655 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6656 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6657 }
6658 return resultobj;
6659 fail:
6660 return NULL;
6661 }
6662
6663
6664 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6665 PyObject *resultobj = 0;
6666 wxSize result;
6667
6668 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6669 {
6670 if (!wxPyCheckForApp()) SWIG_fail;
6671 PyThreadState* __tstate = wxPyBeginAllowThreads();
6672 result = wxGetDisplaySize();
6673 wxPyEndAllowThreads(__tstate);
6674 if (PyErr_Occurred()) SWIG_fail;
6675 }
6676 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6677 return resultobj;
6678 fail:
6679 return NULL;
6680 }
6681
6682
6683 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6684 PyObject *resultobj = 0;
6685 int *arg1 = (int *) 0 ;
6686 int *arg2 = (int *) 0 ;
6687 int temp1 ;
6688 int res1 = SWIG_TMPOBJ ;
6689 int temp2 ;
6690 int res2 = SWIG_TMPOBJ ;
6691
6692 arg1 = &temp1;
6693 arg2 = &temp2;
6694 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6695 {
6696 if (!wxPyCheckForApp()) SWIG_fail;
6697 PyThreadState* __tstate = wxPyBeginAllowThreads();
6698 wxDisplaySizeMM(arg1,arg2);
6699 wxPyEndAllowThreads(__tstate);
6700 if (PyErr_Occurred()) SWIG_fail;
6701 }
6702 resultobj = SWIG_Py_Void();
6703 if (SWIG_IsTmpObj(res1)) {
6704 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6705 } else {
6706 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6707 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6708 }
6709 if (SWIG_IsTmpObj(res2)) {
6710 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6711 } else {
6712 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6713 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6714 }
6715 return resultobj;
6716 fail:
6717 return NULL;
6718 }
6719
6720
6721 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6722 PyObject *resultobj = 0;
6723 wxSize result;
6724
6725 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6726 {
6727 if (!wxPyCheckForApp()) SWIG_fail;
6728 PyThreadState* __tstate = wxPyBeginAllowThreads();
6729 result = wxGetDisplaySizeMM();
6730 wxPyEndAllowThreads(__tstate);
6731 if (PyErr_Occurred()) SWIG_fail;
6732 }
6733 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6734 return resultobj;
6735 fail:
6736 return NULL;
6737 }
6738
6739
6740 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6741 PyObject *resultobj = 0;
6742 int *arg1 = (int *) 0 ;
6743 int *arg2 = (int *) 0 ;
6744 int *arg3 = (int *) 0 ;
6745 int *arg4 = (int *) 0 ;
6746 int temp1 ;
6747 int res1 = SWIG_TMPOBJ ;
6748 int temp2 ;
6749 int res2 = SWIG_TMPOBJ ;
6750 int temp3 ;
6751 int res3 = SWIG_TMPOBJ ;
6752 int temp4 ;
6753 int res4 = SWIG_TMPOBJ ;
6754
6755 arg1 = &temp1;
6756 arg2 = &temp2;
6757 arg3 = &temp3;
6758 arg4 = &temp4;
6759 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6760 {
6761 if (!wxPyCheckForApp()) SWIG_fail;
6762 PyThreadState* __tstate = wxPyBeginAllowThreads();
6763 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6764 wxPyEndAllowThreads(__tstate);
6765 if (PyErr_Occurred()) SWIG_fail;
6766 }
6767 resultobj = SWIG_Py_Void();
6768 if (SWIG_IsTmpObj(res1)) {
6769 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6770 } else {
6771 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6772 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6773 }
6774 if (SWIG_IsTmpObj(res2)) {
6775 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6776 } else {
6777 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6778 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6779 }
6780 if (SWIG_IsTmpObj(res3)) {
6781 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6782 } else {
6783 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6784 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6785 }
6786 if (SWIG_IsTmpObj(res4)) {
6787 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6788 } else {
6789 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6790 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6791 }
6792 return resultobj;
6793 fail:
6794 return NULL;
6795 }
6796
6797
6798 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6799 PyObject *resultobj = 0;
6800 wxRect result;
6801
6802 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6803 {
6804 if (!wxPyCheckForApp()) SWIG_fail;
6805 PyThreadState* __tstate = wxPyBeginAllowThreads();
6806 result = wxGetClientDisplayRect();
6807 wxPyEndAllowThreads(__tstate);
6808 if (PyErr_Occurred()) SWIG_fail;
6809 }
6810 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6811 return resultobj;
6812 fail:
6813 return NULL;
6814 }
6815
6816
6817 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6818 PyObject *resultobj = 0;
6819 wxCursor *arg1 = 0 ;
6820 void *argp1 = 0 ;
6821 int res1 = 0 ;
6822 PyObject * obj0 = 0 ;
6823 char * kwnames[] = {
6824 (char *) "cursor", NULL
6825 };
6826
6827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6828 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6829 if (!SWIG_IsOK(res1)) {
6830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6831 }
6832 if (!argp1) {
6833 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6834 }
6835 arg1 = reinterpret_cast< wxCursor * >(argp1);
6836 {
6837 if (!wxPyCheckForApp()) SWIG_fail;
6838 PyThreadState* __tstate = wxPyBeginAllowThreads();
6839 wxSetCursor(*arg1);
6840 wxPyEndAllowThreads(__tstate);
6841 if (PyErr_Occurred()) SWIG_fail;
6842 }
6843 resultobj = SWIG_Py_Void();
6844 return resultobj;
6845 fail:
6846 return NULL;
6847 }
6848
6849
6850 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6851 PyObject *resultobj = 0;
6852 void *result = 0 ;
6853
6854 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
6855 {
6856 if (!wxPyCheckForApp()) SWIG_fail;
6857 PyThreadState* __tstate = wxPyBeginAllowThreads();
6858 result = (void *)wxGetXDisplay();
6859 wxPyEndAllowThreads(__tstate);
6860 if (PyErr_Occurred()) SWIG_fail;
6861 }
6862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
6863 return resultobj;
6864 fail:
6865 return NULL;
6866 }
6867
6868
6869 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6870 PyObject *resultobj = 0;
6871 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6872 void *argp1 = 0 ;
6873 int res1 = 0 ;
6874 PyObject * obj0 = 0 ;
6875 char * kwnames[] = {
6876 (char *) "cursor", NULL
6877 };
6878
6879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
6880 if (obj0) {
6881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
6882 if (!SWIG_IsOK(res1)) {
6883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
6884 }
6885 arg1 = reinterpret_cast< wxCursor * >(argp1);
6886 }
6887 {
6888 if (!wxPyCheckForApp()) SWIG_fail;
6889 PyThreadState* __tstate = wxPyBeginAllowThreads();
6890 wxBeginBusyCursor(arg1);
6891 wxPyEndAllowThreads(__tstate);
6892 if (PyErr_Occurred()) SWIG_fail;
6893 }
6894 resultobj = SWIG_Py_Void();
6895 return resultobj;
6896 fail:
6897 return NULL;
6898 }
6899
6900
6901 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6902 PyObject *resultobj = 0;
6903 wxPoint result;
6904
6905 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
6906 {
6907 if (!wxPyCheckForApp()) SWIG_fail;
6908 PyThreadState* __tstate = wxPyBeginAllowThreads();
6909 result = wxGetMousePosition();
6910 wxPyEndAllowThreads(__tstate);
6911 if (PyErr_Occurred()) SWIG_fail;
6912 }
6913 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6914 return resultobj;
6915 fail:
6916 return NULL;
6917 }
6918
6919
6920 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6921 PyObject *resultobj = 0;
6922 wxWindow *result = 0 ;
6923
6924 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
6925 {
6926 if (!wxPyCheckForApp()) SWIG_fail;
6927 PyThreadState* __tstate = wxPyBeginAllowThreads();
6928 result = (wxWindow *)FindWindowAtPointer();
6929 wxPyEndAllowThreads(__tstate);
6930 if (PyErr_Occurred()) SWIG_fail;
6931 }
6932 {
6933 resultobj = wxPyMake_wxObject(result, 0);
6934 }
6935 return resultobj;
6936 fail:
6937 return NULL;
6938 }
6939
6940
6941 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6942 PyObject *resultobj = 0;
6943 wxWindow *result = 0 ;
6944
6945 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
6946 {
6947 if (!wxPyCheckForApp()) SWIG_fail;
6948 PyThreadState* __tstate = wxPyBeginAllowThreads();
6949 result = (wxWindow *)wxGetActiveWindow();
6950 wxPyEndAllowThreads(__tstate);
6951 if (PyErr_Occurred()) SWIG_fail;
6952 }
6953 {
6954 resultobj = wxPyMake_wxObject(result, 0);
6955 }
6956 return resultobj;
6957 fail:
6958 return NULL;
6959 }
6960
6961
6962 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6963 PyObject *resultobj = 0;
6964 wxPoint *arg1 = 0 ;
6965 wxWindow *result = 0 ;
6966 wxPoint temp1 ;
6967 PyObject * obj0 = 0 ;
6968 char * kwnames[] = {
6969 (char *) "pt", NULL
6970 };
6971
6972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6973 {
6974 arg1 = &temp1;
6975 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6976 }
6977 {
6978 if (!wxPyCheckForApp()) SWIG_fail;
6979 PyThreadState* __tstate = wxPyBeginAllowThreads();
6980 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
6981 wxPyEndAllowThreads(__tstate);
6982 if (PyErr_Occurred()) SWIG_fail;
6983 }
6984 {
6985 resultobj = wxPyMake_wxObject(result, 0);
6986 }
6987 return resultobj;
6988 fail:
6989 return NULL;
6990 }
6991
6992
6993 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6994 PyObject *resultobj = 0;
6995 wxPoint *arg1 = 0 ;
6996 wxWindow *result = 0 ;
6997 wxPoint temp1 ;
6998 PyObject * obj0 = 0 ;
6999 char * kwnames[] = {
7000 (char *) "pt", NULL
7001 };
7002
7003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7004 {
7005 arg1 = &temp1;
7006 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7007 }
7008 {
7009 if (!wxPyCheckForApp()) SWIG_fail;
7010 PyThreadState* __tstate = wxPyBeginAllowThreads();
7011 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7012 wxPyEndAllowThreads(__tstate);
7013 if (PyErr_Occurred()) SWIG_fail;
7014 }
7015 {
7016 resultobj = wxPyMake_wxObject(result, 0);
7017 }
7018 return resultobj;
7019 fail:
7020 return NULL;
7021 }
7022
7023
7024 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7025 PyObject *resultobj = 0;
7026 wxWindow *arg1 = (wxWindow *) 0 ;
7027 wxWindow *result = 0 ;
7028 void *argp1 = 0 ;
7029 int res1 = 0 ;
7030 PyObject * obj0 = 0 ;
7031 char * kwnames[] = {
7032 (char *) "win", NULL
7033 };
7034
7035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7037 if (!SWIG_IsOK(res1)) {
7038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7039 }
7040 arg1 = reinterpret_cast< wxWindow * >(argp1);
7041 {
7042 if (!wxPyCheckForApp()) SWIG_fail;
7043 PyThreadState* __tstate = wxPyBeginAllowThreads();
7044 result = (wxWindow *)wxGetTopLevelParent(arg1);
7045 wxPyEndAllowThreads(__tstate);
7046 if (PyErr_Occurred()) SWIG_fail;
7047 }
7048 {
7049 resultobj = wxPyMake_wxObject(result, 0);
7050 }
7051 return resultobj;
7052 fail:
7053 return NULL;
7054 }
7055
7056
7057 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7058 PyObject *resultobj = 0;
7059 wxString *arg1 = 0 ;
7060 bool result;
7061 bool temp1 = false ;
7062 PyObject * obj0 = 0 ;
7063 char * kwnames[] = {
7064 (char *) "url", NULL
7065 };
7066
7067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7068 {
7069 arg1 = wxString_in_helper(obj0);
7070 if (arg1 == NULL) SWIG_fail;
7071 temp1 = true;
7072 }
7073 {
7074 PyThreadState* __tstate = wxPyBeginAllowThreads();
7075 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7076 wxPyEndAllowThreads(__tstate);
7077 if (PyErr_Occurred()) SWIG_fail;
7078 }
7079 {
7080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7081 }
7082 {
7083 if (temp1)
7084 delete arg1;
7085 }
7086 return resultobj;
7087 fail:
7088 {
7089 if (temp1)
7090 delete arg1;
7091 }
7092 return NULL;
7093 }
7094
7095
7096 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7097 PyObject *resultobj = 0;
7098 wxKeyCode arg1 ;
7099 bool result;
7100 int val1 ;
7101 int ecode1 = 0 ;
7102 PyObject * obj0 = 0 ;
7103 char * kwnames[] = {
7104 (char *) "key", NULL
7105 };
7106
7107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7108 ecode1 = SWIG_AsVal_int(obj0, &val1);
7109 if (!SWIG_IsOK(ecode1)) {
7110 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7111 }
7112 arg1 = static_cast< wxKeyCode >(val1);
7113 {
7114 if (!wxPyCheckForApp()) SWIG_fail;
7115 PyThreadState* __tstate = wxPyBeginAllowThreads();
7116 result = (bool)wxGetKeyState(arg1);
7117 wxPyEndAllowThreads(__tstate);
7118 if (PyErr_Occurred()) SWIG_fail;
7119 }
7120 {
7121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7122 }
7123 return resultobj;
7124 fail:
7125 return NULL;
7126 }
7127
7128
7129 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7130 PyObject *resultobj = 0;
7131 wxMouseState *result = 0 ;
7132
7133 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7134 {
7135 PyThreadState* __tstate = wxPyBeginAllowThreads();
7136 result = (wxMouseState *)new wxMouseState();
7137 wxPyEndAllowThreads(__tstate);
7138 if (PyErr_Occurred()) SWIG_fail;
7139 }
7140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7141 return resultobj;
7142 fail:
7143 return NULL;
7144 }
7145
7146
7147 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7148 PyObject *resultobj = 0;
7149 wxMouseState *arg1 = (wxMouseState *) 0 ;
7150 void *argp1 = 0 ;
7151 int res1 = 0 ;
7152 PyObject *swig_obj[1] ;
7153
7154 if (!args) SWIG_fail;
7155 swig_obj[0] = args;
7156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7157 if (!SWIG_IsOK(res1)) {
7158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7159 }
7160 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7161 {
7162 PyThreadState* __tstate = wxPyBeginAllowThreads();
7163 delete arg1;
7164
7165 wxPyEndAllowThreads(__tstate);
7166 if (PyErr_Occurred()) SWIG_fail;
7167 }
7168 resultobj = SWIG_Py_Void();
7169 return resultobj;
7170 fail:
7171 return NULL;
7172 }
7173
7174
7175 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7176 PyObject *resultobj = 0;
7177 wxMouseState *arg1 = (wxMouseState *) 0 ;
7178 int result;
7179 void *argp1 = 0 ;
7180 int res1 = 0 ;
7181 PyObject *swig_obj[1] ;
7182
7183 if (!args) SWIG_fail;
7184 swig_obj[0] = args;
7185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7186 if (!SWIG_IsOK(res1)) {
7187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7188 }
7189 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7190 {
7191 PyThreadState* __tstate = wxPyBeginAllowThreads();
7192 result = (int)(arg1)->GetX();
7193 wxPyEndAllowThreads(__tstate);
7194 if (PyErr_Occurred()) SWIG_fail;
7195 }
7196 resultobj = SWIG_From_int(static_cast< int >(result));
7197 return resultobj;
7198 fail:
7199 return NULL;
7200 }
7201
7202
7203 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7204 PyObject *resultobj = 0;
7205 wxMouseState *arg1 = (wxMouseState *) 0 ;
7206 int result;
7207 void *argp1 = 0 ;
7208 int res1 = 0 ;
7209 PyObject *swig_obj[1] ;
7210
7211 if (!args) SWIG_fail;
7212 swig_obj[0] = args;
7213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7214 if (!SWIG_IsOK(res1)) {
7215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7216 }
7217 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7218 {
7219 PyThreadState* __tstate = wxPyBeginAllowThreads();
7220 result = (int)(arg1)->GetY();
7221 wxPyEndAllowThreads(__tstate);
7222 if (PyErr_Occurred()) SWIG_fail;
7223 }
7224 resultobj = SWIG_From_int(static_cast< int >(result));
7225 return resultobj;
7226 fail:
7227 return NULL;
7228 }
7229
7230
7231 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7232 PyObject *resultobj = 0;
7233 wxMouseState *arg1 = (wxMouseState *) 0 ;
7234 bool result;
7235 void *argp1 = 0 ;
7236 int res1 = 0 ;
7237 PyObject *swig_obj[1] ;
7238
7239 if (!args) SWIG_fail;
7240 swig_obj[0] = args;
7241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7242 if (!SWIG_IsOK(res1)) {
7243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7244 }
7245 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7246 {
7247 PyThreadState* __tstate = wxPyBeginAllowThreads();
7248 result = (bool)(arg1)->LeftDown();
7249 wxPyEndAllowThreads(__tstate);
7250 if (PyErr_Occurred()) SWIG_fail;
7251 }
7252 {
7253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7254 }
7255 return resultobj;
7256 fail:
7257 return NULL;
7258 }
7259
7260
7261 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7262 PyObject *resultobj = 0;
7263 wxMouseState *arg1 = (wxMouseState *) 0 ;
7264 bool result;
7265 void *argp1 = 0 ;
7266 int res1 = 0 ;
7267 PyObject *swig_obj[1] ;
7268
7269 if (!args) SWIG_fail;
7270 swig_obj[0] = args;
7271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7272 if (!SWIG_IsOK(res1)) {
7273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7274 }
7275 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7276 {
7277 PyThreadState* __tstate = wxPyBeginAllowThreads();
7278 result = (bool)(arg1)->MiddleDown();
7279 wxPyEndAllowThreads(__tstate);
7280 if (PyErr_Occurred()) SWIG_fail;
7281 }
7282 {
7283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7284 }
7285 return resultobj;
7286 fail:
7287 return NULL;
7288 }
7289
7290
7291 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7292 PyObject *resultobj = 0;
7293 wxMouseState *arg1 = (wxMouseState *) 0 ;
7294 bool result;
7295 void *argp1 = 0 ;
7296 int res1 = 0 ;
7297 PyObject *swig_obj[1] ;
7298
7299 if (!args) SWIG_fail;
7300 swig_obj[0] = args;
7301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7302 if (!SWIG_IsOK(res1)) {
7303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7304 }
7305 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7306 {
7307 PyThreadState* __tstate = wxPyBeginAllowThreads();
7308 result = (bool)(arg1)->RightDown();
7309 wxPyEndAllowThreads(__tstate);
7310 if (PyErr_Occurred()) SWIG_fail;
7311 }
7312 {
7313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7314 }
7315 return resultobj;
7316 fail:
7317 return NULL;
7318 }
7319
7320
7321 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7322 PyObject *resultobj = 0;
7323 wxMouseState *arg1 = (wxMouseState *) 0 ;
7324 bool result;
7325 void *argp1 = 0 ;
7326 int res1 = 0 ;
7327 PyObject *swig_obj[1] ;
7328
7329 if (!args) SWIG_fail;
7330 swig_obj[0] = args;
7331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7332 if (!SWIG_IsOK(res1)) {
7333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7334 }
7335 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7336 {
7337 PyThreadState* __tstate = wxPyBeginAllowThreads();
7338 result = (bool)(arg1)->ControlDown();
7339 wxPyEndAllowThreads(__tstate);
7340 if (PyErr_Occurred()) SWIG_fail;
7341 }
7342 {
7343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7344 }
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7352 PyObject *resultobj = 0;
7353 wxMouseState *arg1 = (wxMouseState *) 0 ;
7354 bool result;
7355 void *argp1 = 0 ;
7356 int res1 = 0 ;
7357 PyObject *swig_obj[1] ;
7358
7359 if (!args) SWIG_fail;
7360 swig_obj[0] = args;
7361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7362 if (!SWIG_IsOK(res1)) {
7363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7364 }
7365 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7366 {
7367 PyThreadState* __tstate = wxPyBeginAllowThreads();
7368 result = (bool)(arg1)->ShiftDown();
7369 wxPyEndAllowThreads(__tstate);
7370 if (PyErr_Occurred()) SWIG_fail;
7371 }
7372 {
7373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7374 }
7375 return resultobj;
7376 fail:
7377 return NULL;
7378 }
7379
7380
7381 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7382 PyObject *resultobj = 0;
7383 wxMouseState *arg1 = (wxMouseState *) 0 ;
7384 bool result;
7385 void *argp1 = 0 ;
7386 int res1 = 0 ;
7387 PyObject *swig_obj[1] ;
7388
7389 if (!args) SWIG_fail;
7390 swig_obj[0] = args;
7391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7392 if (!SWIG_IsOK(res1)) {
7393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7394 }
7395 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7396 {
7397 PyThreadState* __tstate = wxPyBeginAllowThreads();
7398 result = (bool)(arg1)->AltDown();
7399 wxPyEndAllowThreads(__tstate);
7400 if (PyErr_Occurred()) SWIG_fail;
7401 }
7402 {
7403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7404 }
7405 return resultobj;
7406 fail:
7407 return NULL;
7408 }
7409
7410
7411 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7412 PyObject *resultobj = 0;
7413 wxMouseState *arg1 = (wxMouseState *) 0 ;
7414 bool result;
7415 void *argp1 = 0 ;
7416 int res1 = 0 ;
7417 PyObject *swig_obj[1] ;
7418
7419 if (!args) SWIG_fail;
7420 swig_obj[0] = args;
7421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7422 if (!SWIG_IsOK(res1)) {
7423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7424 }
7425 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7426 {
7427 PyThreadState* __tstate = wxPyBeginAllowThreads();
7428 result = (bool)(arg1)->MetaDown();
7429 wxPyEndAllowThreads(__tstate);
7430 if (PyErr_Occurred()) SWIG_fail;
7431 }
7432 {
7433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7434 }
7435 return resultobj;
7436 fail:
7437 return NULL;
7438 }
7439
7440
7441 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7442 PyObject *resultobj = 0;
7443 wxMouseState *arg1 = (wxMouseState *) 0 ;
7444 bool result;
7445 void *argp1 = 0 ;
7446 int res1 = 0 ;
7447 PyObject *swig_obj[1] ;
7448
7449 if (!args) SWIG_fail;
7450 swig_obj[0] = args;
7451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7452 if (!SWIG_IsOK(res1)) {
7453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7454 }
7455 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7456 {
7457 PyThreadState* __tstate = wxPyBeginAllowThreads();
7458 result = (bool)(arg1)->CmdDown();
7459 wxPyEndAllowThreads(__tstate);
7460 if (PyErr_Occurred()) SWIG_fail;
7461 }
7462 {
7463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7464 }
7465 return resultobj;
7466 fail:
7467 return NULL;
7468 }
7469
7470
7471 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7472 PyObject *resultobj = 0;
7473 wxMouseState *arg1 = (wxMouseState *) 0 ;
7474 int arg2 ;
7475 void *argp1 = 0 ;
7476 int res1 = 0 ;
7477 int val2 ;
7478 int ecode2 = 0 ;
7479 PyObject * obj0 = 0 ;
7480 PyObject * obj1 = 0 ;
7481 char * kwnames[] = {
7482 (char *) "self",(char *) "x", NULL
7483 };
7484
7485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7487 if (!SWIG_IsOK(res1)) {
7488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7489 }
7490 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7491 ecode2 = SWIG_AsVal_int(obj1, &val2);
7492 if (!SWIG_IsOK(ecode2)) {
7493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7494 }
7495 arg2 = static_cast< int >(val2);
7496 {
7497 PyThreadState* __tstate = wxPyBeginAllowThreads();
7498 (arg1)->SetX(arg2);
7499 wxPyEndAllowThreads(__tstate);
7500 if (PyErr_Occurred()) SWIG_fail;
7501 }
7502 resultobj = SWIG_Py_Void();
7503 return resultobj;
7504 fail:
7505 return NULL;
7506 }
7507
7508
7509 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7510 PyObject *resultobj = 0;
7511 wxMouseState *arg1 = (wxMouseState *) 0 ;
7512 int arg2 ;
7513 void *argp1 = 0 ;
7514 int res1 = 0 ;
7515 int val2 ;
7516 int ecode2 = 0 ;
7517 PyObject * obj0 = 0 ;
7518 PyObject * obj1 = 0 ;
7519 char * kwnames[] = {
7520 (char *) "self",(char *) "y", NULL
7521 };
7522
7523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7525 if (!SWIG_IsOK(res1)) {
7526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7527 }
7528 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7529 ecode2 = SWIG_AsVal_int(obj1, &val2);
7530 if (!SWIG_IsOK(ecode2)) {
7531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7532 }
7533 arg2 = static_cast< int >(val2);
7534 {
7535 PyThreadState* __tstate = wxPyBeginAllowThreads();
7536 (arg1)->SetY(arg2);
7537 wxPyEndAllowThreads(__tstate);
7538 if (PyErr_Occurred()) SWIG_fail;
7539 }
7540 resultobj = SWIG_Py_Void();
7541 return resultobj;
7542 fail:
7543 return NULL;
7544 }
7545
7546
7547 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7548 PyObject *resultobj = 0;
7549 wxMouseState *arg1 = (wxMouseState *) 0 ;
7550 bool arg2 ;
7551 void *argp1 = 0 ;
7552 int res1 = 0 ;
7553 bool val2 ;
7554 int ecode2 = 0 ;
7555 PyObject * obj0 = 0 ;
7556 PyObject * obj1 = 0 ;
7557 char * kwnames[] = {
7558 (char *) "self",(char *) "down", NULL
7559 };
7560
7561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7563 if (!SWIG_IsOK(res1)) {
7564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7565 }
7566 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7567 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7568 if (!SWIG_IsOK(ecode2)) {
7569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7570 }
7571 arg2 = static_cast< bool >(val2);
7572 {
7573 PyThreadState* __tstate = wxPyBeginAllowThreads();
7574 (arg1)->SetLeftDown(arg2);
7575 wxPyEndAllowThreads(__tstate);
7576 if (PyErr_Occurred()) SWIG_fail;
7577 }
7578 resultobj = SWIG_Py_Void();
7579 return resultobj;
7580 fail:
7581 return NULL;
7582 }
7583
7584
7585 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7586 PyObject *resultobj = 0;
7587 wxMouseState *arg1 = (wxMouseState *) 0 ;
7588 bool arg2 ;
7589 void *argp1 = 0 ;
7590 int res1 = 0 ;
7591 bool val2 ;
7592 int ecode2 = 0 ;
7593 PyObject * obj0 = 0 ;
7594 PyObject * obj1 = 0 ;
7595 char * kwnames[] = {
7596 (char *) "self",(char *) "down", NULL
7597 };
7598
7599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7601 if (!SWIG_IsOK(res1)) {
7602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7603 }
7604 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7605 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7606 if (!SWIG_IsOK(ecode2)) {
7607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7608 }
7609 arg2 = static_cast< bool >(val2);
7610 {
7611 PyThreadState* __tstate = wxPyBeginAllowThreads();
7612 (arg1)->SetMiddleDown(arg2);
7613 wxPyEndAllowThreads(__tstate);
7614 if (PyErr_Occurred()) SWIG_fail;
7615 }
7616 resultobj = SWIG_Py_Void();
7617 return resultobj;
7618 fail:
7619 return NULL;
7620 }
7621
7622
7623 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7624 PyObject *resultobj = 0;
7625 wxMouseState *arg1 = (wxMouseState *) 0 ;
7626 bool arg2 ;
7627 void *argp1 = 0 ;
7628 int res1 = 0 ;
7629 bool val2 ;
7630 int ecode2 = 0 ;
7631 PyObject * obj0 = 0 ;
7632 PyObject * obj1 = 0 ;
7633 char * kwnames[] = {
7634 (char *) "self",(char *) "down", NULL
7635 };
7636
7637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7639 if (!SWIG_IsOK(res1)) {
7640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7641 }
7642 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7643 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7644 if (!SWIG_IsOK(ecode2)) {
7645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7646 }
7647 arg2 = static_cast< bool >(val2);
7648 {
7649 PyThreadState* __tstate = wxPyBeginAllowThreads();
7650 (arg1)->SetRightDown(arg2);
7651 wxPyEndAllowThreads(__tstate);
7652 if (PyErr_Occurred()) SWIG_fail;
7653 }
7654 resultobj = SWIG_Py_Void();
7655 return resultobj;
7656 fail:
7657 return NULL;
7658 }
7659
7660
7661 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7662 PyObject *resultobj = 0;
7663 wxMouseState *arg1 = (wxMouseState *) 0 ;
7664 bool arg2 ;
7665 void *argp1 = 0 ;
7666 int res1 = 0 ;
7667 bool val2 ;
7668 int ecode2 = 0 ;
7669 PyObject * obj0 = 0 ;
7670 PyObject * obj1 = 0 ;
7671 char * kwnames[] = {
7672 (char *) "self",(char *) "down", NULL
7673 };
7674
7675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7677 if (!SWIG_IsOK(res1)) {
7678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7679 }
7680 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7681 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7682 if (!SWIG_IsOK(ecode2)) {
7683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7684 }
7685 arg2 = static_cast< bool >(val2);
7686 {
7687 PyThreadState* __tstate = wxPyBeginAllowThreads();
7688 (arg1)->SetControlDown(arg2);
7689 wxPyEndAllowThreads(__tstate);
7690 if (PyErr_Occurred()) SWIG_fail;
7691 }
7692 resultobj = SWIG_Py_Void();
7693 return resultobj;
7694 fail:
7695 return NULL;
7696 }
7697
7698
7699 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7700 PyObject *resultobj = 0;
7701 wxMouseState *arg1 = (wxMouseState *) 0 ;
7702 bool arg2 ;
7703 void *argp1 = 0 ;
7704 int res1 = 0 ;
7705 bool val2 ;
7706 int ecode2 = 0 ;
7707 PyObject * obj0 = 0 ;
7708 PyObject * obj1 = 0 ;
7709 char * kwnames[] = {
7710 (char *) "self",(char *) "down", NULL
7711 };
7712
7713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7715 if (!SWIG_IsOK(res1)) {
7716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7717 }
7718 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7719 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7720 if (!SWIG_IsOK(ecode2)) {
7721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7722 }
7723 arg2 = static_cast< bool >(val2);
7724 {
7725 PyThreadState* __tstate = wxPyBeginAllowThreads();
7726 (arg1)->SetShiftDown(arg2);
7727 wxPyEndAllowThreads(__tstate);
7728 if (PyErr_Occurred()) SWIG_fail;
7729 }
7730 resultobj = SWIG_Py_Void();
7731 return resultobj;
7732 fail:
7733 return NULL;
7734 }
7735
7736
7737 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7738 PyObject *resultobj = 0;
7739 wxMouseState *arg1 = (wxMouseState *) 0 ;
7740 bool arg2 ;
7741 void *argp1 = 0 ;
7742 int res1 = 0 ;
7743 bool val2 ;
7744 int ecode2 = 0 ;
7745 PyObject * obj0 = 0 ;
7746 PyObject * obj1 = 0 ;
7747 char * kwnames[] = {
7748 (char *) "self",(char *) "down", NULL
7749 };
7750
7751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7753 if (!SWIG_IsOK(res1)) {
7754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7755 }
7756 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7757 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7758 if (!SWIG_IsOK(ecode2)) {
7759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7760 }
7761 arg2 = static_cast< bool >(val2);
7762 {
7763 PyThreadState* __tstate = wxPyBeginAllowThreads();
7764 (arg1)->SetAltDown(arg2);
7765 wxPyEndAllowThreads(__tstate);
7766 if (PyErr_Occurred()) SWIG_fail;
7767 }
7768 resultobj = SWIG_Py_Void();
7769 return resultobj;
7770 fail:
7771 return NULL;
7772 }
7773
7774
7775 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7776 PyObject *resultobj = 0;
7777 wxMouseState *arg1 = (wxMouseState *) 0 ;
7778 bool arg2 ;
7779 void *argp1 = 0 ;
7780 int res1 = 0 ;
7781 bool val2 ;
7782 int ecode2 = 0 ;
7783 PyObject * obj0 = 0 ;
7784 PyObject * obj1 = 0 ;
7785 char * kwnames[] = {
7786 (char *) "self",(char *) "down", NULL
7787 };
7788
7789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7791 if (!SWIG_IsOK(res1)) {
7792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7793 }
7794 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7795 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7796 if (!SWIG_IsOK(ecode2)) {
7797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7798 }
7799 arg2 = static_cast< bool >(val2);
7800 {
7801 PyThreadState* __tstate = wxPyBeginAllowThreads();
7802 (arg1)->SetMetaDown(arg2);
7803 wxPyEndAllowThreads(__tstate);
7804 if (PyErr_Occurred()) SWIG_fail;
7805 }
7806 resultobj = SWIG_Py_Void();
7807 return resultobj;
7808 fail:
7809 return NULL;
7810 }
7811
7812
7813 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7814 PyObject *obj;
7815 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7816 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7817 return SWIG_Py_Void();
7818 }
7819
7820 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7821 return SWIG_Python_InitShadowInstance(args);
7822 }
7823
7824 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7825 PyObject *resultobj = 0;
7826 wxMouseState result;
7827
7828 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7829 {
7830 PyThreadState* __tstate = wxPyBeginAllowThreads();
7831 result = wxGetMouseState();
7832 wxPyEndAllowThreads(__tstate);
7833 if (PyErr_Occurred()) SWIG_fail;
7834 }
7835 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7836 return resultobj;
7837 fail:
7838 return NULL;
7839 }
7840
7841
7842 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7843 PyObject *resultobj = 0;
7844
7845 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
7846 {
7847 if (!wxPyCheckForApp()) SWIG_fail;
7848 PyThreadState* __tstate = wxPyBeginAllowThreads();
7849 wxWakeUpMainThread();
7850 wxPyEndAllowThreads(__tstate);
7851 if (PyErr_Occurred()) SWIG_fail;
7852 }
7853 resultobj = SWIG_Py_Void();
7854 return resultobj;
7855 fail:
7856 return NULL;
7857 }
7858
7859
7860 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7861 PyObject *resultobj = 0;
7862
7863 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
7864 {
7865 if (!wxPyCheckForApp()) SWIG_fail;
7866 PyThreadState* __tstate = wxPyBeginAllowThreads();
7867 wxMutexGuiEnter();
7868 wxPyEndAllowThreads(__tstate);
7869 if (PyErr_Occurred()) SWIG_fail;
7870 }
7871 resultobj = SWIG_Py_Void();
7872 return resultobj;
7873 fail:
7874 return NULL;
7875 }
7876
7877
7878 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7879 PyObject *resultobj = 0;
7880
7881 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
7882 {
7883 if (!wxPyCheckForApp()) SWIG_fail;
7884 PyThreadState* __tstate = wxPyBeginAllowThreads();
7885 wxMutexGuiLeave();
7886 wxPyEndAllowThreads(__tstate);
7887 if (PyErr_Occurred()) SWIG_fail;
7888 }
7889 resultobj = SWIG_Py_Void();
7890 return resultobj;
7891 fail:
7892 return NULL;
7893 }
7894
7895
7896 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7897 PyObject *resultobj = 0;
7898 wxMutexGuiLocker *result = 0 ;
7899
7900 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
7901 {
7902 if (!wxPyCheckForApp()) SWIG_fail;
7903 PyThreadState* __tstate = wxPyBeginAllowThreads();
7904 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
7905 wxPyEndAllowThreads(__tstate);
7906 if (PyErr_Occurred()) SWIG_fail;
7907 }
7908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
7909 return resultobj;
7910 fail:
7911 return NULL;
7912 }
7913
7914
7915 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7916 PyObject *resultobj = 0;
7917 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
7918 void *argp1 = 0 ;
7919 int res1 = 0 ;
7920 PyObject *swig_obj[1] ;
7921
7922 if (!args) SWIG_fail;
7923 swig_obj[0] = args;
7924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
7925 if (!SWIG_IsOK(res1)) {
7926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
7927 }
7928 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
7929 {
7930 PyThreadState* __tstate = wxPyBeginAllowThreads();
7931 delete arg1;
7932
7933 wxPyEndAllowThreads(__tstate);
7934 if (PyErr_Occurred()) SWIG_fail;
7935 }
7936 resultobj = SWIG_Py_Void();
7937 return resultobj;
7938 fail:
7939 return NULL;
7940 }
7941
7942
7943 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7944 PyObject *obj;
7945 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7946 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
7947 return SWIG_Py_Void();
7948 }
7949
7950 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7951 return SWIG_Python_InitShadowInstance(args);
7952 }
7953
7954 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7955 PyObject *resultobj = 0;
7956 bool result;
7957
7958 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
7959 {
7960 PyThreadState* __tstate = wxPyBeginAllowThreads();
7961 result = (bool)wxThread_IsMain();
7962 wxPyEndAllowThreads(__tstate);
7963 if (PyErr_Occurred()) SWIG_fail;
7964 }
7965 {
7966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7967 }
7968 return resultobj;
7969 fail:
7970 return NULL;
7971 }
7972
7973
7974 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7975 PyObject *resultobj = 0;
7976 wxString *arg1 = 0 ;
7977 wxToolTip *result = 0 ;
7978 bool temp1 = false ;
7979 PyObject * obj0 = 0 ;
7980 char * kwnames[] = {
7981 (char *) "tip", NULL
7982 };
7983
7984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
7985 {
7986 arg1 = wxString_in_helper(obj0);
7987 if (arg1 == NULL) SWIG_fail;
7988 temp1 = true;
7989 }
7990 {
7991 if (!wxPyCheckForApp()) SWIG_fail;
7992 PyThreadState* __tstate = wxPyBeginAllowThreads();
7993 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
7994 wxPyEndAllowThreads(__tstate);
7995 if (PyErr_Occurred()) SWIG_fail;
7996 }
7997 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
7998 {
7999 if (temp1)
8000 delete arg1;
8001 }
8002 return resultobj;
8003 fail:
8004 {
8005 if (temp1)
8006 delete arg1;
8007 }
8008 return NULL;
8009 }
8010
8011
8012 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8013 PyObject *resultobj = 0;
8014 wxToolTip *arg1 = (wxToolTip *) 0 ;
8015 void *argp1 = 0 ;
8016 int res1 = 0 ;
8017 PyObject *swig_obj[1] ;
8018
8019 if (!args) SWIG_fail;
8020 swig_obj[0] = args;
8021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8022 if (!SWIG_IsOK(res1)) {
8023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8024 }
8025 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8026 {
8027 PyThreadState* __tstate = wxPyBeginAllowThreads();
8028 delete arg1;
8029
8030 wxPyEndAllowThreads(__tstate);
8031 if (PyErr_Occurred()) SWIG_fail;
8032 }
8033 resultobj = SWIG_Py_Void();
8034 return resultobj;
8035 fail:
8036 return NULL;
8037 }
8038
8039
8040 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8041 PyObject *resultobj = 0;
8042 wxToolTip *arg1 = (wxToolTip *) 0 ;
8043 wxString *arg2 = 0 ;
8044 void *argp1 = 0 ;
8045 int res1 = 0 ;
8046 bool temp2 = false ;
8047 PyObject * obj0 = 0 ;
8048 PyObject * obj1 = 0 ;
8049 char * kwnames[] = {
8050 (char *) "self",(char *) "tip", NULL
8051 };
8052
8053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8055 if (!SWIG_IsOK(res1)) {
8056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8057 }
8058 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8059 {
8060 arg2 = wxString_in_helper(obj1);
8061 if (arg2 == NULL) SWIG_fail;
8062 temp2 = true;
8063 }
8064 {
8065 PyThreadState* __tstate = wxPyBeginAllowThreads();
8066 (arg1)->SetTip((wxString const &)*arg2);
8067 wxPyEndAllowThreads(__tstate);
8068 if (PyErr_Occurred()) SWIG_fail;
8069 }
8070 resultobj = SWIG_Py_Void();
8071 {
8072 if (temp2)
8073 delete arg2;
8074 }
8075 return resultobj;
8076 fail:
8077 {
8078 if (temp2)
8079 delete arg2;
8080 }
8081 return NULL;
8082 }
8083
8084
8085 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8086 PyObject *resultobj = 0;
8087 wxToolTip *arg1 = (wxToolTip *) 0 ;
8088 wxString result;
8089 void *argp1 = 0 ;
8090 int res1 = 0 ;
8091 PyObject *swig_obj[1] ;
8092
8093 if (!args) SWIG_fail;
8094 swig_obj[0] = args;
8095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8096 if (!SWIG_IsOK(res1)) {
8097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8098 }
8099 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8100 {
8101 PyThreadState* __tstate = wxPyBeginAllowThreads();
8102 result = (arg1)->GetTip();
8103 wxPyEndAllowThreads(__tstate);
8104 if (PyErr_Occurred()) SWIG_fail;
8105 }
8106 {
8107 #if wxUSE_UNICODE
8108 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8109 #else
8110 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8111 #endif
8112 }
8113 return resultobj;
8114 fail:
8115 return NULL;
8116 }
8117
8118
8119 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8120 PyObject *resultobj = 0;
8121 wxToolTip *arg1 = (wxToolTip *) 0 ;
8122 wxWindow *result = 0 ;
8123 void *argp1 = 0 ;
8124 int res1 = 0 ;
8125 PyObject *swig_obj[1] ;
8126
8127 if (!args) SWIG_fail;
8128 swig_obj[0] = args;
8129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8130 if (!SWIG_IsOK(res1)) {
8131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8132 }
8133 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8134 {
8135 PyThreadState* __tstate = wxPyBeginAllowThreads();
8136 result = (wxWindow *)(arg1)->GetWindow();
8137 wxPyEndAllowThreads(__tstate);
8138 if (PyErr_Occurred()) SWIG_fail;
8139 }
8140 {
8141 resultobj = wxPyMake_wxObject(result, 0);
8142 }
8143 return resultobj;
8144 fail:
8145 return NULL;
8146 }
8147
8148
8149 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8150 PyObject *resultobj = 0;
8151 bool arg1 ;
8152 bool val1 ;
8153 int ecode1 = 0 ;
8154 PyObject * obj0 = 0 ;
8155 char * kwnames[] = {
8156 (char *) "flag", NULL
8157 };
8158
8159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8160 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8161 if (!SWIG_IsOK(ecode1)) {
8162 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8163 }
8164 arg1 = static_cast< bool >(val1);
8165 {
8166 PyThreadState* __tstate = wxPyBeginAllowThreads();
8167 wxToolTip::Enable(arg1);
8168 wxPyEndAllowThreads(__tstate);
8169 if (PyErr_Occurred()) SWIG_fail;
8170 }
8171 resultobj = SWIG_Py_Void();
8172 return resultobj;
8173 fail:
8174 return NULL;
8175 }
8176
8177
8178 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8179 PyObject *resultobj = 0;
8180 long arg1 ;
8181 long val1 ;
8182 int ecode1 = 0 ;
8183 PyObject * obj0 = 0 ;
8184 char * kwnames[] = {
8185 (char *) "milliseconds", NULL
8186 };
8187
8188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8189 ecode1 = SWIG_AsVal_long(obj0, &val1);
8190 if (!SWIG_IsOK(ecode1)) {
8191 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8192 }
8193 arg1 = static_cast< long >(val1);
8194 {
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 wxToolTip::SetDelay(arg1);
8197 wxPyEndAllowThreads(__tstate);
8198 if (PyErr_Occurred()) SWIG_fail;
8199 }
8200 resultobj = SWIG_Py_Void();
8201 return resultobj;
8202 fail:
8203 return NULL;
8204 }
8205
8206
8207 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8208 PyObject *obj;
8209 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8210 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8211 return SWIG_Py_Void();
8212 }
8213
8214 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8215 return SWIG_Python_InitShadowInstance(args);
8216 }
8217
8218 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8219 PyObject *resultobj = 0;
8220 wxWindow *arg1 = (wxWindow *) 0 ;
8221 wxSize *arg2 = 0 ;
8222 wxCaret *result = 0 ;
8223 void *argp1 = 0 ;
8224 int res1 = 0 ;
8225 wxSize temp2 ;
8226 PyObject * obj0 = 0 ;
8227 PyObject * obj1 = 0 ;
8228 char * kwnames[] = {
8229 (char *) "window",(char *) "size", NULL
8230 };
8231
8232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8234 if (!SWIG_IsOK(res1)) {
8235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8236 }
8237 arg1 = reinterpret_cast< wxWindow * >(argp1);
8238 {
8239 arg2 = &temp2;
8240 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8241 }
8242 {
8243 if (!wxPyCheckForApp()) SWIG_fail;
8244 PyThreadState* __tstate = wxPyBeginAllowThreads();
8245 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8246 wxPyEndAllowThreads(__tstate);
8247 if (PyErr_Occurred()) SWIG_fail;
8248 }
8249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8250 return resultobj;
8251 fail:
8252 return NULL;
8253 }
8254
8255
8256 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8257 PyObject *resultobj = 0;
8258 wxCaret *arg1 = (wxCaret *) 0 ;
8259 void *argp1 = 0 ;
8260 int res1 = 0 ;
8261 PyObject *swig_obj[1] ;
8262
8263 if (!args) SWIG_fail;
8264 swig_obj[0] = args;
8265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8266 if (!SWIG_IsOK(res1)) {
8267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8268 }
8269 arg1 = reinterpret_cast< wxCaret * >(argp1);
8270 {
8271 PyThreadState* __tstate = wxPyBeginAllowThreads();
8272 delete arg1;
8273
8274 wxPyEndAllowThreads(__tstate);
8275 if (PyErr_Occurred()) SWIG_fail;
8276 }
8277 resultobj = SWIG_Py_Void();
8278 return resultobj;
8279 fail:
8280 return NULL;
8281 }
8282
8283
8284 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8285 PyObject *resultobj = 0;
8286 wxCaret *arg1 = (wxCaret *) 0 ;
8287 void *argp1 = 0 ;
8288 int res1 = 0 ;
8289 PyObject *swig_obj[1] ;
8290
8291 if (!args) SWIG_fail;
8292 swig_obj[0] = args;
8293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8294 if (!SWIG_IsOK(res1)) {
8295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8296 }
8297 arg1 = reinterpret_cast< wxCaret * >(argp1);
8298 {
8299 PyThreadState* __tstate = wxPyBeginAllowThreads();
8300 wxCaret_Destroy(arg1);
8301 wxPyEndAllowThreads(__tstate);
8302 if (PyErr_Occurred()) SWIG_fail;
8303 }
8304 resultobj = SWIG_Py_Void();
8305 return resultobj;
8306 fail:
8307 return NULL;
8308 }
8309
8310
8311 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8312 PyObject *resultobj = 0;
8313 wxCaret *arg1 = (wxCaret *) 0 ;
8314 bool result;
8315 void *argp1 = 0 ;
8316 int res1 = 0 ;
8317 PyObject *swig_obj[1] ;
8318
8319 if (!args) SWIG_fail;
8320 swig_obj[0] = args;
8321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8322 if (!SWIG_IsOK(res1)) {
8323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8324 }
8325 arg1 = reinterpret_cast< wxCaret * >(argp1);
8326 {
8327 PyThreadState* __tstate = wxPyBeginAllowThreads();
8328 result = (bool)(arg1)->IsOk();
8329 wxPyEndAllowThreads(__tstate);
8330 if (PyErr_Occurred()) SWIG_fail;
8331 }
8332 {
8333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8334 }
8335 return resultobj;
8336 fail:
8337 return NULL;
8338 }
8339
8340
8341 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8342 PyObject *resultobj = 0;
8343 wxCaret *arg1 = (wxCaret *) 0 ;
8344 bool result;
8345 void *argp1 = 0 ;
8346 int res1 = 0 ;
8347 PyObject *swig_obj[1] ;
8348
8349 if (!args) SWIG_fail;
8350 swig_obj[0] = args;
8351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8352 if (!SWIG_IsOK(res1)) {
8353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8354 }
8355 arg1 = reinterpret_cast< wxCaret * >(argp1);
8356 {
8357 PyThreadState* __tstate = wxPyBeginAllowThreads();
8358 result = (bool)(arg1)->IsVisible();
8359 wxPyEndAllowThreads(__tstate);
8360 if (PyErr_Occurred()) SWIG_fail;
8361 }
8362 {
8363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8364 }
8365 return resultobj;
8366 fail:
8367 return NULL;
8368 }
8369
8370
8371 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8372 PyObject *resultobj = 0;
8373 wxCaret *arg1 = (wxCaret *) 0 ;
8374 wxPoint result;
8375 void *argp1 = 0 ;
8376 int res1 = 0 ;
8377 PyObject *swig_obj[1] ;
8378
8379 if (!args) SWIG_fail;
8380 swig_obj[0] = args;
8381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8382 if (!SWIG_IsOK(res1)) {
8383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8384 }
8385 arg1 = reinterpret_cast< wxCaret * >(argp1);
8386 {
8387 PyThreadState* __tstate = wxPyBeginAllowThreads();
8388 result = (arg1)->GetPosition();
8389 wxPyEndAllowThreads(__tstate);
8390 if (PyErr_Occurred()) SWIG_fail;
8391 }
8392 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8393 return resultobj;
8394 fail:
8395 return NULL;
8396 }
8397
8398
8399 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8400 PyObject *resultobj = 0;
8401 wxCaret *arg1 = (wxCaret *) 0 ;
8402 int *arg2 = (int *) 0 ;
8403 int *arg3 = (int *) 0 ;
8404 void *argp1 = 0 ;
8405 int res1 = 0 ;
8406 int temp2 ;
8407 int res2 = SWIG_TMPOBJ ;
8408 int temp3 ;
8409 int res3 = SWIG_TMPOBJ ;
8410 PyObject *swig_obj[1] ;
8411
8412 arg2 = &temp2;
8413 arg3 = &temp3;
8414 if (!args) SWIG_fail;
8415 swig_obj[0] = args;
8416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8417 if (!SWIG_IsOK(res1)) {
8418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8419 }
8420 arg1 = reinterpret_cast< wxCaret * >(argp1);
8421 {
8422 PyThreadState* __tstate = wxPyBeginAllowThreads();
8423 (arg1)->GetPosition(arg2,arg3);
8424 wxPyEndAllowThreads(__tstate);
8425 if (PyErr_Occurred()) SWIG_fail;
8426 }
8427 resultobj = SWIG_Py_Void();
8428 if (SWIG_IsTmpObj(res2)) {
8429 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8430 } else {
8431 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8432 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8433 }
8434 if (SWIG_IsTmpObj(res3)) {
8435 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8436 } else {
8437 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8438 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8439 }
8440 return resultobj;
8441 fail:
8442 return NULL;
8443 }
8444
8445
8446 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8447 PyObject *resultobj = 0;
8448 wxCaret *arg1 = (wxCaret *) 0 ;
8449 wxSize result;
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, 0 | 0 );
8457 if (!SWIG_IsOK(res1)) {
8458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8459 }
8460 arg1 = reinterpret_cast< wxCaret * >(argp1);
8461 {
8462 PyThreadState* __tstate = wxPyBeginAllowThreads();
8463 result = (arg1)->GetSize();
8464 wxPyEndAllowThreads(__tstate);
8465 if (PyErr_Occurred()) SWIG_fail;
8466 }
8467 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8468 return resultobj;
8469 fail:
8470 return NULL;
8471 }
8472
8473
8474 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8475 PyObject *resultobj = 0;
8476 wxCaret *arg1 = (wxCaret *) 0 ;
8477 int *arg2 = (int *) 0 ;
8478 int *arg3 = (int *) 0 ;
8479 void *argp1 = 0 ;
8480 int res1 = 0 ;
8481 int temp2 ;
8482 int res2 = SWIG_TMPOBJ ;
8483 int temp3 ;
8484 int res3 = SWIG_TMPOBJ ;
8485 PyObject *swig_obj[1] ;
8486
8487 arg2 = &temp2;
8488 arg3 = &temp3;
8489 if (!args) SWIG_fail;
8490 swig_obj[0] = args;
8491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8492 if (!SWIG_IsOK(res1)) {
8493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8494 }
8495 arg1 = reinterpret_cast< wxCaret * >(argp1);
8496 {
8497 PyThreadState* __tstate = wxPyBeginAllowThreads();
8498 (arg1)->GetSize(arg2,arg3);
8499 wxPyEndAllowThreads(__tstate);
8500 if (PyErr_Occurred()) SWIG_fail;
8501 }
8502 resultobj = SWIG_Py_Void();
8503 if (SWIG_IsTmpObj(res2)) {
8504 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8505 } else {
8506 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8507 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8508 }
8509 if (SWIG_IsTmpObj(res3)) {
8510 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8511 } else {
8512 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8513 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8514 }
8515 return resultobj;
8516 fail:
8517 return NULL;
8518 }
8519
8520
8521 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8522 PyObject *resultobj = 0;
8523 wxCaret *arg1 = (wxCaret *) 0 ;
8524 wxWindow *result = 0 ;
8525 void *argp1 = 0 ;
8526 int res1 = 0 ;
8527 PyObject *swig_obj[1] ;
8528
8529 if (!args) SWIG_fail;
8530 swig_obj[0] = args;
8531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8532 if (!SWIG_IsOK(res1)) {
8533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8534 }
8535 arg1 = reinterpret_cast< wxCaret * >(argp1);
8536 {
8537 PyThreadState* __tstate = wxPyBeginAllowThreads();
8538 result = (wxWindow *)(arg1)->GetWindow();
8539 wxPyEndAllowThreads(__tstate);
8540 if (PyErr_Occurred()) SWIG_fail;
8541 }
8542 {
8543 resultobj = wxPyMake_wxObject(result, 0);
8544 }
8545 return resultobj;
8546 fail:
8547 return NULL;
8548 }
8549
8550
8551 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8552 PyObject *resultobj = 0;
8553 wxCaret *arg1 = (wxCaret *) 0 ;
8554 int arg2 ;
8555 int arg3 ;
8556 void *argp1 = 0 ;
8557 int res1 = 0 ;
8558 int val2 ;
8559 int ecode2 = 0 ;
8560 int val3 ;
8561 int ecode3 = 0 ;
8562 PyObject * obj0 = 0 ;
8563 PyObject * obj1 = 0 ;
8564 PyObject * obj2 = 0 ;
8565 char * kwnames[] = {
8566 (char *) "self",(char *) "x",(char *) "y", NULL
8567 };
8568
8569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8571 if (!SWIG_IsOK(res1)) {
8572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8573 }
8574 arg1 = reinterpret_cast< wxCaret * >(argp1);
8575 ecode2 = SWIG_AsVal_int(obj1, &val2);
8576 if (!SWIG_IsOK(ecode2)) {
8577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8578 }
8579 arg2 = static_cast< int >(val2);
8580 ecode3 = SWIG_AsVal_int(obj2, &val3);
8581 if (!SWIG_IsOK(ecode3)) {
8582 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8583 }
8584 arg3 = static_cast< int >(val3);
8585 {
8586 PyThreadState* __tstate = wxPyBeginAllowThreads();
8587 (arg1)->Move(arg2,arg3);
8588 wxPyEndAllowThreads(__tstate);
8589 if (PyErr_Occurred()) SWIG_fail;
8590 }
8591 resultobj = SWIG_Py_Void();
8592 return resultobj;
8593 fail:
8594 return NULL;
8595 }
8596
8597
8598 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8599 PyObject *resultobj = 0;
8600 wxCaret *arg1 = (wxCaret *) 0 ;
8601 wxPoint *arg2 = 0 ;
8602 void *argp1 = 0 ;
8603 int res1 = 0 ;
8604 wxPoint temp2 ;
8605 PyObject * obj0 = 0 ;
8606 PyObject * obj1 = 0 ;
8607 char * kwnames[] = {
8608 (char *) "self",(char *) "pt", NULL
8609 };
8610
8611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8613 if (!SWIG_IsOK(res1)) {
8614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8615 }
8616 arg1 = reinterpret_cast< wxCaret * >(argp1);
8617 {
8618 arg2 = &temp2;
8619 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8620 }
8621 {
8622 PyThreadState* __tstate = wxPyBeginAllowThreads();
8623 (arg1)->Move((wxPoint const &)*arg2);
8624 wxPyEndAllowThreads(__tstate);
8625 if (PyErr_Occurred()) SWIG_fail;
8626 }
8627 resultobj = SWIG_Py_Void();
8628 return resultobj;
8629 fail:
8630 return NULL;
8631 }
8632
8633
8634 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8635 PyObject *resultobj = 0;
8636 wxCaret *arg1 = (wxCaret *) 0 ;
8637 int arg2 ;
8638 int arg3 ;
8639 void *argp1 = 0 ;
8640 int res1 = 0 ;
8641 int val2 ;
8642 int ecode2 = 0 ;
8643 int val3 ;
8644 int ecode3 = 0 ;
8645 PyObject * obj0 = 0 ;
8646 PyObject * obj1 = 0 ;
8647 PyObject * obj2 = 0 ;
8648 char * kwnames[] = {
8649 (char *) "self",(char *) "width",(char *) "height", NULL
8650 };
8651
8652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8654 if (!SWIG_IsOK(res1)) {
8655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8656 }
8657 arg1 = reinterpret_cast< wxCaret * >(argp1);
8658 ecode2 = SWIG_AsVal_int(obj1, &val2);
8659 if (!SWIG_IsOK(ecode2)) {
8660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8661 }
8662 arg2 = static_cast< int >(val2);
8663 ecode3 = SWIG_AsVal_int(obj2, &val3);
8664 if (!SWIG_IsOK(ecode3)) {
8665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8666 }
8667 arg3 = static_cast< int >(val3);
8668 {
8669 PyThreadState* __tstate = wxPyBeginAllowThreads();
8670 (arg1)->SetSize(arg2,arg3);
8671 wxPyEndAllowThreads(__tstate);
8672 if (PyErr_Occurred()) SWIG_fail;
8673 }
8674 resultobj = SWIG_Py_Void();
8675 return resultobj;
8676 fail:
8677 return NULL;
8678 }
8679
8680
8681 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8682 PyObject *resultobj = 0;
8683 wxCaret *arg1 = (wxCaret *) 0 ;
8684 wxSize *arg2 = 0 ;
8685 void *argp1 = 0 ;
8686 int res1 = 0 ;
8687 wxSize temp2 ;
8688 PyObject * obj0 = 0 ;
8689 PyObject * obj1 = 0 ;
8690 char * kwnames[] = {
8691 (char *) "self",(char *) "size", NULL
8692 };
8693
8694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8696 if (!SWIG_IsOK(res1)) {
8697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8698 }
8699 arg1 = reinterpret_cast< wxCaret * >(argp1);
8700 {
8701 arg2 = &temp2;
8702 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8703 }
8704 {
8705 PyThreadState* __tstate = wxPyBeginAllowThreads();
8706 (arg1)->SetSize((wxSize const &)*arg2);
8707 wxPyEndAllowThreads(__tstate);
8708 if (PyErr_Occurred()) SWIG_fail;
8709 }
8710 resultobj = SWIG_Py_Void();
8711 return resultobj;
8712 fail:
8713 return NULL;
8714 }
8715
8716
8717 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8718 PyObject *resultobj = 0;
8719 wxCaret *arg1 = (wxCaret *) 0 ;
8720 int arg2 = (int) true ;
8721 void *argp1 = 0 ;
8722 int res1 = 0 ;
8723 int val2 ;
8724 int ecode2 = 0 ;
8725 PyObject * obj0 = 0 ;
8726 PyObject * obj1 = 0 ;
8727 char * kwnames[] = {
8728 (char *) "self",(char *) "show", NULL
8729 };
8730
8731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8733 if (!SWIG_IsOK(res1)) {
8734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8735 }
8736 arg1 = reinterpret_cast< wxCaret * >(argp1);
8737 if (obj1) {
8738 ecode2 = SWIG_AsVal_int(obj1, &val2);
8739 if (!SWIG_IsOK(ecode2)) {
8740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8741 }
8742 arg2 = static_cast< int >(val2);
8743 }
8744 {
8745 PyThreadState* __tstate = wxPyBeginAllowThreads();
8746 (arg1)->Show(arg2);
8747 wxPyEndAllowThreads(__tstate);
8748 if (PyErr_Occurred()) SWIG_fail;
8749 }
8750 resultobj = SWIG_Py_Void();
8751 return resultobj;
8752 fail:
8753 return NULL;
8754 }
8755
8756
8757 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8758 PyObject *resultobj = 0;
8759 wxCaret *arg1 = (wxCaret *) 0 ;
8760 void *argp1 = 0 ;
8761 int res1 = 0 ;
8762 PyObject *swig_obj[1] ;
8763
8764 if (!args) SWIG_fail;
8765 swig_obj[0] = args;
8766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8767 if (!SWIG_IsOK(res1)) {
8768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8769 }
8770 arg1 = reinterpret_cast< wxCaret * >(argp1);
8771 {
8772 PyThreadState* __tstate = wxPyBeginAllowThreads();
8773 (arg1)->Hide();
8774 wxPyEndAllowThreads(__tstate);
8775 if (PyErr_Occurred()) SWIG_fail;
8776 }
8777 resultobj = SWIG_Py_Void();
8778 return resultobj;
8779 fail:
8780 return NULL;
8781 }
8782
8783
8784 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8785 PyObject *resultobj = 0;
8786 int result;
8787
8788 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8789 {
8790 PyThreadState* __tstate = wxPyBeginAllowThreads();
8791 result = (int)wxCaret::GetBlinkTime();
8792 wxPyEndAllowThreads(__tstate);
8793 if (PyErr_Occurred()) SWIG_fail;
8794 }
8795 resultobj = SWIG_From_int(static_cast< int >(result));
8796 return resultobj;
8797 fail:
8798 return NULL;
8799 }
8800
8801
8802 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8803 PyObject *resultobj = 0;
8804 int arg1 ;
8805 int val1 ;
8806 int ecode1 = 0 ;
8807 PyObject * obj0 = 0 ;
8808 char * kwnames[] = {
8809 (char *) "milliseconds", NULL
8810 };
8811
8812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8813 ecode1 = SWIG_AsVal_int(obj0, &val1);
8814 if (!SWIG_IsOK(ecode1)) {
8815 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8816 }
8817 arg1 = static_cast< int >(val1);
8818 {
8819 PyThreadState* __tstate = wxPyBeginAllowThreads();
8820 wxCaret::SetBlinkTime(arg1);
8821 wxPyEndAllowThreads(__tstate);
8822 if (PyErr_Occurred()) SWIG_fail;
8823 }
8824 resultobj = SWIG_Py_Void();
8825 return resultobj;
8826 fail:
8827 return NULL;
8828 }
8829
8830
8831 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8832 PyObject *obj;
8833 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8834 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8835 return SWIG_Py_Void();
8836 }
8837
8838 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8839 return SWIG_Python_InitShadowInstance(args);
8840 }
8841
8842 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8843 PyObject *resultobj = 0;
8844 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8845 wxBusyCursor *result = 0 ;
8846 void *argp1 = 0 ;
8847 int res1 = 0 ;
8848 PyObject * obj0 = 0 ;
8849 char * kwnames[] = {
8850 (char *) "cursor", NULL
8851 };
8852
8853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
8854 if (obj0) {
8855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
8856 if (!SWIG_IsOK(res1)) {
8857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
8858 }
8859 arg1 = reinterpret_cast< wxCursor * >(argp1);
8860 }
8861 {
8862 if (!wxPyCheckForApp()) SWIG_fail;
8863 PyThreadState* __tstate = wxPyBeginAllowThreads();
8864 result = (wxBusyCursor *)new wxBusyCursor(arg1);
8865 wxPyEndAllowThreads(__tstate);
8866 if (PyErr_Occurred()) SWIG_fail;
8867 }
8868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
8869 return resultobj;
8870 fail:
8871 return NULL;
8872 }
8873
8874
8875 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8876 PyObject *resultobj = 0;
8877 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
8878 void *argp1 = 0 ;
8879 int res1 = 0 ;
8880 PyObject *swig_obj[1] ;
8881
8882 if (!args) SWIG_fail;
8883 swig_obj[0] = args;
8884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
8885 if (!SWIG_IsOK(res1)) {
8886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
8887 }
8888 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
8889 {
8890 PyThreadState* __tstate = wxPyBeginAllowThreads();
8891 delete arg1;
8892
8893 wxPyEndAllowThreads(__tstate);
8894 if (PyErr_Occurred()) SWIG_fail;
8895 }
8896 resultobj = SWIG_Py_Void();
8897 return resultobj;
8898 fail:
8899 return NULL;
8900 }
8901
8902
8903 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8904 PyObject *obj;
8905 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8906 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
8907 return SWIG_Py_Void();
8908 }
8909
8910 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8911 return SWIG_Python_InitShadowInstance(args);
8912 }
8913
8914 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8915 PyObject *resultobj = 0;
8916 wxWindow *arg1 = (wxWindow *) NULL ;
8917 wxWindowDisabler *result = 0 ;
8918 void *argp1 = 0 ;
8919 int res1 = 0 ;
8920 PyObject * obj0 = 0 ;
8921 char * kwnames[] = {
8922 (char *) "winToSkip", NULL
8923 };
8924
8925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
8926 if (obj0) {
8927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8928 if (!SWIG_IsOK(res1)) {
8929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
8930 }
8931 arg1 = reinterpret_cast< wxWindow * >(argp1);
8932 }
8933 {
8934 if (!wxPyCheckForApp()) SWIG_fail;
8935 PyThreadState* __tstate = wxPyBeginAllowThreads();
8936 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
8937 wxPyEndAllowThreads(__tstate);
8938 if (PyErr_Occurred()) SWIG_fail;
8939 }
8940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
8941 return resultobj;
8942 fail:
8943 return NULL;
8944 }
8945
8946
8947 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8948 PyObject *resultobj = 0;
8949 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
8950 void *argp1 = 0 ;
8951 int res1 = 0 ;
8952 PyObject *swig_obj[1] ;
8953
8954 if (!args) SWIG_fail;
8955 swig_obj[0] = args;
8956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
8957 if (!SWIG_IsOK(res1)) {
8958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
8959 }
8960 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
8961 {
8962 PyThreadState* __tstate = wxPyBeginAllowThreads();
8963 delete arg1;
8964
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 *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8976 PyObject *obj;
8977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8978 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
8979 return SWIG_Py_Void();
8980 }
8981
8982 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8983 return SWIG_Python_InitShadowInstance(args);
8984 }
8985
8986 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8987 PyObject *resultobj = 0;
8988 wxString *arg1 = 0 ;
8989 wxBusyInfo *result = 0 ;
8990 bool temp1 = false ;
8991 PyObject * obj0 = 0 ;
8992 char * kwnames[] = {
8993 (char *) "message", NULL
8994 };
8995
8996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
8997 {
8998 arg1 = wxString_in_helper(obj0);
8999 if (arg1 == NULL) SWIG_fail;
9000 temp1 = true;
9001 }
9002 {
9003 if (!wxPyCheckForApp()) SWIG_fail;
9004 PyThreadState* __tstate = wxPyBeginAllowThreads();
9005 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9006 wxPyEndAllowThreads(__tstate);
9007 if (PyErr_Occurred()) SWIG_fail;
9008 }
9009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9010 {
9011 if (temp1)
9012 delete arg1;
9013 }
9014 return resultobj;
9015 fail:
9016 {
9017 if (temp1)
9018 delete arg1;
9019 }
9020 return NULL;
9021 }
9022
9023
9024 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9025 PyObject *resultobj = 0;
9026 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9027 void *argp1 = 0 ;
9028 int res1 = 0 ;
9029 PyObject *swig_obj[1] ;
9030
9031 if (!args) SWIG_fail;
9032 swig_obj[0] = args;
9033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9034 if (!SWIG_IsOK(res1)) {
9035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9036 }
9037 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9038 {
9039 PyThreadState* __tstate = wxPyBeginAllowThreads();
9040 delete arg1;
9041
9042 wxPyEndAllowThreads(__tstate);
9043 if (PyErr_Occurred()) SWIG_fail;
9044 }
9045 resultobj = SWIG_Py_Void();
9046 return resultobj;
9047 fail:
9048 return NULL;
9049 }
9050
9051
9052 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9053 PyObject *obj;
9054 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9055 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9056 return SWIG_Py_Void();
9057 }
9058
9059 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9060 return SWIG_Python_InitShadowInstance(args);
9061 }
9062
9063 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9064 PyObject *resultobj = 0;
9065 wxStopWatch *result = 0 ;
9066
9067 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9068 {
9069 PyThreadState* __tstate = wxPyBeginAllowThreads();
9070 result = (wxStopWatch *)new wxStopWatch();
9071 wxPyEndAllowThreads(__tstate);
9072 if (PyErr_Occurred()) SWIG_fail;
9073 }
9074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9075 return resultobj;
9076 fail:
9077 return NULL;
9078 }
9079
9080
9081 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9082 PyObject *resultobj = 0;
9083 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9084 long arg2 = (long) 0 ;
9085 void *argp1 = 0 ;
9086 int res1 = 0 ;
9087 long val2 ;
9088 int ecode2 = 0 ;
9089 PyObject * obj0 = 0 ;
9090 PyObject * obj1 = 0 ;
9091 char * kwnames[] = {
9092 (char *) "self",(char *) "t0", NULL
9093 };
9094
9095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9097 if (!SWIG_IsOK(res1)) {
9098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9099 }
9100 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9101 if (obj1) {
9102 ecode2 = SWIG_AsVal_long(obj1, &val2);
9103 if (!SWIG_IsOK(ecode2)) {
9104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9105 }
9106 arg2 = static_cast< long >(val2);
9107 }
9108 {
9109 PyThreadState* __tstate = wxPyBeginAllowThreads();
9110 (arg1)->Start(arg2);
9111 wxPyEndAllowThreads(__tstate);
9112 if (PyErr_Occurred()) SWIG_fail;
9113 }
9114 resultobj = SWIG_Py_Void();
9115 return resultobj;
9116 fail:
9117 return NULL;
9118 }
9119
9120
9121 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9122 PyObject *resultobj = 0;
9123 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9124 void *argp1 = 0 ;
9125 int res1 = 0 ;
9126 PyObject *swig_obj[1] ;
9127
9128 if (!args) SWIG_fail;
9129 swig_obj[0] = args;
9130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9131 if (!SWIG_IsOK(res1)) {
9132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9133 }
9134 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9135 {
9136 PyThreadState* __tstate = wxPyBeginAllowThreads();
9137 (arg1)->Pause();
9138 wxPyEndAllowThreads(__tstate);
9139 if (PyErr_Occurred()) SWIG_fail;
9140 }
9141 resultobj = SWIG_Py_Void();
9142 return resultobj;
9143 fail:
9144 return NULL;
9145 }
9146
9147
9148 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9149 PyObject *resultobj = 0;
9150 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9151 void *argp1 = 0 ;
9152 int res1 = 0 ;
9153 PyObject *swig_obj[1] ;
9154
9155 if (!args) SWIG_fail;
9156 swig_obj[0] = args;
9157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9158 if (!SWIG_IsOK(res1)) {
9159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9160 }
9161 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9162 {
9163 PyThreadState* __tstate = wxPyBeginAllowThreads();
9164 (arg1)->Resume();
9165 wxPyEndAllowThreads(__tstate);
9166 if (PyErr_Occurred()) SWIG_fail;
9167 }
9168 resultobj = SWIG_Py_Void();
9169 return resultobj;
9170 fail:
9171 return NULL;
9172 }
9173
9174
9175 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9176 PyObject *resultobj = 0;
9177 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9178 long result;
9179 void *argp1 = 0 ;
9180 int res1 = 0 ;
9181 PyObject *swig_obj[1] ;
9182
9183 if (!args) SWIG_fail;
9184 swig_obj[0] = args;
9185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9186 if (!SWIG_IsOK(res1)) {
9187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9188 }
9189 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9190 {
9191 PyThreadState* __tstate = wxPyBeginAllowThreads();
9192 result = (long)((wxStopWatch const *)arg1)->Time();
9193 wxPyEndAllowThreads(__tstate);
9194 if (PyErr_Occurred()) SWIG_fail;
9195 }
9196 resultobj = SWIG_From_long(static_cast< long >(result));
9197 return resultobj;
9198 fail:
9199 return NULL;
9200 }
9201
9202
9203 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9204 PyObject *obj;
9205 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9206 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9207 return SWIG_Py_Void();
9208 }
9209
9210 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9211 return SWIG_Python_InitShadowInstance(args);
9212 }
9213
9214 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9215 PyObject *resultobj = 0;
9216 int arg1 = (int) 9 ;
9217 int arg2 = (int) wxID_FILE1 ;
9218 wxFileHistory *result = 0 ;
9219 int val1 ;
9220 int ecode1 = 0 ;
9221 int val2 ;
9222 int ecode2 = 0 ;
9223 PyObject * obj0 = 0 ;
9224 PyObject * obj1 = 0 ;
9225 char * kwnames[] = {
9226 (char *) "maxFiles",(char *) "idBase", NULL
9227 };
9228
9229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9230 if (obj0) {
9231 ecode1 = SWIG_AsVal_int(obj0, &val1);
9232 if (!SWIG_IsOK(ecode1)) {
9233 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9234 }
9235 arg1 = static_cast< int >(val1);
9236 }
9237 if (obj1) {
9238 ecode2 = SWIG_AsVal_int(obj1, &val2);
9239 if (!SWIG_IsOK(ecode2)) {
9240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9241 }
9242 arg2 = static_cast< int >(val2);
9243 }
9244 {
9245 PyThreadState* __tstate = wxPyBeginAllowThreads();
9246 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9247 wxPyEndAllowThreads(__tstate);
9248 if (PyErr_Occurred()) SWIG_fail;
9249 }
9250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9251 return resultobj;
9252 fail:
9253 return NULL;
9254 }
9255
9256
9257 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9258 PyObject *resultobj = 0;
9259 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9260 void *argp1 = 0 ;
9261 int res1 = 0 ;
9262 PyObject *swig_obj[1] ;
9263
9264 if (!args) SWIG_fail;
9265 swig_obj[0] = args;
9266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9267 if (!SWIG_IsOK(res1)) {
9268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9269 }
9270 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9271 {
9272 PyThreadState* __tstate = wxPyBeginAllowThreads();
9273 delete arg1;
9274
9275 wxPyEndAllowThreads(__tstate);
9276 if (PyErr_Occurred()) SWIG_fail;
9277 }
9278 resultobj = SWIG_Py_Void();
9279 return resultobj;
9280 fail:
9281 return NULL;
9282 }
9283
9284
9285 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9286 PyObject *resultobj = 0;
9287 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9288 wxString *arg2 = 0 ;
9289 void *argp1 = 0 ;
9290 int res1 = 0 ;
9291 bool temp2 = false ;
9292 PyObject * obj0 = 0 ;
9293 PyObject * obj1 = 0 ;
9294 char * kwnames[] = {
9295 (char *) "self",(char *) "file", NULL
9296 };
9297
9298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9300 if (!SWIG_IsOK(res1)) {
9301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9302 }
9303 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9304 {
9305 arg2 = wxString_in_helper(obj1);
9306 if (arg2 == NULL) SWIG_fail;
9307 temp2 = true;
9308 }
9309 {
9310 PyThreadState* __tstate = wxPyBeginAllowThreads();
9311 (arg1)->AddFileToHistory((wxString const &)*arg2);
9312 wxPyEndAllowThreads(__tstate);
9313 if (PyErr_Occurred()) SWIG_fail;
9314 }
9315 resultobj = SWIG_Py_Void();
9316 {
9317 if (temp2)
9318 delete arg2;
9319 }
9320 return resultobj;
9321 fail:
9322 {
9323 if (temp2)
9324 delete arg2;
9325 }
9326 return NULL;
9327 }
9328
9329
9330 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9331 PyObject *resultobj = 0;
9332 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9333 int arg2 ;
9334 void *argp1 = 0 ;
9335 int res1 = 0 ;
9336 int val2 ;
9337 int ecode2 = 0 ;
9338 PyObject * obj0 = 0 ;
9339 PyObject * obj1 = 0 ;
9340 char * kwnames[] = {
9341 (char *) "self",(char *) "i", NULL
9342 };
9343
9344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9346 if (!SWIG_IsOK(res1)) {
9347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9348 }
9349 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9350 ecode2 = SWIG_AsVal_int(obj1, &val2);
9351 if (!SWIG_IsOK(ecode2)) {
9352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9353 }
9354 arg2 = static_cast< int >(val2);
9355 {
9356 PyThreadState* __tstate = wxPyBeginAllowThreads();
9357 (arg1)->RemoveFileFromHistory(arg2);
9358 wxPyEndAllowThreads(__tstate);
9359 if (PyErr_Occurred()) SWIG_fail;
9360 }
9361 resultobj = SWIG_Py_Void();
9362 return resultobj;
9363 fail:
9364 return NULL;
9365 }
9366
9367
9368 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9369 PyObject *resultobj = 0;
9370 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9371 int result;
9372 void *argp1 = 0 ;
9373 int res1 = 0 ;
9374 PyObject *swig_obj[1] ;
9375
9376 if (!args) SWIG_fail;
9377 swig_obj[0] = args;
9378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9379 if (!SWIG_IsOK(res1)) {
9380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9381 }
9382 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9383 {
9384 PyThreadState* __tstate = wxPyBeginAllowThreads();
9385 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9386 wxPyEndAllowThreads(__tstate);
9387 if (PyErr_Occurred()) SWIG_fail;
9388 }
9389 resultobj = SWIG_From_int(static_cast< int >(result));
9390 return resultobj;
9391 fail:
9392 return NULL;
9393 }
9394
9395
9396 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9397 PyObject *resultobj = 0;
9398 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9399 wxMenu *arg2 = (wxMenu *) 0 ;
9400 void *argp1 = 0 ;
9401 int res1 = 0 ;
9402 void *argp2 = 0 ;
9403 int res2 = 0 ;
9404 PyObject * obj0 = 0 ;
9405 PyObject * obj1 = 0 ;
9406 char * kwnames[] = {
9407 (char *) "self",(char *) "menu", NULL
9408 };
9409
9410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9412 if (!SWIG_IsOK(res1)) {
9413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9414 }
9415 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9416 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9417 if (!SWIG_IsOK(res2)) {
9418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9419 }
9420 arg2 = reinterpret_cast< wxMenu * >(argp2);
9421 {
9422 PyThreadState* __tstate = wxPyBeginAllowThreads();
9423 (arg1)->UseMenu(arg2);
9424 wxPyEndAllowThreads(__tstate);
9425 if (PyErr_Occurred()) SWIG_fail;
9426 }
9427 resultobj = SWIG_Py_Void();
9428 return resultobj;
9429 fail:
9430 return NULL;
9431 }
9432
9433
9434 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9435 PyObject *resultobj = 0;
9436 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9437 wxMenu *arg2 = (wxMenu *) 0 ;
9438 void *argp1 = 0 ;
9439 int res1 = 0 ;
9440 void *argp2 = 0 ;
9441 int res2 = 0 ;
9442 PyObject * obj0 = 0 ;
9443 PyObject * obj1 = 0 ;
9444 char * kwnames[] = {
9445 (char *) "self",(char *) "menu", NULL
9446 };
9447
9448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9450 if (!SWIG_IsOK(res1)) {
9451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9452 }
9453 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9454 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9455 if (!SWIG_IsOK(res2)) {
9456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9457 }
9458 arg2 = reinterpret_cast< wxMenu * >(argp2);
9459 {
9460 PyThreadState* __tstate = wxPyBeginAllowThreads();
9461 (arg1)->RemoveMenu(arg2);
9462 wxPyEndAllowThreads(__tstate);
9463 if (PyErr_Occurred()) SWIG_fail;
9464 }
9465 resultobj = SWIG_Py_Void();
9466 return resultobj;
9467 fail:
9468 return NULL;
9469 }
9470
9471
9472 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9473 PyObject *resultobj = 0;
9474 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9475 wxConfigBase *arg2 = 0 ;
9476 void *argp1 = 0 ;
9477 int res1 = 0 ;
9478 void *argp2 = 0 ;
9479 int res2 = 0 ;
9480 PyObject * obj0 = 0 ;
9481 PyObject * obj1 = 0 ;
9482 char * kwnames[] = {
9483 (char *) "self",(char *) "config", NULL
9484 };
9485
9486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9488 if (!SWIG_IsOK(res1)) {
9489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9490 }
9491 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9492 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9493 if (!SWIG_IsOK(res2)) {
9494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9495 }
9496 if (!argp2) {
9497 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9498 }
9499 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9500 {
9501 PyThreadState* __tstate = wxPyBeginAllowThreads();
9502 (arg1)->Load(*arg2);
9503 wxPyEndAllowThreads(__tstate);
9504 if (PyErr_Occurred()) SWIG_fail;
9505 }
9506 resultobj = SWIG_Py_Void();
9507 return resultobj;
9508 fail:
9509 return NULL;
9510 }
9511
9512
9513 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9514 PyObject *resultobj = 0;
9515 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9516 wxConfigBase *arg2 = 0 ;
9517 void *argp1 = 0 ;
9518 int res1 = 0 ;
9519 void *argp2 = 0 ;
9520 int res2 = 0 ;
9521 PyObject * obj0 = 0 ;
9522 PyObject * obj1 = 0 ;
9523 char * kwnames[] = {
9524 (char *) "self",(char *) "config", NULL
9525 };
9526
9527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9529 if (!SWIG_IsOK(res1)) {
9530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9531 }
9532 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9533 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9534 if (!SWIG_IsOK(res2)) {
9535 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9536 }
9537 if (!argp2) {
9538 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9539 }
9540 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9541 {
9542 PyThreadState* __tstate = wxPyBeginAllowThreads();
9543 (arg1)->Save(*arg2);
9544 wxPyEndAllowThreads(__tstate);
9545 if (PyErr_Occurred()) SWIG_fail;
9546 }
9547 resultobj = SWIG_Py_Void();
9548 return resultobj;
9549 fail:
9550 return NULL;
9551 }
9552
9553
9554 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9555 PyObject *resultobj = 0;
9556 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9557 void *argp1 = 0 ;
9558 int res1 = 0 ;
9559 PyObject *swig_obj[1] ;
9560
9561 if (!args) SWIG_fail;
9562 swig_obj[0] = args;
9563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9564 if (!SWIG_IsOK(res1)) {
9565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9566 }
9567 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9568 {
9569 PyThreadState* __tstate = wxPyBeginAllowThreads();
9570 (arg1)->AddFilesToMenu();
9571 wxPyEndAllowThreads(__tstate);
9572 if (PyErr_Occurred()) SWIG_fail;
9573 }
9574 resultobj = SWIG_Py_Void();
9575 return resultobj;
9576 fail:
9577 return NULL;
9578 }
9579
9580
9581 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9582 PyObject *resultobj = 0;
9583 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9584 wxMenu *arg2 = (wxMenu *) 0 ;
9585 void *argp1 = 0 ;
9586 int res1 = 0 ;
9587 void *argp2 = 0 ;
9588 int res2 = 0 ;
9589 PyObject * obj0 = 0 ;
9590 PyObject * obj1 = 0 ;
9591 char * kwnames[] = {
9592 (char *) "self",(char *) "menu", NULL
9593 };
9594
9595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9597 if (!SWIG_IsOK(res1)) {
9598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9599 }
9600 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9601 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9602 if (!SWIG_IsOK(res2)) {
9603 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9604 }
9605 arg2 = reinterpret_cast< wxMenu * >(argp2);
9606 {
9607 PyThreadState* __tstate = wxPyBeginAllowThreads();
9608 (arg1)->AddFilesToMenu(arg2);
9609 wxPyEndAllowThreads(__tstate);
9610 if (PyErr_Occurred()) SWIG_fail;
9611 }
9612 resultobj = SWIG_Py_Void();
9613 return resultobj;
9614 fail:
9615 return NULL;
9616 }
9617
9618
9619 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9620 PyObject *resultobj = 0;
9621 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9622 int arg2 ;
9623 wxString result;
9624 void *argp1 = 0 ;
9625 int res1 = 0 ;
9626 int val2 ;
9627 int ecode2 = 0 ;
9628 PyObject * obj0 = 0 ;
9629 PyObject * obj1 = 0 ;
9630 char * kwnames[] = {
9631 (char *) "self",(char *) "i", NULL
9632 };
9633
9634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9636 if (!SWIG_IsOK(res1)) {
9637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9638 }
9639 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9640 ecode2 = SWIG_AsVal_int(obj1, &val2);
9641 if (!SWIG_IsOK(ecode2)) {
9642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9643 }
9644 arg2 = static_cast< int >(val2);
9645 {
9646 PyThreadState* __tstate = wxPyBeginAllowThreads();
9647 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9648 wxPyEndAllowThreads(__tstate);
9649 if (PyErr_Occurred()) SWIG_fail;
9650 }
9651 {
9652 #if wxUSE_UNICODE
9653 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9654 #else
9655 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9656 #endif
9657 }
9658 return resultobj;
9659 fail:
9660 return NULL;
9661 }
9662
9663
9664 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9665 PyObject *resultobj = 0;
9666 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9667 int result;
9668 void *argp1 = 0 ;
9669 int res1 = 0 ;
9670 PyObject *swig_obj[1] ;
9671
9672 if (!args) SWIG_fail;
9673 swig_obj[0] = args;
9674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9675 if (!SWIG_IsOK(res1)) {
9676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9677 }
9678 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9679 {
9680 PyThreadState* __tstate = wxPyBeginAllowThreads();
9681 result = (int)((wxFileHistory const *)arg1)->GetCount();
9682 wxPyEndAllowThreads(__tstate);
9683 if (PyErr_Occurred()) SWIG_fail;
9684 }
9685 resultobj = SWIG_From_int(static_cast< int >(result));
9686 return resultobj;
9687 fail:
9688 return NULL;
9689 }
9690
9691
9692 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9693 PyObject *obj;
9694 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9695 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9696 return SWIG_Py_Void();
9697 }
9698
9699 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9700 return SWIG_Python_InitShadowInstance(args);
9701 }
9702
9703 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9704 PyObject *resultobj = 0;
9705 wxString *arg1 = 0 ;
9706 wxString const &arg2_defvalue = wxPyEmptyString ;
9707 wxString *arg2 = (wxString *) &arg2_defvalue ;
9708 wxSingleInstanceChecker *result = 0 ;
9709 bool temp1 = false ;
9710 bool temp2 = false ;
9711 PyObject * obj0 = 0 ;
9712 PyObject * obj1 = 0 ;
9713 char * kwnames[] = {
9714 (char *) "name",(char *) "path", NULL
9715 };
9716
9717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9718 {
9719 arg1 = wxString_in_helper(obj0);
9720 if (arg1 == NULL) SWIG_fail;
9721 temp1 = true;
9722 }
9723 if (obj1) {
9724 {
9725 arg2 = wxString_in_helper(obj1);
9726 if (arg2 == NULL) SWIG_fail;
9727 temp2 = true;
9728 }
9729 }
9730 {
9731 PyThreadState* __tstate = wxPyBeginAllowThreads();
9732 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9733 wxPyEndAllowThreads(__tstate);
9734 if (PyErr_Occurred()) SWIG_fail;
9735 }
9736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9737 {
9738 if (temp1)
9739 delete arg1;
9740 }
9741 {
9742 if (temp2)
9743 delete arg2;
9744 }
9745 return resultobj;
9746 fail:
9747 {
9748 if (temp1)
9749 delete arg1;
9750 }
9751 {
9752 if (temp2)
9753 delete arg2;
9754 }
9755 return NULL;
9756 }
9757
9758
9759 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9760 PyObject *resultobj = 0;
9761 wxSingleInstanceChecker *result = 0 ;
9762
9763 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9764 {
9765 PyThreadState* __tstate = wxPyBeginAllowThreads();
9766 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9767 wxPyEndAllowThreads(__tstate);
9768 if (PyErr_Occurred()) SWIG_fail;
9769 }
9770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9771 return resultobj;
9772 fail:
9773 return NULL;
9774 }
9775
9776
9777 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9778 PyObject *resultobj = 0;
9779 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9780 void *argp1 = 0 ;
9781 int res1 = 0 ;
9782 PyObject *swig_obj[1] ;
9783
9784 if (!args) SWIG_fail;
9785 swig_obj[0] = args;
9786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9787 if (!SWIG_IsOK(res1)) {
9788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9789 }
9790 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9791 {
9792 PyThreadState* __tstate = wxPyBeginAllowThreads();
9793 delete arg1;
9794
9795 wxPyEndAllowThreads(__tstate);
9796 if (PyErr_Occurred()) SWIG_fail;
9797 }
9798 resultobj = SWIG_Py_Void();
9799 return resultobj;
9800 fail:
9801 return NULL;
9802 }
9803
9804
9805 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9806 PyObject *resultobj = 0;
9807 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9808 wxString *arg2 = 0 ;
9809 wxString const &arg3_defvalue = wxPyEmptyString ;
9810 wxString *arg3 = (wxString *) &arg3_defvalue ;
9811 bool result;
9812 void *argp1 = 0 ;
9813 int res1 = 0 ;
9814 bool temp2 = false ;
9815 bool temp3 = false ;
9816 PyObject * obj0 = 0 ;
9817 PyObject * obj1 = 0 ;
9818 PyObject * obj2 = 0 ;
9819 char * kwnames[] = {
9820 (char *) "self",(char *) "name",(char *) "path", NULL
9821 };
9822
9823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9825 if (!SWIG_IsOK(res1)) {
9826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9827 }
9828 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9829 {
9830 arg2 = wxString_in_helper(obj1);
9831 if (arg2 == NULL) SWIG_fail;
9832 temp2 = true;
9833 }
9834 if (obj2) {
9835 {
9836 arg3 = wxString_in_helper(obj2);
9837 if (arg3 == NULL) SWIG_fail;
9838 temp3 = true;
9839 }
9840 }
9841 {
9842 PyThreadState* __tstate = wxPyBeginAllowThreads();
9843 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9844 wxPyEndAllowThreads(__tstate);
9845 if (PyErr_Occurred()) SWIG_fail;
9846 }
9847 {
9848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9849 }
9850 {
9851 if (temp2)
9852 delete arg2;
9853 }
9854 {
9855 if (temp3)
9856 delete arg3;
9857 }
9858 return resultobj;
9859 fail:
9860 {
9861 if (temp2)
9862 delete arg2;
9863 }
9864 {
9865 if (temp3)
9866 delete arg3;
9867 }
9868 return NULL;
9869 }
9870
9871
9872 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9873 PyObject *resultobj = 0;
9874 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9875 bool result;
9876 void *argp1 = 0 ;
9877 int res1 = 0 ;
9878 PyObject *swig_obj[1] ;
9879
9880 if (!args) SWIG_fail;
9881 swig_obj[0] = args;
9882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9883 if (!SWIG_IsOK(res1)) {
9884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
9885 }
9886 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9887 {
9888 PyThreadState* __tstate = wxPyBeginAllowThreads();
9889 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
9890 wxPyEndAllowThreads(__tstate);
9891 if (PyErr_Occurred()) SWIG_fail;
9892 }
9893 {
9894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9895 }
9896 return resultobj;
9897 fail:
9898 return NULL;
9899 }
9900
9901
9902 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9903 PyObject *obj;
9904 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9905 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
9906 return SWIG_Py_Void();
9907 }
9908
9909 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9910 return SWIG_Python_InitShadowInstance(args);
9911 }
9912
9913 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9914 PyObject *resultobj = 0;
9915 wxWindow *arg1 = (wxWindow *) 0 ;
9916 wxDC *arg2 = 0 ;
9917 bool result;
9918 void *argp1 = 0 ;
9919 int res1 = 0 ;
9920 void *argp2 = 0 ;
9921 int res2 = 0 ;
9922 PyObject * obj0 = 0 ;
9923 PyObject * obj1 = 0 ;
9924 char * kwnames[] = {
9925 (char *) "window",(char *) "dc", NULL
9926 };
9927
9928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
9929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9930 if (!SWIG_IsOK(res1)) {
9931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
9932 }
9933 arg1 = reinterpret_cast< wxWindow * >(argp1);
9934 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
9935 if (!SWIG_IsOK(res2)) {
9936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9937 }
9938 if (!argp2) {
9939 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9940 }
9941 arg2 = reinterpret_cast< wxDC * >(argp2);
9942 {
9943 PyThreadState* __tstate = wxPyBeginAllowThreads();
9944 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
9945 wxPyEndAllowThreads(__tstate);
9946 if (PyErr_Occurred()) SWIG_fail;
9947 }
9948 {
9949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9950 }
9951 return resultobj;
9952 fail:
9953 return NULL;
9954 }
9955
9956
9957 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9958 PyObject *resultobj = 0;
9959 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9960 void *argp1 = 0 ;
9961 int res1 = 0 ;
9962 PyObject *swig_obj[1] ;
9963
9964 if (!args) SWIG_fail;
9965 swig_obj[0] = args;
9966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
9967 if (!SWIG_IsOK(res1)) {
9968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9969 }
9970 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9971 {
9972 PyThreadState* __tstate = wxPyBeginAllowThreads();
9973 delete arg1;
9974
9975 wxPyEndAllowThreads(__tstate);
9976 if (PyErr_Occurred()) SWIG_fail;
9977 }
9978 resultobj = SWIG_Py_Void();
9979 return resultobj;
9980 fail:
9981 return NULL;
9982 }
9983
9984
9985 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9986 PyObject *resultobj = 0;
9987 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9988 wxString result;
9989 void *argp1 = 0 ;
9990 int res1 = 0 ;
9991 PyObject *swig_obj[1] ;
9992
9993 if (!args) SWIG_fail;
9994 swig_obj[0] = args;
9995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
9996 if (!SWIG_IsOK(res1)) {
9997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9998 }
9999 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10000 {
10001 PyThreadState* __tstate = wxPyBeginAllowThreads();
10002 result = (arg1)->GetTip();
10003 wxPyEndAllowThreads(__tstate);
10004 if (PyErr_Occurred()) SWIG_fail;
10005 }
10006 {
10007 #if wxUSE_UNICODE
10008 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10009 #else
10010 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10011 #endif
10012 }
10013 return resultobj;
10014 fail:
10015 return NULL;
10016 }
10017
10018
10019 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10020 PyObject *resultobj = 0;
10021 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10022 size_t result;
10023 void *argp1 = 0 ;
10024 int res1 = 0 ;
10025 PyObject *swig_obj[1] ;
10026
10027 if (!args) SWIG_fail;
10028 swig_obj[0] = args;
10029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10030 if (!SWIG_IsOK(res1)) {
10031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10032 }
10033 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10034 {
10035 PyThreadState* __tstate = wxPyBeginAllowThreads();
10036 result = (size_t)(arg1)->GetCurrentTip();
10037 wxPyEndAllowThreads(__tstate);
10038 if (PyErr_Occurred()) SWIG_fail;
10039 }
10040 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10041 return resultobj;
10042 fail:
10043 return NULL;
10044 }
10045
10046
10047 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10048 PyObject *resultobj = 0;
10049 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10050 wxString *arg2 = 0 ;
10051 wxString result;
10052 void *argp1 = 0 ;
10053 int res1 = 0 ;
10054 bool temp2 = false ;
10055 PyObject * obj0 = 0 ;
10056 PyObject * obj1 = 0 ;
10057 char * kwnames[] = {
10058 (char *) "self",(char *) "tip", NULL
10059 };
10060
10061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
10062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10063 if (!SWIG_IsOK(res1)) {
10064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10065 }
10066 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10067 {
10068 arg2 = wxString_in_helper(obj1);
10069 if (arg2 == NULL) SWIG_fail;
10070 temp2 = true;
10071 }
10072 {
10073 PyThreadState* __tstate = wxPyBeginAllowThreads();
10074 result = (arg1)->PreprocessTip((wxString const &)*arg2);
10075 wxPyEndAllowThreads(__tstate);
10076 if (PyErr_Occurred()) SWIG_fail;
10077 }
10078 {
10079 #if wxUSE_UNICODE
10080 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10081 #else
10082 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10083 #endif
10084 }
10085 {
10086 if (temp2)
10087 delete arg2;
10088 }
10089 return resultobj;
10090 fail:
10091 {
10092 if (temp2)
10093 delete arg2;
10094 }
10095 return NULL;
10096 }
10097
10098
10099 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10100 PyObject *obj;
10101 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10102 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
10103 return SWIG_Py_Void();
10104 }
10105
10106 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10107 PyObject *resultobj = 0;
10108 size_t arg1 ;
10109 wxPyTipProvider *result = 0 ;
10110 size_t val1 ;
10111 int ecode1 = 0 ;
10112 PyObject * obj0 = 0 ;
10113 char * kwnames[] = {
10114 (char *) "currentTip", NULL
10115 };
10116
10117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
10118 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10119 if (!SWIG_IsOK(ecode1)) {
10120 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
10121 }
10122 arg1 = static_cast< size_t >(val1);
10123 {
10124 PyThreadState* __tstate = wxPyBeginAllowThreads();
10125 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
10126 wxPyEndAllowThreads(__tstate);
10127 if (PyErr_Occurred()) SWIG_fail;
10128 }
10129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
10130 return resultobj;
10131 fail:
10132 return NULL;
10133 }
10134
10135
10136 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10137 PyObject *resultobj = 0;
10138 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
10139 PyObject *arg2 = (PyObject *) 0 ;
10140 PyObject *arg3 = (PyObject *) 0 ;
10141 void *argp1 = 0 ;
10142 int res1 = 0 ;
10143 PyObject * obj0 = 0 ;
10144 PyObject * obj1 = 0 ;
10145 PyObject * obj2 = 0 ;
10146 char * kwnames[] = {
10147 (char *) "self",(char *) "self",(char *) "_class", NULL
10148 };
10149
10150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
10152 if (!SWIG_IsOK(res1)) {
10153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
10154 }
10155 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
10156 arg2 = obj1;
10157 arg3 = obj2;
10158 {
10159 PyThreadState* __tstate = wxPyBeginAllowThreads();
10160 (arg1)->_setCallbackInfo(arg2,arg3);
10161 wxPyEndAllowThreads(__tstate);
10162 if (PyErr_Occurred()) SWIG_fail;
10163 }
10164 resultobj = SWIG_Py_Void();
10165 return resultobj;
10166 fail:
10167 return NULL;
10168 }
10169
10170
10171 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10172 PyObject *obj;
10173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10174 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
10175 return SWIG_Py_Void();
10176 }
10177
10178 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10179 return SWIG_Python_InitShadowInstance(args);
10180 }
10181
10182 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10183 PyObject *resultobj = 0;
10184 wxWindow *arg1 = (wxWindow *) 0 ;
10185 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
10186 bool arg3 = (bool) true ;
10187 bool result;
10188 void *argp1 = 0 ;
10189 int res1 = 0 ;
10190 void *argp2 = 0 ;
10191 int res2 = 0 ;
10192 bool val3 ;
10193 int ecode3 = 0 ;
10194 PyObject * obj0 = 0 ;
10195 PyObject * obj1 = 0 ;
10196 PyObject * obj2 = 0 ;
10197 char * kwnames[] = {
10198 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
10199 };
10200
10201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10203 if (!SWIG_IsOK(res1)) {
10204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
10205 }
10206 arg1 = reinterpret_cast< wxWindow * >(argp1);
10207 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10208 if (!SWIG_IsOK(res2)) {
10209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
10210 }
10211 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
10212 if (obj2) {
10213 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10214 if (!SWIG_IsOK(ecode3)) {
10215 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
10216 }
10217 arg3 = static_cast< bool >(val3);
10218 }
10219 {
10220 if (!wxPyCheckForApp()) SWIG_fail;
10221 PyThreadState* __tstate = wxPyBeginAllowThreads();
10222 result = (bool)wxShowTip(arg1,arg2,arg3);
10223 wxPyEndAllowThreads(__tstate);
10224 if (PyErr_Occurred()) SWIG_fail;
10225 }
10226 {
10227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10228 }
10229 return resultobj;
10230 fail:
10231 return NULL;
10232 }
10233
10234
10235 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10236 PyObject *resultobj = 0;
10237 wxString *arg1 = 0 ;
10238 size_t arg2 ;
10239 wxTipProvider *result = 0 ;
10240 bool temp1 = false ;
10241 size_t val2 ;
10242 int ecode2 = 0 ;
10243 PyObject * obj0 = 0 ;
10244 PyObject * obj1 = 0 ;
10245 char * kwnames[] = {
10246 (char *) "filename",(char *) "currentTip", NULL
10247 };
10248
10249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
10250 {
10251 arg1 = wxString_in_helper(obj0);
10252 if (arg1 == NULL) SWIG_fail;
10253 temp1 = true;
10254 }
10255 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10256 if (!SWIG_IsOK(ecode2)) {
10257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
10258 }
10259 arg2 = static_cast< size_t >(val2);
10260 {
10261 if (!wxPyCheckForApp()) SWIG_fail;
10262 PyThreadState* __tstate = wxPyBeginAllowThreads();
10263 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
10264 wxPyEndAllowThreads(__tstate);
10265 if (PyErr_Occurred()) SWIG_fail;
10266 }
10267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
10268 {
10269 if (temp1)
10270 delete arg1;
10271 }
10272 return resultobj;
10273 fail:
10274 {
10275 if (temp1)
10276 delete arg1;
10277 }
10278 return NULL;
10279 }
10280
10281
10282 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10283 PyObject *resultobj = 0;
10284 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10285 int arg2 = (int) wxID_ANY ;
10286 wxPyTimer *result = 0 ;
10287 void *argp1 = 0 ;
10288 int res1 = 0 ;
10289 int val2 ;
10290 int ecode2 = 0 ;
10291 PyObject * obj0 = 0 ;
10292 PyObject * obj1 = 0 ;
10293 char * kwnames[] = {
10294 (char *) "owner",(char *) "id", NULL
10295 };
10296
10297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
10298 if (obj0) {
10299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10300 if (!SWIG_IsOK(res1)) {
10301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
10302 }
10303 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
10304 }
10305 if (obj1) {
10306 ecode2 = SWIG_AsVal_int(obj1, &val2);
10307 if (!SWIG_IsOK(ecode2)) {
10308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
10309 }
10310 arg2 = static_cast< int >(val2);
10311 }
10312 {
10313 if (!wxPyCheckForApp()) SWIG_fail;
10314 PyThreadState* __tstate = wxPyBeginAllowThreads();
10315 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
10316 wxPyEndAllowThreads(__tstate);
10317 if (PyErr_Occurred()) SWIG_fail;
10318 }
10319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
10320 return resultobj;
10321 fail:
10322 return NULL;
10323 }
10324
10325
10326 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10327 PyObject *resultobj = 0;
10328 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10329 void *argp1 = 0 ;
10330 int res1 = 0 ;
10331 PyObject *swig_obj[1] ;
10332
10333 if (!args) SWIG_fail;
10334 swig_obj[0] = args;
10335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
10336 if (!SWIG_IsOK(res1)) {
10337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10338 }
10339 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10340 {
10341 PyThreadState* __tstate = wxPyBeginAllowThreads();
10342 delete arg1;
10343
10344 wxPyEndAllowThreads(__tstate);
10345 if (PyErr_Occurred()) SWIG_fail;
10346 }
10347 resultobj = SWIG_Py_Void();
10348 return resultobj;
10349 fail:
10350 return NULL;
10351 }
10352
10353
10354 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10355 PyObject *resultobj = 0;
10356 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10357 PyObject *arg2 = (PyObject *) 0 ;
10358 PyObject *arg3 = (PyObject *) 0 ;
10359 int arg4 = (int) 1 ;
10360 void *argp1 = 0 ;
10361 int res1 = 0 ;
10362 int val4 ;
10363 int ecode4 = 0 ;
10364 PyObject * obj0 = 0 ;
10365 PyObject * obj1 = 0 ;
10366 PyObject * obj2 = 0 ;
10367 PyObject * obj3 = 0 ;
10368 char * kwnames[] = {
10369 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10370 };
10371
10372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10374 if (!SWIG_IsOK(res1)) {
10375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10376 }
10377 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10378 arg2 = obj1;
10379 arg3 = obj2;
10380 if (obj3) {
10381 ecode4 = SWIG_AsVal_int(obj3, &val4);
10382 if (!SWIG_IsOK(ecode4)) {
10383 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
10384 }
10385 arg4 = static_cast< int >(val4);
10386 }
10387 {
10388 PyThreadState* __tstate = wxPyBeginAllowThreads();
10389 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10390 wxPyEndAllowThreads(__tstate);
10391 if (PyErr_Occurred()) SWIG_fail;
10392 }
10393 resultobj = SWIG_Py_Void();
10394 return resultobj;
10395 fail:
10396 return NULL;
10397 }
10398
10399
10400 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10401 PyObject *resultobj = 0;
10402 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10403 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
10404 int arg3 = (int) wxID_ANY ;
10405 void *argp1 = 0 ;
10406 int res1 = 0 ;
10407 void *argp2 = 0 ;
10408 int res2 = 0 ;
10409 int val3 ;
10410 int ecode3 = 0 ;
10411 PyObject * obj0 = 0 ;
10412 PyObject * obj1 = 0 ;
10413 PyObject * obj2 = 0 ;
10414 char * kwnames[] = {
10415 (char *) "self",(char *) "owner",(char *) "id", NULL
10416 };
10417
10418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10420 if (!SWIG_IsOK(res1)) {
10421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10422 }
10423 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10424 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10425 if (!SWIG_IsOK(res2)) {
10426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
10427 }
10428 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
10429 if (obj2) {
10430 ecode3 = SWIG_AsVal_int(obj2, &val3);
10431 if (!SWIG_IsOK(ecode3)) {
10432 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
10433 }
10434 arg3 = static_cast< int >(val3);
10435 }
10436 {
10437 PyThreadState* __tstate = wxPyBeginAllowThreads();
10438 (arg1)->SetOwner(arg2,arg3);
10439 wxPyEndAllowThreads(__tstate);
10440 if (PyErr_Occurred()) SWIG_fail;
10441 }
10442 resultobj = SWIG_Py_Void();
10443 return resultobj;
10444 fail:
10445 return NULL;
10446 }
10447
10448
10449 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10450 PyObject *resultobj = 0;
10451 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10452 wxEvtHandler *result = 0 ;
10453 void *argp1 = 0 ;
10454 int res1 = 0 ;
10455 PyObject *swig_obj[1] ;
10456
10457 if (!args) SWIG_fail;
10458 swig_obj[0] = args;
10459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10460 if (!SWIG_IsOK(res1)) {
10461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10462 }
10463 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10464 {
10465 PyThreadState* __tstate = wxPyBeginAllowThreads();
10466 result = (wxEvtHandler *)(arg1)->GetOwner();
10467 wxPyEndAllowThreads(__tstate);
10468 if (PyErr_Occurred()) SWIG_fail;
10469 }
10470 {
10471 resultobj = wxPyMake_wxObject(result, 0);
10472 }
10473 return resultobj;
10474 fail:
10475 return NULL;
10476 }
10477
10478
10479 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10480 PyObject *resultobj = 0;
10481 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10482 int arg2 = (int) -1 ;
10483 bool arg3 = (bool) false ;
10484 bool result;
10485 void *argp1 = 0 ;
10486 int res1 = 0 ;
10487 int val2 ;
10488 int ecode2 = 0 ;
10489 bool val3 ;
10490 int ecode3 = 0 ;
10491 PyObject * obj0 = 0 ;
10492 PyObject * obj1 = 0 ;
10493 PyObject * obj2 = 0 ;
10494 char * kwnames[] = {
10495 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
10496 };
10497
10498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10500 if (!SWIG_IsOK(res1)) {
10501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10502 }
10503 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10504 if (obj1) {
10505 ecode2 = SWIG_AsVal_int(obj1, &val2);
10506 if (!SWIG_IsOK(ecode2)) {
10507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
10508 }
10509 arg2 = static_cast< int >(val2);
10510 }
10511 if (obj2) {
10512 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10513 if (!SWIG_IsOK(ecode3)) {
10514 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
10515 }
10516 arg3 = static_cast< bool >(val3);
10517 }
10518 {
10519 PyThreadState* __tstate = wxPyBeginAllowThreads();
10520 result = (bool)(arg1)->Start(arg2,arg3);
10521 wxPyEndAllowThreads(__tstate);
10522 if (PyErr_Occurred()) SWIG_fail;
10523 }
10524 {
10525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10526 }
10527 return resultobj;
10528 fail:
10529 return NULL;
10530 }
10531
10532
10533 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10534 PyObject *resultobj = 0;
10535 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
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_wxPyTimer, 0 | 0 );
10543 if (!SWIG_IsOK(res1)) {
10544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10545 }
10546 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10547 {
10548 PyThreadState* __tstate = wxPyBeginAllowThreads();
10549 (arg1)->Stop();
10550 wxPyEndAllowThreads(__tstate);
10551 if (PyErr_Occurred()) SWIG_fail;
10552 }
10553 resultobj = SWIG_Py_Void();
10554 return resultobj;
10555 fail:
10556 return NULL;
10557 }
10558
10559
10560 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10561 PyObject *resultobj = 0;
10562 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10563 void *argp1 = 0 ;
10564 int res1 = 0 ;
10565 PyObject *swig_obj[1] ;
10566
10567 if (!args) SWIG_fail;
10568 swig_obj[0] = args;
10569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10570 if (!SWIG_IsOK(res1)) {
10571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10572 }
10573 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10574 {
10575 PyThreadState* __tstate = wxPyBeginAllowThreads();
10576 (arg1)->Notify();
10577 wxPyEndAllowThreads(__tstate);
10578 if (PyErr_Occurred()) SWIG_fail;
10579 }
10580 resultobj = SWIG_Py_Void();
10581 return resultobj;
10582 fail:
10583 return NULL;
10584 }
10585
10586
10587 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10588 PyObject *resultobj = 0;
10589 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10590 bool result;
10591 void *argp1 = 0 ;
10592 int res1 = 0 ;
10593 PyObject *swig_obj[1] ;
10594
10595 if (!args) SWIG_fail;
10596 swig_obj[0] = args;
10597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10598 if (!SWIG_IsOK(res1)) {
10599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10600 }
10601 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10602 {
10603 PyThreadState* __tstate = wxPyBeginAllowThreads();
10604 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
10605 wxPyEndAllowThreads(__tstate);
10606 if (PyErr_Occurred()) SWIG_fail;
10607 }
10608 {
10609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10610 }
10611 return resultobj;
10612 fail:
10613 return NULL;
10614 }
10615
10616
10617 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10618 PyObject *resultobj = 0;
10619 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10620 int result;
10621 void *argp1 = 0 ;
10622 int res1 = 0 ;
10623 PyObject *swig_obj[1] ;
10624
10625 if (!args) SWIG_fail;
10626 swig_obj[0] = args;
10627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10628 if (!SWIG_IsOK(res1)) {
10629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10630 }
10631 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10632 {
10633 PyThreadState* __tstate = wxPyBeginAllowThreads();
10634 result = (int)((wxPyTimer const *)arg1)->GetInterval();
10635 wxPyEndAllowThreads(__tstate);
10636 if (PyErr_Occurred()) SWIG_fail;
10637 }
10638 resultobj = SWIG_From_int(static_cast< int >(result));
10639 return resultobj;
10640 fail:
10641 return NULL;
10642 }
10643
10644
10645 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10646 PyObject *resultobj = 0;
10647 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10648 int result;
10649 void *argp1 = 0 ;
10650 int res1 = 0 ;
10651 PyObject *swig_obj[1] ;
10652
10653 if (!args) SWIG_fail;
10654 swig_obj[0] = args;
10655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10656 if (!SWIG_IsOK(res1)) {
10657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10658 }
10659 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10660 {
10661 PyThreadState* __tstate = wxPyBeginAllowThreads();
10662 result = (int)((wxPyTimer const *)arg1)->GetId();
10663 wxPyEndAllowThreads(__tstate);
10664 if (PyErr_Occurred()) SWIG_fail;
10665 }
10666 resultobj = SWIG_From_int(static_cast< int >(result));
10667 return resultobj;
10668 fail:
10669 return NULL;
10670 }
10671
10672
10673 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10674 PyObject *resultobj = 0;
10675 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10676 bool result;
10677 void *argp1 = 0 ;
10678 int res1 = 0 ;
10679 PyObject *swig_obj[1] ;
10680
10681 if (!args) SWIG_fail;
10682 swig_obj[0] = args;
10683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10684 if (!SWIG_IsOK(res1)) {
10685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10686 }
10687 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10688 {
10689 PyThreadState* __tstate = wxPyBeginAllowThreads();
10690 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
10691 wxPyEndAllowThreads(__tstate);
10692 if (PyErr_Occurred()) SWIG_fail;
10693 }
10694 {
10695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10696 }
10697 return resultobj;
10698 fail:
10699 return NULL;
10700 }
10701
10702
10703 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10704 PyObject *obj;
10705 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10706 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
10707 return SWIG_Py_Void();
10708 }
10709
10710 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10711 return SWIG_Python_InitShadowInstance(args);
10712 }
10713
10714 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10715 PyObject *resultobj = 0;
10716 int arg1 = (int) 0 ;
10717 int arg2 = (int) 0 ;
10718 wxTimerEvent *result = 0 ;
10719 int val1 ;
10720 int ecode1 = 0 ;
10721 int val2 ;
10722 int ecode2 = 0 ;
10723 PyObject * obj0 = 0 ;
10724 PyObject * obj1 = 0 ;
10725 char * kwnames[] = {
10726 (char *) "timerid",(char *) "interval", NULL
10727 };
10728
10729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
10730 if (obj0) {
10731 ecode1 = SWIG_AsVal_int(obj0, &val1);
10732 if (!SWIG_IsOK(ecode1)) {
10733 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
10734 }
10735 arg1 = static_cast< int >(val1);
10736 }
10737 if (obj1) {
10738 ecode2 = SWIG_AsVal_int(obj1, &val2);
10739 if (!SWIG_IsOK(ecode2)) {
10740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
10741 }
10742 arg2 = static_cast< int >(val2);
10743 }
10744 {
10745 PyThreadState* __tstate = wxPyBeginAllowThreads();
10746 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
10747 wxPyEndAllowThreads(__tstate);
10748 if (PyErr_Occurred()) SWIG_fail;
10749 }
10750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
10751 return resultobj;
10752 fail:
10753 return NULL;
10754 }
10755
10756
10757 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10758 PyObject *resultobj = 0;
10759 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
10760 int result;
10761 void *argp1 = 0 ;
10762 int res1 = 0 ;
10763 PyObject *swig_obj[1] ;
10764
10765 if (!args) SWIG_fail;
10766 swig_obj[0] = args;
10767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
10768 if (!SWIG_IsOK(res1)) {
10769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
10770 }
10771 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
10772 {
10773 PyThreadState* __tstate = wxPyBeginAllowThreads();
10774 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
10775 wxPyEndAllowThreads(__tstate);
10776 if (PyErr_Occurred()) SWIG_fail;
10777 }
10778 resultobj = SWIG_From_int(static_cast< int >(result));
10779 return resultobj;
10780 fail:
10781 return NULL;
10782 }
10783
10784
10785 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10786 PyObject *obj;
10787 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10788 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
10789 return SWIG_Py_Void();
10790 }
10791
10792 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10793 return SWIG_Python_InitShadowInstance(args);
10794 }
10795
10796 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10797 PyObject *resultobj = 0;
10798 wxTimer *arg1 = 0 ;
10799 wxTimerRunner *result = 0 ;
10800 void *argp1 = 0 ;
10801 int res1 = 0 ;
10802
10803 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
10804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10805 if (!SWIG_IsOK(res1)) {
10806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10807 }
10808 if (!argp1) {
10809 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10810 }
10811 arg1 = reinterpret_cast< wxTimer * >(argp1);
10812 {
10813 if (!wxPyCheckForApp()) SWIG_fail;
10814 PyThreadState* __tstate = wxPyBeginAllowThreads();
10815 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
10816 wxPyEndAllowThreads(__tstate);
10817 if (PyErr_Occurred()) SWIG_fail;
10818 }
10819 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10820 return resultobj;
10821 fail:
10822 return NULL;
10823 }
10824
10825
10826 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10827 PyObject *resultobj = 0;
10828 wxTimer *arg1 = 0 ;
10829 int arg2 ;
10830 bool arg3 = (bool) false ;
10831 wxTimerRunner *result = 0 ;
10832 void *argp1 = 0 ;
10833 int res1 = 0 ;
10834 int val2 ;
10835 int ecode2 = 0 ;
10836 bool val3 ;
10837 int ecode3 = 0 ;
10838
10839 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
10840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10841 if (!SWIG_IsOK(res1)) {
10842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10843 }
10844 if (!argp1) {
10845 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10846 }
10847 arg1 = reinterpret_cast< wxTimer * >(argp1);
10848 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10849 if (!SWIG_IsOK(ecode2)) {
10850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
10851 }
10852 arg2 = static_cast< int >(val2);
10853 if (swig_obj[2]) {
10854 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
10855 if (!SWIG_IsOK(ecode3)) {
10856 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
10857 }
10858 arg3 = static_cast< bool >(val3);
10859 }
10860 {
10861 if (!wxPyCheckForApp()) SWIG_fail;
10862 PyThreadState* __tstate = wxPyBeginAllowThreads();
10863 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
10864 wxPyEndAllowThreads(__tstate);
10865 if (PyErr_Occurred()) SWIG_fail;
10866 }
10867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10868 return resultobj;
10869 fail:
10870 return NULL;
10871 }
10872
10873
10874 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
10875 int argc;
10876 PyObject *argv[4];
10877
10878 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
10879 --argc;
10880 if (argc == 1) {
10881 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
10882 }
10883 if ((argc >= 2) && (argc <= 3)) {
10884 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
10885 }
10886
10887 fail:
10888 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
10889 return NULL;
10890 }
10891
10892
10893 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10894 PyObject *resultobj = 0;
10895 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10896 void *argp1 = 0 ;
10897 int res1 = 0 ;
10898 PyObject *swig_obj[1] ;
10899
10900 if (!args) SWIG_fail;
10901 swig_obj[0] = args;
10902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
10903 if (!SWIG_IsOK(res1)) {
10904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10905 }
10906 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10907 {
10908 PyThreadState* __tstate = wxPyBeginAllowThreads();
10909 delete arg1;
10910
10911 wxPyEndAllowThreads(__tstate);
10912 if (PyErr_Occurred()) SWIG_fail;
10913 }
10914 resultobj = SWIG_Py_Void();
10915 return resultobj;
10916 fail:
10917 return NULL;
10918 }
10919
10920
10921 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10922 PyObject *resultobj = 0;
10923 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10924 int arg2 ;
10925 bool arg3 = (bool) false ;
10926 void *argp1 = 0 ;
10927 int res1 = 0 ;
10928 int val2 ;
10929 int ecode2 = 0 ;
10930 bool val3 ;
10931 int ecode3 = 0 ;
10932 PyObject * obj0 = 0 ;
10933 PyObject * obj1 = 0 ;
10934 PyObject * obj2 = 0 ;
10935 char * kwnames[] = {
10936 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
10937 };
10938
10939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
10941 if (!SWIG_IsOK(res1)) {
10942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10943 }
10944 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10945 ecode2 = SWIG_AsVal_int(obj1, &val2);
10946 if (!SWIG_IsOK(ecode2)) {
10947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
10948 }
10949 arg2 = static_cast< int >(val2);
10950 if (obj2) {
10951 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10952 if (!SWIG_IsOK(ecode3)) {
10953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
10954 }
10955 arg3 = static_cast< bool >(val3);
10956 }
10957 {
10958 PyThreadState* __tstate = wxPyBeginAllowThreads();
10959 (arg1)->Start(arg2,arg3);
10960 wxPyEndAllowThreads(__tstate);
10961 if (PyErr_Occurred()) SWIG_fail;
10962 }
10963 resultobj = SWIG_Py_Void();
10964 return resultobj;
10965 fail:
10966 return NULL;
10967 }
10968
10969
10970 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10971 PyObject *obj;
10972 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10973 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
10974 return SWIG_Py_Void();
10975 }
10976
10977 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10978 return SWIG_Python_InitShadowInstance(args);
10979 }
10980
10981 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10982 PyObject *resultobj = 0;
10983 wxLog *result = 0 ;
10984
10985 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
10986 {
10987 PyThreadState* __tstate = wxPyBeginAllowThreads();
10988 result = (wxLog *)new wxLog();
10989 wxPyEndAllowThreads(__tstate);
10990 if (PyErr_Occurred()) SWIG_fail;
10991 }
10992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
10993 return resultobj;
10994 fail:
10995 return NULL;
10996 }
10997
10998
10999 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11000 PyObject *resultobj = 0;
11001 wxLog *arg1 = (wxLog *) 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_wxLog, SWIG_POINTER_DISOWN | 0 );
11009 if (!SWIG_IsOK(res1)) {
11010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
11011 }
11012 arg1 = reinterpret_cast< wxLog * >(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_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11028 PyObject *resultobj = 0;
11029 bool result;
11030
11031 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
11032 {
11033 PyThreadState* __tstate = wxPyBeginAllowThreads();
11034 result = (bool)wxLog::IsEnabled();
11035 wxPyEndAllowThreads(__tstate);
11036 if (PyErr_Occurred()) SWIG_fail;
11037 }
11038 {
11039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11040 }
11041 return resultobj;
11042 fail:
11043 return NULL;
11044 }
11045
11046
11047 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11048 PyObject *resultobj = 0;
11049 bool arg1 = (bool) true ;
11050 bool result;
11051 bool val1 ;
11052 int ecode1 = 0 ;
11053 PyObject * obj0 = 0 ;
11054 char * kwnames[] = {
11055 (char *) "doIt", NULL
11056 };
11057
11058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
11059 if (obj0) {
11060 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11061 if (!SWIG_IsOK(ecode1)) {
11062 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
11063 }
11064 arg1 = static_cast< bool >(val1);
11065 }
11066 {
11067 PyThreadState* __tstate = wxPyBeginAllowThreads();
11068 result = (bool)wxLog::EnableLogging(arg1);
11069 wxPyEndAllowThreads(__tstate);
11070 if (PyErr_Occurred()) SWIG_fail;
11071 }
11072 {
11073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11074 }
11075 return resultobj;
11076 fail:
11077 return NULL;
11078 }
11079
11080
11081 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11082 PyObject *resultobj = 0;
11083 wxLogLevel arg1 ;
11084 wxChar *arg2 = (wxChar *) 0 ;
11085 time_t arg3 ;
11086 unsigned long val1 ;
11087 int ecode1 = 0 ;
11088 void *argp2 = 0 ;
11089 int res2 = 0 ;
11090 unsigned int val3 ;
11091 int ecode3 = 0 ;
11092 PyObject * obj0 = 0 ;
11093 PyObject * obj1 = 0 ;
11094 PyObject * obj2 = 0 ;
11095 char * kwnames[] = {
11096 (char *) "level",(char *) "szString",(char *) "t", NULL
11097 };
11098
11099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11100 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11101 if (!SWIG_IsOK(ecode1)) {
11102 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
11103 }
11104 arg1 = static_cast< wxLogLevel >(val1);
11105 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
11106 if (!SWIG_IsOK(res2)) {
11107 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
11108 }
11109 arg2 = reinterpret_cast< wxChar * >(argp2);
11110 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
11111 if (!SWIG_IsOK(ecode3)) {
11112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
11113 }
11114 arg3 = static_cast< time_t >(val3);
11115 {
11116 PyThreadState* __tstate = wxPyBeginAllowThreads();
11117 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
11118 wxPyEndAllowThreads(__tstate);
11119 if (PyErr_Occurred()) SWIG_fail;
11120 }
11121 resultobj = SWIG_Py_Void();
11122 return resultobj;
11123 fail:
11124 return NULL;
11125 }
11126
11127
11128 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11129 PyObject *resultobj = 0;
11130 wxLog *arg1 = (wxLog *) 0 ;
11131 void *argp1 = 0 ;
11132 int res1 = 0 ;
11133 PyObject *swig_obj[1] ;
11134
11135 if (!args) SWIG_fail;
11136 swig_obj[0] = args;
11137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11138 if (!SWIG_IsOK(res1)) {
11139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
11140 }
11141 arg1 = reinterpret_cast< wxLog * >(argp1);
11142 {
11143 PyThreadState* __tstate = wxPyBeginAllowThreads();
11144 (arg1)->Flush();
11145 wxPyEndAllowThreads(__tstate);
11146 if (PyErr_Occurred()) SWIG_fail;
11147 }
11148 resultobj = SWIG_Py_Void();
11149 return resultobj;
11150 fail:
11151 return NULL;
11152 }
11153
11154
11155 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11156 PyObject *resultobj = 0;
11157
11158 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
11159 {
11160 PyThreadState* __tstate = wxPyBeginAllowThreads();
11161 wxLog::FlushActive();
11162 wxPyEndAllowThreads(__tstate);
11163 if (PyErr_Occurred()) SWIG_fail;
11164 }
11165 resultobj = SWIG_Py_Void();
11166 return resultobj;
11167 fail:
11168 return NULL;
11169 }
11170
11171
11172 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11173 PyObject *resultobj = 0;
11174 wxLog *result = 0 ;
11175
11176 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
11177 {
11178 PyThreadState* __tstate = wxPyBeginAllowThreads();
11179 result = (wxLog *)wxLog::GetActiveTarget();
11180 wxPyEndAllowThreads(__tstate);
11181 if (PyErr_Occurred()) SWIG_fail;
11182 }
11183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11184 return resultobj;
11185 fail:
11186 return NULL;
11187 }
11188
11189
11190 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11191 PyObject *resultobj = 0;
11192 wxLog *arg1 = (wxLog *) 0 ;
11193 wxLog *result = 0 ;
11194 int res1 = 0 ;
11195 PyObject * obj0 = 0 ;
11196 char * kwnames[] = {
11197 (char *) "pLogger", NULL
11198 };
11199
11200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
11201 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11202 if (!SWIG_IsOK(res1)) {
11203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
11204 }
11205 {
11206 PyThreadState* __tstate = wxPyBeginAllowThreads();
11207 result = (wxLog *)wxLog::SetActiveTarget(arg1);
11208 wxPyEndAllowThreads(__tstate);
11209 if (PyErr_Occurred()) SWIG_fail;
11210 }
11211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
11212 return resultobj;
11213 fail:
11214 return NULL;
11215 }
11216
11217
11218 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11219 PyObject *resultobj = 0;
11220
11221 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
11222 {
11223 PyThreadState* __tstate = wxPyBeginAllowThreads();
11224 wxLog::Suspend();
11225 wxPyEndAllowThreads(__tstate);
11226 if (PyErr_Occurred()) SWIG_fail;
11227 }
11228 resultobj = SWIG_Py_Void();
11229 return resultobj;
11230 fail:
11231 return NULL;
11232 }
11233
11234
11235 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11236 PyObject *resultobj = 0;
11237
11238 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
11239 {
11240 PyThreadState* __tstate = wxPyBeginAllowThreads();
11241 wxLog::Resume();
11242 wxPyEndAllowThreads(__tstate);
11243 if (PyErr_Occurred()) SWIG_fail;
11244 }
11245 resultobj = SWIG_Py_Void();
11246 return resultobj;
11247 fail:
11248 return NULL;
11249 }
11250
11251
11252 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11253 PyObject *resultobj = 0;
11254 bool arg1 = (bool) true ;
11255 bool val1 ;
11256 int ecode1 = 0 ;
11257 PyObject * obj0 = 0 ;
11258 char * kwnames[] = {
11259 (char *) "bVerbose", NULL
11260 };
11261
11262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
11263 if (obj0) {
11264 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11265 if (!SWIG_IsOK(ecode1)) {
11266 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
11267 }
11268 arg1 = static_cast< bool >(val1);
11269 }
11270 {
11271 PyThreadState* __tstate = wxPyBeginAllowThreads();
11272 wxLog::SetVerbose(arg1);
11273 wxPyEndAllowThreads(__tstate);
11274 if (PyErr_Occurred()) SWIG_fail;
11275 }
11276 resultobj = SWIG_Py_Void();
11277 return resultobj;
11278 fail:
11279 return NULL;
11280 }
11281
11282
11283 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11284 PyObject *resultobj = 0;
11285 wxLogLevel arg1 ;
11286 unsigned long val1 ;
11287 int ecode1 = 0 ;
11288 PyObject * obj0 = 0 ;
11289 char * kwnames[] = {
11290 (char *) "logLevel", NULL
11291 };
11292
11293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
11294 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11295 if (!SWIG_IsOK(ecode1)) {
11296 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
11297 }
11298 arg1 = static_cast< wxLogLevel >(val1);
11299 {
11300 PyThreadState* __tstate = wxPyBeginAllowThreads();
11301 wxLog::SetLogLevel(arg1);
11302 wxPyEndAllowThreads(__tstate);
11303 if (PyErr_Occurred()) SWIG_fail;
11304 }
11305 resultobj = SWIG_Py_Void();
11306 return resultobj;
11307 fail:
11308 return NULL;
11309 }
11310
11311
11312 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11313 PyObject *resultobj = 0;
11314
11315 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
11316 {
11317 PyThreadState* __tstate = wxPyBeginAllowThreads();
11318 wxLog::DontCreateOnDemand();
11319 wxPyEndAllowThreads(__tstate);
11320 if (PyErr_Occurred()) SWIG_fail;
11321 }
11322 resultobj = SWIG_Py_Void();
11323 return resultobj;
11324 fail:
11325 return NULL;
11326 }
11327
11328
11329 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11330 PyObject *resultobj = 0;
11331 wxTraceMask arg1 ;
11332 unsigned long val1 ;
11333 int ecode1 = 0 ;
11334 PyObject * obj0 = 0 ;
11335 char * kwnames[] = {
11336 (char *) "ulMask", NULL
11337 };
11338
11339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
11340 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11341 if (!SWIG_IsOK(ecode1)) {
11342 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
11343 }
11344 arg1 = static_cast< wxTraceMask >(val1);
11345 {
11346 PyThreadState* __tstate = wxPyBeginAllowThreads();
11347 wxLog::SetTraceMask(arg1);
11348 wxPyEndAllowThreads(__tstate);
11349 if (PyErr_Occurred()) SWIG_fail;
11350 }
11351 resultobj = SWIG_Py_Void();
11352 return resultobj;
11353 fail:
11354 return NULL;
11355 }
11356
11357
11358 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11359 PyObject *resultobj = 0;
11360 wxString *arg1 = 0 ;
11361 bool temp1 = false ;
11362 PyObject * obj0 = 0 ;
11363 char * kwnames[] = {
11364 (char *) "str", NULL
11365 };
11366
11367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
11368 {
11369 arg1 = wxString_in_helper(obj0);
11370 if (arg1 == NULL) SWIG_fail;
11371 temp1 = true;
11372 }
11373 {
11374 PyThreadState* __tstate = wxPyBeginAllowThreads();
11375 wxLog::AddTraceMask((wxString const &)*arg1);
11376 wxPyEndAllowThreads(__tstate);
11377 if (PyErr_Occurred()) SWIG_fail;
11378 }
11379 resultobj = SWIG_Py_Void();
11380 {
11381 if (temp1)
11382 delete arg1;
11383 }
11384 return resultobj;
11385 fail:
11386 {
11387 if (temp1)
11388 delete arg1;
11389 }
11390 return NULL;
11391 }
11392
11393
11394 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11395 PyObject *resultobj = 0;
11396 wxString *arg1 = 0 ;
11397 bool temp1 = false ;
11398 PyObject * obj0 = 0 ;
11399 char * kwnames[] = {
11400 (char *) "str", NULL
11401 };
11402
11403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
11404 {
11405 arg1 = wxString_in_helper(obj0);
11406 if (arg1 == NULL) SWIG_fail;
11407 temp1 = true;
11408 }
11409 {
11410 PyThreadState* __tstate = wxPyBeginAllowThreads();
11411 wxLog::RemoveTraceMask((wxString const &)*arg1);
11412 wxPyEndAllowThreads(__tstate);
11413 if (PyErr_Occurred()) SWIG_fail;
11414 }
11415 resultobj = SWIG_Py_Void();
11416 {
11417 if (temp1)
11418 delete arg1;
11419 }
11420 return resultobj;
11421 fail:
11422 {
11423 if (temp1)
11424 delete arg1;
11425 }
11426 return NULL;
11427 }
11428
11429
11430 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11431 PyObject *resultobj = 0;
11432
11433 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
11434 {
11435 PyThreadState* __tstate = wxPyBeginAllowThreads();
11436 wxLog::ClearTraceMasks();
11437 wxPyEndAllowThreads(__tstate);
11438 if (PyErr_Occurred()) SWIG_fail;
11439 }
11440 resultobj = SWIG_Py_Void();
11441 return resultobj;
11442 fail:
11443 return NULL;
11444 }
11445
11446
11447 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11448 PyObject *resultobj = 0;
11449 wxArrayString *result = 0 ;
11450
11451 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
11452 {
11453 PyThreadState* __tstate = wxPyBeginAllowThreads();
11454 {
11455 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
11456 result = (wxArrayString *) &_result_ref;
11457 }
11458 wxPyEndAllowThreads(__tstate);
11459 if (PyErr_Occurred()) SWIG_fail;
11460 }
11461 {
11462 resultobj = wxArrayString2PyList_helper(*result);
11463 }
11464 return resultobj;
11465 fail:
11466 return NULL;
11467 }
11468
11469
11470 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11471 PyObject *resultobj = 0;
11472 wxChar *arg1 = (wxChar *) 0 ;
11473 void *argp1 = 0 ;
11474 int res1 = 0 ;
11475 PyObject * obj0 = 0 ;
11476 char * kwnames[] = {
11477 (char *) "ts", NULL
11478 };
11479
11480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
11481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11482 if (!SWIG_IsOK(res1)) {
11483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
11484 }
11485 arg1 = reinterpret_cast< wxChar * >(argp1);
11486 {
11487 PyThreadState* __tstate = wxPyBeginAllowThreads();
11488 wxLog::SetTimestamp((wxChar const *)arg1);
11489 wxPyEndAllowThreads(__tstate);
11490 if (PyErr_Occurred()) SWIG_fail;
11491 }
11492 resultobj = SWIG_Py_Void();
11493 return resultobj;
11494 fail:
11495 return NULL;
11496 }
11497
11498
11499 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11500 PyObject *resultobj = 0;
11501 bool result;
11502
11503 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
11504 {
11505 PyThreadState* __tstate = wxPyBeginAllowThreads();
11506 result = (bool)wxLog::GetVerbose();
11507 wxPyEndAllowThreads(__tstate);
11508 if (PyErr_Occurred()) SWIG_fail;
11509 }
11510 {
11511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11512 }
11513 return resultobj;
11514 fail:
11515 return NULL;
11516 }
11517
11518
11519 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11520 PyObject *resultobj = 0;
11521 wxTraceMask result;
11522
11523 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
11524 {
11525 PyThreadState* __tstate = wxPyBeginAllowThreads();
11526 result = (wxTraceMask)wxLog::GetTraceMask();
11527 wxPyEndAllowThreads(__tstate);
11528 if (PyErr_Occurred()) SWIG_fail;
11529 }
11530 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11531 return resultobj;
11532 fail:
11533 return NULL;
11534 }
11535
11536
11537 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11538 PyObject *resultobj = 0;
11539 wxChar *arg1 = (wxChar *) 0 ;
11540 bool result;
11541 void *argp1 = 0 ;
11542 int res1 = 0 ;
11543 PyObject * obj0 = 0 ;
11544 char * kwnames[] = {
11545 (char *) "mask", NULL
11546 };
11547
11548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
11549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11550 if (!SWIG_IsOK(res1)) {
11551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
11552 }
11553 arg1 = reinterpret_cast< wxChar * >(argp1);
11554 {
11555 PyThreadState* __tstate = wxPyBeginAllowThreads();
11556 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
11557 wxPyEndAllowThreads(__tstate);
11558 if (PyErr_Occurred()) SWIG_fail;
11559 }
11560 {
11561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11562 }
11563 return resultobj;
11564 fail:
11565 return NULL;
11566 }
11567
11568
11569 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11570 PyObject *resultobj = 0;
11571 wxLogLevel result;
11572
11573 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
11574 {
11575 PyThreadState* __tstate = wxPyBeginAllowThreads();
11576 result = (wxLogLevel)wxLog::GetLogLevel();
11577 wxPyEndAllowThreads(__tstate);
11578 if (PyErr_Occurred()) SWIG_fail;
11579 }
11580 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11581 return resultobj;
11582 fail:
11583 return NULL;
11584 }
11585
11586
11587 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11588 PyObject *resultobj = 0;
11589 wxChar *result = 0 ;
11590
11591 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
11592 {
11593 PyThreadState* __tstate = wxPyBeginAllowThreads();
11594 result = (wxChar *)wxLog::GetTimestamp();
11595 wxPyEndAllowThreads(__tstate);
11596 if (PyErr_Occurred()) SWIG_fail;
11597 }
11598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
11599 return resultobj;
11600 fail:
11601 return NULL;
11602 }
11603
11604
11605 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11606 PyObject *resultobj = 0;
11607 wxString result;
11608
11609 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
11610 {
11611 PyThreadState* __tstate = wxPyBeginAllowThreads();
11612 result = wxLog_TimeStamp();
11613 wxPyEndAllowThreads(__tstate);
11614 if (PyErr_Occurred()) SWIG_fail;
11615 }
11616 {
11617 #if wxUSE_UNICODE
11618 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11619 #else
11620 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11621 #endif
11622 }
11623 return resultobj;
11624 fail:
11625 return NULL;
11626 }
11627
11628
11629 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11630 PyObject *resultobj = 0;
11631 wxLog *arg1 = (wxLog *) 0 ;
11632 void *argp1 = 0 ;
11633 int res1 = 0 ;
11634 PyObject *swig_obj[1] ;
11635
11636 if (!args) SWIG_fail;
11637 swig_obj[0] = args;
11638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11639 if (!SWIG_IsOK(res1)) {
11640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
11641 }
11642 arg1 = reinterpret_cast< wxLog * >(argp1);
11643 {
11644 PyThreadState* __tstate = wxPyBeginAllowThreads();
11645 wxLog_Destroy(arg1);
11646 wxPyEndAllowThreads(__tstate);
11647 if (PyErr_Occurred()) SWIG_fail;
11648 }
11649 resultobj = SWIG_Py_Void();
11650 return resultobj;
11651 fail:
11652 return NULL;
11653 }
11654
11655
11656 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11657 PyObject *obj;
11658 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11659 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
11660 return SWIG_Py_Void();
11661 }
11662
11663 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11664 return SWIG_Python_InitShadowInstance(args);
11665 }
11666
11667 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11668 PyObject *resultobj = 0;
11669 wxLogStderr *result = 0 ;
11670
11671 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
11672 {
11673 PyThreadState* __tstate = wxPyBeginAllowThreads();
11674 result = (wxLogStderr *)new wxLogStderr();
11675 wxPyEndAllowThreads(__tstate);
11676 if (PyErr_Occurred()) SWIG_fail;
11677 }
11678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
11679 return resultobj;
11680 fail:
11681 return NULL;
11682 }
11683
11684
11685 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11686 PyObject *obj;
11687 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11688 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
11689 return SWIG_Py_Void();
11690 }
11691
11692 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11693 return SWIG_Python_InitShadowInstance(args);
11694 }
11695
11696 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11697 PyObject *resultobj = 0;
11698 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11699 wxLogTextCtrl *result = 0 ;
11700 void *argp1 = 0 ;
11701 int res1 = 0 ;
11702 PyObject * obj0 = 0 ;
11703 char * kwnames[] = {
11704 (char *) "pTextCtrl", NULL
11705 };
11706
11707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
11708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
11709 if (!SWIG_IsOK(res1)) {
11710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
11711 }
11712 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
11713 {
11714 PyThreadState* __tstate = wxPyBeginAllowThreads();
11715 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
11716 wxPyEndAllowThreads(__tstate);
11717 if (PyErr_Occurred()) SWIG_fail;
11718 }
11719 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
11720 return resultobj;
11721 fail:
11722 return NULL;
11723 }
11724
11725
11726 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11727 PyObject *obj;
11728 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11729 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
11730 return SWIG_Py_Void();
11731 }
11732
11733 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11734 return SWIG_Python_InitShadowInstance(args);
11735 }
11736
11737 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11738 PyObject *resultobj = 0;
11739 wxLogGui *result = 0 ;
11740
11741 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
11742 {
11743 PyThreadState* __tstate = wxPyBeginAllowThreads();
11744 result = (wxLogGui *)new wxLogGui();
11745 wxPyEndAllowThreads(__tstate);
11746 if (PyErr_Occurred()) SWIG_fail;
11747 }
11748 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
11749 return resultobj;
11750 fail:
11751 return NULL;
11752 }
11753
11754
11755 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11756 PyObject *obj;
11757 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11758 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
11759 return SWIG_Py_Void();
11760 }
11761
11762 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11763 return SWIG_Python_InitShadowInstance(args);
11764 }
11765
11766 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11767 PyObject *resultobj = 0;
11768 wxFrame *arg1 = (wxFrame *) 0 ;
11769 wxString *arg2 = 0 ;
11770 bool arg3 = (bool) true ;
11771 bool arg4 = (bool) true ;
11772 wxLogWindow *result = 0 ;
11773 void *argp1 = 0 ;
11774 int res1 = 0 ;
11775 bool temp2 = false ;
11776 bool val3 ;
11777 int ecode3 = 0 ;
11778 bool val4 ;
11779 int ecode4 = 0 ;
11780 PyObject * obj0 = 0 ;
11781 PyObject * obj1 = 0 ;
11782 PyObject * obj2 = 0 ;
11783 PyObject * obj3 = 0 ;
11784 char * kwnames[] = {
11785 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
11786 };
11787
11788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
11790 if (!SWIG_IsOK(res1)) {
11791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
11792 }
11793 arg1 = reinterpret_cast< wxFrame * >(argp1);
11794 {
11795 arg2 = wxString_in_helper(obj1);
11796 if (arg2 == NULL) SWIG_fail;
11797 temp2 = true;
11798 }
11799 if (obj2) {
11800 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11801 if (!SWIG_IsOK(ecode3)) {
11802 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
11803 }
11804 arg3 = static_cast< bool >(val3);
11805 }
11806 if (obj3) {
11807 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11808 if (!SWIG_IsOK(ecode4)) {
11809 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
11810 }
11811 arg4 = static_cast< bool >(val4);
11812 }
11813 {
11814 PyThreadState* __tstate = wxPyBeginAllowThreads();
11815 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
11816 wxPyEndAllowThreads(__tstate);
11817 if (PyErr_Occurred()) SWIG_fail;
11818 }
11819 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
11820 {
11821 if (temp2)
11822 delete arg2;
11823 }
11824 return resultobj;
11825 fail:
11826 {
11827 if (temp2)
11828 delete arg2;
11829 }
11830 return NULL;
11831 }
11832
11833
11834 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11835 PyObject *resultobj = 0;
11836 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11837 bool arg2 = (bool) true ;
11838 void *argp1 = 0 ;
11839 int res1 = 0 ;
11840 bool val2 ;
11841 int ecode2 = 0 ;
11842 PyObject * obj0 = 0 ;
11843 PyObject * obj1 = 0 ;
11844 char * kwnames[] = {
11845 (char *) "self",(char *) "bShow", NULL
11846 };
11847
11848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
11849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11850 if (!SWIG_IsOK(res1)) {
11851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11852 }
11853 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11854 if (obj1) {
11855 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11856 if (!SWIG_IsOK(ecode2)) {
11857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
11858 }
11859 arg2 = static_cast< bool >(val2);
11860 }
11861 {
11862 PyThreadState* __tstate = wxPyBeginAllowThreads();
11863 (arg1)->Show(arg2);
11864 wxPyEndAllowThreads(__tstate);
11865 if (PyErr_Occurred()) SWIG_fail;
11866 }
11867 resultobj = SWIG_Py_Void();
11868 return resultobj;
11869 fail:
11870 return NULL;
11871 }
11872
11873
11874 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11875 PyObject *resultobj = 0;
11876 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11877 wxFrame *result = 0 ;
11878 void *argp1 = 0 ;
11879 int res1 = 0 ;
11880 PyObject *swig_obj[1] ;
11881
11882 if (!args) SWIG_fail;
11883 swig_obj[0] = args;
11884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11885 if (!SWIG_IsOK(res1)) {
11886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11887 }
11888 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11889 {
11890 PyThreadState* __tstate = wxPyBeginAllowThreads();
11891 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
11892 wxPyEndAllowThreads(__tstate);
11893 if (PyErr_Occurred()) SWIG_fail;
11894 }
11895 {
11896 resultobj = wxPyMake_wxObject(result, (bool)0);
11897 }
11898 return resultobj;
11899 fail:
11900 return NULL;
11901 }
11902
11903
11904 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11905 PyObject *resultobj = 0;
11906 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11907 wxLog *result = 0 ;
11908 void *argp1 = 0 ;
11909 int res1 = 0 ;
11910 PyObject *swig_obj[1] ;
11911
11912 if (!args) SWIG_fail;
11913 swig_obj[0] = args;
11914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11915 if (!SWIG_IsOK(res1)) {
11916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11917 }
11918 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11919 {
11920 PyThreadState* __tstate = wxPyBeginAllowThreads();
11921 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
11922 wxPyEndAllowThreads(__tstate);
11923 if (PyErr_Occurred()) SWIG_fail;
11924 }
11925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11926 return resultobj;
11927 fail:
11928 return NULL;
11929 }
11930
11931
11932 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11933 PyObject *resultobj = 0;
11934 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11935 bool result;
11936 void *argp1 = 0 ;
11937 int res1 = 0 ;
11938 PyObject *swig_obj[1] ;
11939
11940 if (!args) SWIG_fail;
11941 swig_obj[0] = args;
11942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11943 if (!SWIG_IsOK(res1)) {
11944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11945 }
11946 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11947 {
11948 PyThreadState* __tstate = wxPyBeginAllowThreads();
11949 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
11950 wxPyEndAllowThreads(__tstate);
11951 if (PyErr_Occurred()) SWIG_fail;
11952 }
11953 {
11954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11955 }
11956 return resultobj;
11957 fail:
11958 return NULL;
11959 }
11960
11961
11962 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11963 PyObject *resultobj = 0;
11964 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11965 bool arg2 ;
11966 void *argp1 = 0 ;
11967 int res1 = 0 ;
11968 bool val2 ;
11969 int ecode2 = 0 ;
11970 PyObject * obj0 = 0 ;
11971 PyObject * obj1 = 0 ;
11972 char * kwnames[] = {
11973 (char *) "self",(char *) "bDoPass", NULL
11974 };
11975
11976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
11977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11978 if (!SWIG_IsOK(res1)) {
11979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11980 }
11981 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11982 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11983 if (!SWIG_IsOK(ecode2)) {
11984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
11985 }
11986 arg2 = static_cast< bool >(val2);
11987 {
11988 PyThreadState* __tstate = wxPyBeginAllowThreads();
11989 (arg1)->PassMessages(arg2);
11990 wxPyEndAllowThreads(__tstate);
11991 if (PyErr_Occurred()) SWIG_fail;
11992 }
11993 resultobj = SWIG_Py_Void();
11994 return resultobj;
11995 fail:
11996 return NULL;
11997 }
11998
11999
12000 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12001 PyObject *obj;
12002 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12003 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
12004 return SWIG_Py_Void();
12005 }
12006
12007 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12008 return SWIG_Python_InitShadowInstance(args);
12009 }
12010
12011 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12012 PyObject *resultobj = 0;
12013 wxLog *arg1 = (wxLog *) 0 ;
12014 wxLogChain *result = 0 ;
12015 void *argp1 = 0 ;
12016 int res1 = 0 ;
12017 PyObject * obj0 = 0 ;
12018 char * kwnames[] = {
12019 (char *) "logger", NULL
12020 };
12021
12022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
12023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12024 if (!SWIG_IsOK(res1)) {
12025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
12026 }
12027 arg1 = reinterpret_cast< wxLog * >(argp1);
12028 {
12029 PyThreadState* __tstate = wxPyBeginAllowThreads();
12030 result = (wxLogChain *)new wxLogChain(arg1);
12031 wxPyEndAllowThreads(__tstate);
12032 if (PyErr_Occurred()) SWIG_fail;
12033 }
12034 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
12035 return resultobj;
12036 fail:
12037 return NULL;
12038 }
12039
12040
12041 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12042 PyObject *resultobj = 0;
12043 wxLogChain *arg1 = (wxLogChain *) 0 ;
12044 wxLog *arg2 = (wxLog *) 0 ;
12045 void *argp1 = 0 ;
12046 int res1 = 0 ;
12047 void *argp2 = 0 ;
12048 int res2 = 0 ;
12049 PyObject * obj0 = 0 ;
12050 PyObject * obj1 = 0 ;
12051 char * kwnames[] = {
12052 (char *) "self",(char *) "logger", NULL
12053 };
12054
12055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
12056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12057 if (!SWIG_IsOK(res1)) {
12058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12059 }
12060 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12061 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
12062 if (!SWIG_IsOK(res2)) {
12063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
12064 }
12065 arg2 = reinterpret_cast< wxLog * >(argp2);
12066 {
12067 PyThreadState* __tstate = wxPyBeginAllowThreads();
12068 (arg1)->SetLog(arg2);
12069 wxPyEndAllowThreads(__tstate);
12070 if (PyErr_Occurred()) SWIG_fail;
12071 }
12072 resultobj = SWIG_Py_Void();
12073 return resultobj;
12074 fail:
12075 return NULL;
12076 }
12077
12078
12079 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12080 PyObject *resultobj = 0;
12081 wxLogChain *arg1 = (wxLogChain *) 0 ;
12082 bool arg2 ;
12083 void *argp1 = 0 ;
12084 int res1 = 0 ;
12085 bool val2 ;
12086 int ecode2 = 0 ;
12087 PyObject * obj0 = 0 ;
12088 PyObject * obj1 = 0 ;
12089 char * kwnames[] = {
12090 (char *) "self",(char *) "bDoPass", NULL
12091 };
12092
12093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12095 if (!SWIG_IsOK(res1)) {
12096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12097 }
12098 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12099 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12100 if (!SWIG_IsOK(ecode2)) {
12101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12102 }
12103 arg2 = static_cast< bool >(val2);
12104 {
12105 PyThreadState* __tstate = wxPyBeginAllowThreads();
12106 (arg1)->PassMessages(arg2);
12107 wxPyEndAllowThreads(__tstate);
12108 if (PyErr_Occurred()) SWIG_fail;
12109 }
12110 resultobj = SWIG_Py_Void();
12111 return resultobj;
12112 fail:
12113 return NULL;
12114 }
12115
12116
12117 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12118 PyObject *resultobj = 0;
12119 wxLogChain *arg1 = (wxLogChain *) 0 ;
12120 bool result;
12121 void *argp1 = 0 ;
12122 int res1 = 0 ;
12123 PyObject *swig_obj[1] ;
12124
12125 if (!args) SWIG_fail;
12126 swig_obj[0] = args;
12127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12128 if (!SWIG_IsOK(res1)) {
12129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12130 }
12131 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12132 {
12133 PyThreadState* __tstate = wxPyBeginAllowThreads();
12134 result = (bool)(arg1)->IsPassingMessages();
12135 wxPyEndAllowThreads(__tstate);
12136 if (PyErr_Occurred()) SWIG_fail;
12137 }
12138 {
12139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12140 }
12141 return resultobj;
12142 fail:
12143 return NULL;
12144 }
12145
12146
12147 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12148 PyObject *resultobj = 0;
12149 wxLogChain *arg1 = (wxLogChain *) 0 ;
12150 wxLog *result = 0 ;
12151 void *argp1 = 0 ;
12152 int res1 = 0 ;
12153 PyObject *swig_obj[1] ;
12154
12155 if (!args) SWIG_fail;
12156 swig_obj[0] = args;
12157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12158 if (!SWIG_IsOK(res1)) {
12159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12160 }
12161 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12162 {
12163 PyThreadState* __tstate = wxPyBeginAllowThreads();
12164 result = (wxLog *)(arg1)->GetOldLog();
12165 wxPyEndAllowThreads(__tstate);
12166 if (PyErr_Occurred()) SWIG_fail;
12167 }
12168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12169 return resultobj;
12170 fail:
12171 return NULL;
12172 }
12173
12174
12175 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12176 PyObject *obj;
12177 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12178 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
12179 return SWIG_Py_Void();
12180 }
12181
12182 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12183 return SWIG_Python_InitShadowInstance(args);
12184 }
12185
12186 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12187 PyObject *resultobj = 0;
12188 wxLogBuffer *result = 0 ;
12189
12190 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
12191 {
12192 PyThreadState* __tstate = wxPyBeginAllowThreads();
12193 result = (wxLogBuffer *)new wxLogBuffer();
12194 wxPyEndAllowThreads(__tstate);
12195 if (PyErr_Occurred()) SWIG_fail;
12196 }
12197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
12198 return resultobj;
12199 fail:
12200 return NULL;
12201 }
12202
12203
12204 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12205 PyObject *resultobj = 0;
12206 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
12207 wxString *result = 0 ;
12208 void *argp1 = 0 ;
12209 int res1 = 0 ;
12210 PyObject *swig_obj[1] ;
12211
12212 if (!args) SWIG_fail;
12213 swig_obj[0] = args;
12214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
12215 if (!SWIG_IsOK(res1)) {
12216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
12217 }
12218 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
12219 {
12220 PyThreadState* __tstate = wxPyBeginAllowThreads();
12221 {
12222 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
12223 result = (wxString *) &_result_ref;
12224 }
12225 wxPyEndAllowThreads(__tstate);
12226 if (PyErr_Occurred()) SWIG_fail;
12227 }
12228 {
12229 #if wxUSE_UNICODE
12230 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12231 #else
12232 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12233 #endif
12234 }
12235 return resultobj;
12236 fail:
12237 return NULL;
12238 }
12239
12240
12241 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12242 PyObject *obj;
12243 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12244 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
12245 return SWIG_Py_Void();
12246 }
12247
12248 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12249 return SWIG_Python_InitShadowInstance(args);
12250 }
12251
12252 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12253 PyObject *resultobj = 0;
12254 unsigned long result;
12255
12256 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
12257 {
12258 PyThreadState* __tstate = wxPyBeginAllowThreads();
12259 result = (unsigned long)wxSysErrorCode();
12260 wxPyEndAllowThreads(__tstate);
12261 if (PyErr_Occurred()) SWIG_fail;
12262 }
12263 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12264 return resultobj;
12265 fail:
12266 return NULL;
12267 }
12268
12269
12270 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12271 PyObject *resultobj = 0;
12272 unsigned long arg1 = (unsigned long) 0 ;
12273 wxString result;
12274 unsigned long val1 ;
12275 int ecode1 = 0 ;
12276 PyObject * obj0 = 0 ;
12277 char * kwnames[] = {
12278 (char *) "nErrCode", NULL
12279 };
12280
12281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
12282 if (obj0) {
12283 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12284 if (!SWIG_IsOK(ecode1)) {
12285 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
12286 }
12287 arg1 = static_cast< unsigned long >(val1);
12288 }
12289 {
12290 PyThreadState* __tstate = wxPyBeginAllowThreads();
12291 result = wxSysErrorMsg(arg1);
12292 wxPyEndAllowThreads(__tstate);
12293 if (PyErr_Occurred()) SWIG_fail;
12294 }
12295 {
12296 #if wxUSE_UNICODE
12297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12298 #else
12299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12300 #endif
12301 }
12302 return resultobj;
12303 fail:
12304 return NULL;
12305 }
12306
12307
12308 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12309 PyObject *resultobj = 0;
12310 wxString *arg1 = 0 ;
12311 bool temp1 = false ;
12312 PyObject * obj0 = 0 ;
12313 char * kwnames[] = {
12314 (char *) "msg", NULL
12315 };
12316
12317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
12318 {
12319 arg1 = wxString_in_helper(obj0);
12320 if (arg1 == NULL) SWIG_fail;
12321 temp1 = true;
12322 }
12323 {
12324 PyThreadState* __tstate = wxPyBeginAllowThreads();
12325 wxPyLogFatalError((wxString const &)*arg1);
12326 wxPyEndAllowThreads(__tstate);
12327 if (PyErr_Occurred()) SWIG_fail;
12328 }
12329 resultobj = SWIG_Py_Void();
12330 {
12331 if (temp1)
12332 delete arg1;
12333 }
12334 return resultobj;
12335 fail:
12336 {
12337 if (temp1)
12338 delete arg1;
12339 }
12340 return NULL;
12341 }
12342
12343
12344 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12345 PyObject *resultobj = 0;
12346 wxString *arg1 = 0 ;
12347 bool temp1 = false ;
12348 PyObject * obj0 = 0 ;
12349 char * kwnames[] = {
12350 (char *) "msg", NULL
12351 };
12352
12353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
12354 {
12355 arg1 = wxString_in_helper(obj0);
12356 if (arg1 == NULL) SWIG_fail;
12357 temp1 = true;
12358 }
12359 {
12360 PyThreadState* __tstate = wxPyBeginAllowThreads();
12361 wxPyLogError((wxString const &)*arg1);
12362 wxPyEndAllowThreads(__tstate);
12363 if (PyErr_Occurred()) SWIG_fail;
12364 }
12365 resultobj = SWIG_Py_Void();
12366 {
12367 if (temp1)
12368 delete arg1;
12369 }
12370 return resultobj;
12371 fail:
12372 {
12373 if (temp1)
12374 delete arg1;
12375 }
12376 return NULL;
12377 }
12378
12379
12380 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12381 PyObject *resultobj = 0;
12382 wxString *arg1 = 0 ;
12383 bool temp1 = false ;
12384 PyObject * obj0 = 0 ;
12385 char * kwnames[] = {
12386 (char *) "msg", NULL
12387 };
12388
12389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
12390 {
12391 arg1 = wxString_in_helper(obj0);
12392 if (arg1 == NULL) SWIG_fail;
12393 temp1 = true;
12394 }
12395 {
12396 PyThreadState* __tstate = wxPyBeginAllowThreads();
12397 wxPyLogWarning((wxString const &)*arg1);
12398 wxPyEndAllowThreads(__tstate);
12399 if (PyErr_Occurred()) SWIG_fail;
12400 }
12401 resultobj = SWIG_Py_Void();
12402 {
12403 if (temp1)
12404 delete arg1;
12405 }
12406 return resultobj;
12407 fail:
12408 {
12409 if (temp1)
12410 delete arg1;
12411 }
12412 return NULL;
12413 }
12414
12415
12416 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12417 PyObject *resultobj = 0;
12418 wxString *arg1 = 0 ;
12419 bool temp1 = false ;
12420 PyObject * obj0 = 0 ;
12421 char * kwnames[] = {
12422 (char *) "msg", NULL
12423 };
12424
12425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
12426 {
12427 arg1 = wxString_in_helper(obj0);
12428 if (arg1 == NULL) SWIG_fail;
12429 temp1 = true;
12430 }
12431 {
12432 PyThreadState* __tstate = wxPyBeginAllowThreads();
12433 wxPyLogMessage((wxString const &)*arg1);
12434 wxPyEndAllowThreads(__tstate);
12435 if (PyErr_Occurred()) SWIG_fail;
12436 }
12437 resultobj = SWIG_Py_Void();
12438 {
12439 if (temp1)
12440 delete arg1;
12441 }
12442 return resultobj;
12443 fail:
12444 {
12445 if (temp1)
12446 delete arg1;
12447 }
12448 return NULL;
12449 }
12450
12451
12452 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12453 PyObject *resultobj = 0;
12454 wxString *arg1 = 0 ;
12455 bool temp1 = false ;
12456 PyObject * obj0 = 0 ;
12457 char * kwnames[] = {
12458 (char *) "msg", NULL
12459 };
12460
12461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
12462 {
12463 arg1 = wxString_in_helper(obj0);
12464 if (arg1 == NULL) SWIG_fail;
12465 temp1 = true;
12466 }
12467 {
12468 PyThreadState* __tstate = wxPyBeginAllowThreads();
12469 wxPyLogInfo((wxString const &)*arg1);
12470 wxPyEndAllowThreads(__tstate);
12471 if (PyErr_Occurred()) SWIG_fail;
12472 }
12473 resultobj = SWIG_Py_Void();
12474 {
12475 if (temp1)
12476 delete arg1;
12477 }
12478 return resultobj;
12479 fail:
12480 {
12481 if (temp1)
12482 delete arg1;
12483 }
12484 return NULL;
12485 }
12486
12487
12488 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12489 PyObject *resultobj = 0;
12490 wxString *arg1 = 0 ;
12491 bool temp1 = false ;
12492 PyObject * obj0 = 0 ;
12493 char * kwnames[] = {
12494 (char *) "msg", NULL
12495 };
12496
12497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
12498 {
12499 arg1 = wxString_in_helper(obj0);
12500 if (arg1 == NULL) SWIG_fail;
12501 temp1 = true;
12502 }
12503 {
12504 PyThreadState* __tstate = wxPyBeginAllowThreads();
12505 wxPyLogDebug((wxString const &)*arg1);
12506 wxPyEndAllowThreads(__tstate);
12507 if (PyErr_Occurred()) SWIG_fail;
12508 }
12509 resultobj = SWIG_Py_Void();
12510 {
12511 if (temp1)
12512 delete arg1;
12513 }
12514 return resultobj;
12515 fail:
12516 {
12517 if (temp1)
12518 delete arg1;
12519 }
12520 return NULL;
12521 }
12522
12523
12524 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12525 PyObject *resultobj = 0;
12526 wxString *arg1 = 0 ;
12527 bool temp1 = false ;
12528 PyObject * obj0 = 0 ;
12529 char * kwnames[] = {
12530 (char *) "msg", NULL
12531 };
12532
12533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
12534 {
12535 arg1 = wxString_in_helper(obj0);
12536 if (arg1 == NULL) SWIG_fail;
12537 temp1 = true;
12538 }
12539 {
12540 PyThreadState* __tstate = wxPyBeginAllowThreads();
12541 wxPyLogVerbose((wxString const &)*arg1);
12542 wxPyEndAllowThreads(__tstate);
12543 if (PyErr_Occurred()) SWIG_fail;
12544 }
12545 resultobj = SWIG_Py_Void();
12546 {
12547 if (temp1)
12548 delete arg1;
12549 }
12550 return resultobj;
12551 fail:
12552 {
12553 if (temp1)
12554 delete arg1;
12555 }
12556 return NULL;
12557 }
12558
12559
12560 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12561 PyObject *resultobj = 0;
12562 wxString *arg1 = 0 ;
12563 bool temp1 = false ;
12564 PyObject * obj0 = 0 ;
12565 char * kwnames[] = {
12566 (char *) "msg", NULL
12567 };
12568
12569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
12570 {
12571 arg1 = wxString_in_helper(obj0);
12572 if (arg1 == NULL) SWIG_fail;
12573 temp1 = true;
12574 }
12575 {
12576 PyThreadState* __tstate = wxPyBeginAllowThreads();
12577 wxPyLogStatus((wxString const &)*arg1);
12578 wxPyEndAllowThreads(__tstate);
12579 if (PyErr_Occurred()) SWIG_fail;
12580 }
12581 resultobj = SWIG_Py_Void();
12582 {
12583 if (temp1)
12584 delete arg1;
12585 }
12586 return resultobj;
12587 fail:
12588 {
12589 if (temp1)
12590 delete arg1;
12591 }
12592 return NULL;
12593 }
12594
12595
12596 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12597 PyObject *resultobj = 0;
12598 wxFrame *arg1 = (wxFrame *) 0 ;
12599 wxString *arg2 = 0 ;
12600 void *argp1 = 0 ;
12601 int res1 = 0 ;
12602 bool temp2 = false ;
12603 PyObject * obj0 = 0 ;
12604 PyObject * obj1 = 0 ;
12605 char * kwnames[] = {
12606 (char *) "pFrame",(char *) "msg", NULL
12607 };
12608
12609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
12610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12611 if (!SWIG_IsOK(res1)) {
12612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
12613 }
12614 arg1 = reinterpret_cast< wxFrame * >(argp1);
12615 {
12616 arg2 = wxString_in_helper(obj1);
12617 if (arg2 == NULL) SWIG_fail;
12618 temp2 = true;
12619 }
12620 {
12621 PyThreadState* __tstate = wxPyBeginAllowThreads();
12622 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
12623 wxPyEndAllowThreads(__tstate);
12624 if (PyErr_Occurred()) SWIG_fail;
12625 }
12626 resultobj = SWIG_Py_Void();
12627 {
12628 if (temp2)
12629 delete arg2;
12630 }
12631 return resultobj;
12632 fail:
12633 {
12634 if (temp2)
12635 delete arg2;
12636 }
12637 return NULL;
12638 }
12639
12640
12641 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12642 PyObject *resultobj = 0;
12643 wxString *arg1 = 0 ;
12644 bool temp1 = false ;
12645 PyObject * obj0 = 0 ;
12646 char * kwnames[] = {
12647 (char *) "msg", NULL
12648 };
12649
12650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
12651 {
12652 arg1 = wxString_in_helper(obj0);
12653 if (arg1 == NULL) SWIG_fail;
12654 temp1 = true;
12655 }
12656 {
12657 PyThreadState* __tstate = wxPyBeginAllowThreads();
12658 wxPyLogSysError((wxString const &)*arg1);
12659 wxPyEndAllowThreads(__tstate);
12660 if (PyErr_Occurred()) SWIG_fail;
12661 }
12662 resultobj = SWIG_Py_Void();
12663 {
12664 if (temp1)
12665 delete arg1;
12666 }
12667 return resultobj;
12668 fail:
12669 {
12670 if (temp1)
12671 delete arg1;
12672 }
12673 return NULL;
12674 }
12675
12676
12677 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12678 PyObject *resultobj = 0;
12679 unsigned long arg1 ;
12680 wxString *arg2 = 0 ;
12681 unsigned long val1 ;
12682 int ecode1 = 0 ;
12683 bool temp2 = false ;
12684 PyObject * obj0 = 0 ;
12685 PyObject * obj1 = 0 ;
12686 char * kwnames[] = {
12687 (char *) "level",(char *) "msg", NULL
12688 };
12689
12690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
12691 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12692 if (!SWIG_IsOK(ecode1)) {
12693 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
12694 }
12695 arg1 = static_cast< unsigned long >(val1);
12696 {
12697 arg2 = wxString_in_helper(obj1);
12698 if (arg2 == NULL) SWIG_fail;
12699 temp2 = true;
12700 }
12701 {
12702 PyThreadState* __tstate = wxPyBeginAllowThreads();
12703 wxPyLogGeneric(arg1,(wxString const &)*arg2);
12704 wxPyEndAllowThreads(__tstate);
12705 if (PyErr_Occurred()) SWIG_fail;
12706 }
12707 resultobj = SWIG_Py_Void();
12708 {
12709 if (temp2)
12710 delete arg2;
12711 }
12712 return resultobj;
12713 fail:
12714 {
12715 if (temp2)
12716 delete arg2;
12717 }
12718 return NULL;
12719 }
12720
12721
12722 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12723 PyObject *resultobj = 0;
12724 unsigned long arg1 ;
12725 wxString *arg2 = 0 ;
12726 unsigned long val1 ;
12727 int ecode1 = 0 ;
12728 bool temp2 = false ;
12729
12730 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12731 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
12732 if (!SWIG_IsOK(ecode1)) {
12733 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
12734 }
12735 arg1 = static_cast< unsigned long >(val1);
12736 {
12737 arg2 = wxString_in_helper(swig_obj[1]);
12738 if (arg2 == NULL) SWIG_fail;
12739 temp2 = true;
12740 }
12741 {
12742 PyThreadState* __tstate = wxPyBeginAllowThreads();
12743 wxPyLogTrace(arg1,(wxString const &)*arg2);
12744 wxPyEndAllowThreads(__tstate);
12745 if (PyErr_Occurred()) SWIG_fail;
12746 }
12747 resultobj = SWIG_Py_Void();
12748 {
12749 if (temp2)
12750 delete arg2;
12751 }
12752 return resultobj;
12753 fail:
12754 {
12755 if (temp2)
12756 delete arg2;
12757 }
12758 return NULL;
12759 }
12760
12761
12762 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12763 PyObject *resultobj = 0;
12764 wxString *arg1 = 0 ;
12765 wxString *arg2 = 0 ;
12766 bool temp1 = false ;
12767 bool temp2 = false ;
12768
12769 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12770 {
12771 arg1 = wxString_in_helper(swig_obj[0]);
12772 if (arg1 == NULL) SWIG_fail;
12773 temp1 = true;
12774 }
12775 {
12776 arg2 = wxString_in_helper(swig_obj[1]);
12777 if (arg2 == NULL) SWIG_fail;
12778 temp2 = true;
12779 }
12780 {
12781 PyThreadState* __tstate = wxPyBeginAllowThreads();
12782 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
12783 wxPyEndAllowThreads(__tstate);
12784 if (PyErr_Occurred()) SWIG_fail;
12785 }
12786 resultobj = SWIG_Py_Void();
12787 {
12788 if (temp1)
12789 delete arg1;
12790 }
12791 {
12792 if (temp2)
12793 delete arg2;
12794 }
12795 return resultobj;
12796 fail:
12797 {
12798 if (temp1)
12799 delete arg1;
12800 }
12801 {
12802 if (temp2)
12803 delete arg2;
12804 }
12805 return NULL;
12806 }
12807
12808
12809 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
12810 int argc;
12811 PyObject *argv[3];
12812
12813 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
12814 --argc;
12815 if (argc == 2) {
12816 int _v = 0;
12817 {
12818 {
12819 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12820 }
12821 }
12822 if (!_v) goto check_1;
12823 return _wrap_LogTrace__SWIG_1(self, argc, argv);
12824 }
12825 check_1:
12826
12827 if (argc == 2) {
12828 return _wrap_LogTrace__SWIG_0(self, argc, argv);
12829 }
12830
12831 fail:
12832 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
12833 return NULL;
12834 }
12835
12836
12837 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12838 PyObject *resultobj = 0;
12839 wxString *arg1 = 0 ;
12840 wxString *arg2 = 0 ;
12841 bool temp1 = false ;
12842 bool temp2 = false ;
12843 PyObject * obj0 = 0 ;
12844 PyObject * obj1 = 0 ;
12845 char * kwnames[] = {
12846 (char *) "title",(char *) "text", NULL
12847 };
12848
12849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
12850 {
12851 arg1 = wxString_in_helper(obj0);
12852 if (arg1 == NULL) SWIG_fail;
12853 temp1 = true;
12854 }
12855 {
12856 arg2 = wxString_in_helper(obj1);
12857 if (arg2 == NULL) SWIG_fail;
12858 temp2 = true;
12859 }
12860 {
12861 PyThreadState* __tstate = wxPyBeginAllowThreads();
12862 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
12863 wxPyEndAllowThreads(__tstate);
12864 if (PyErr_Occurred()) SWIG_fail;
12865 }
12866 resultobj = SWIG_Py_Void();
12867 {
12868 if (temp1)
12869 delete arg1;
12870 }
12871 {
12872 if (temp2)
12873 delete arg2;
12874 }
12875 return resultobj;
12876 fail:
12877 {
12878 if (temp1)
12879 delete arg1;
12880 }
12881 {
12882 if (temp2)
12883 delete arg2;
12884 }
12885 return NULL;
12886 }
12887
12888
12889 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12890 PyObject *resultobj = 0;
12891 wxLogNull *result = 0 ;
12892
12893 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
12894 {
12895 PyThreadState* __tstate = wxPyBeginAllowThreads();
12896 result = (wxLogNull *)new wxLogNull();
12897 wxPyEndAllowThreads(__tstate);
12898 if (PyErr_Occurred()) SWIG_fail;
12899 }
12900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
12901 return resultobj;
12902 fail:
12903 return NULL;
12904 }
12905
12906
12907 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12908 PyObject *resultobj = 0;
12909 wxLogNull *arg1 = (wxLogNull *) 0 ;
12910 void *argp1 = 0 ;
12911 int res1 = 0 ;
12912 PyObject *swig_obj[1] ;
12913
12914 if (!args) SWIG_fail;
12915 swig_obj[0] = args;
12916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
12917 if (!SWIG_IsOK(res1)) {
12918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
12919 }
12920 arg1 = reinterpret_cast< wxLogNull * >(argp1);
12921 {
12922 PyThreadState* __tstate = wxPyBeginAllowThreads();
12923 delete arg1;
12924
12925 wxPyEndAllowThreads(__tstate);
12926 if (PyErr_Occurred()) SWIG_fail;
12927 }
12928 resultobj = SWIG_Py_Void();
12929 return resultobj;
12930 fail:
12931 return NULL;
12932 }
12933
12934
12935 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12936 PyObject *obj;
12937 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12938 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
12939 return SWIG_Py_Void();
12940 }
12941
12942 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12943 return SWIG_Python_InitShadowInstance(args);
12944 }
12945
12946 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12947 PyObject *resultobj = 0;
12948 wxPyLog *result = 0 ;
12949
12950 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
12951 {
12952 PyThreadState* __tstate = wxPyBeginAllowThreads();
12953 result = (wxPyLog *)new wxPyLog();
12954 wxPyEndAllowThreads(__tstate);
12955 if (PyErr_Occurred()) SWIG_fail;
12956 }
12957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
12958 return resultobj;
12959 fail:
12960 return NULL;
12961 }
12962
12963
12964 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12965 PyObject *resultobj = 0;
12966 wxPyLog *arg1 = (wxPyLog *) 0 ;
12967 PyObject *arg2 = (PyObject *) 0 ;
12968 PyObject *arg3 = (PyObject *) 0 ;
12969 void *argp1 = 0 ;
12970 int res1 = 0 ;
12971 PyObject * obj0 = 0 ;
12972 PyObject * obj1 = 0 ;
12973 PyObject * obj2 = 0 ;
12974 char * kwnames[] = {
12975 (char *) "self",(char *) "self",(char *) "_class", NULL
12976 };
12977
12978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
12980 if (!SWIG_IsOK(res1)) {
12981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
12982 }
12983 arg1 = reinterpret_cast< wxPyLog * >(argp1);
12984 arg2 = obj1;
12985 arg3 = obj2;
12986 {
12987 PyThreadState* __tstate = wxPyBeginAllowThreads();
12988 (arg1)->_setCallbackInfo(arg2,arg3);
12989 wxPyEndAllowThreads(__tstate);
12990 if (PyErr_Occurred()) SWIG_fail;
12991 }
12992 resultobj = SWIG_Py_Void();
12993 return resultobj;
12994 fail:
12995 return NULL;
12996 }
12997
12998
12999 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13000 PyObject *obj;
13001 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13002 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
13003 return SWIG_Py_Void();
13004 }
13005
13006 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13007 return SWIG_Python_InitShadowInstance(args);
13008 }
13009
13010 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13011 PyObject *resultobj = 0;
13012 int arg1 ;
13013 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13014 int arg3 = (int) wxKILL_NOCHILDREN ;
13015 wxKillError result;
13016 int val1 ;
13017 int ecode1 = 0 ;
13018 int val2 ;
13019 int ecode2 = 0 ;
13020 int val3 ;
13021 int ecode3 = 0 ;
13022 PyObject * obj0 = 0 ;
13023 PyObject * obj1 = 0 ;
13024 PyObject * obj2 = 0 ;
13025 char * kwnames[] = {
13026 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13027 };
13028
13029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13030 ecode1 = SWIG_AsVal_int(obj0, &val1);
13031 if (!SWIG_IsOK(ecode1)) {
13032 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
13033 }
13034 arg1 = static_cast< int >(val1);
13035 if (obj1) {
13036 ecode2 = SWIG_AsVal_int(obj1, &val2);
13037 if (!SWIG_IsOK(ecode2)) {
13038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13039 }
13040 arg2 = static_cast< wxSignal >(val2);
13041 }
13042 if (obj2) {
13043 ecode3 = SWIG_AsVal_int(obj2, &val3);
13044 if (!SWIG_IsOK(ecode3)) {
13045 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
13046 }
13047 arg3 = static_cast< int >(val3);
13048 }
13049 {
13050 PyThreadState* __tstate = wxPyBeginAllowThreads();
13051 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
13052 wxPyEndAllowThreads(__tstate);
13053 if (PyErr_Occurred()) SWIG_fail;
13054 }
13055 resultobj = SWIG_From_int(static_cast< int >(result));
13056 return resultobj;
13057 fail:
13058 return NULL;
13059 }
13060
13061
13062 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13063 PyObject *resultobj = 0;
13064 int arg1 ;
13065 bool result;
13066 int val1 ;
13067 int ecode1 = 0 ;
13068 PyObject * obj0 = 0 ;
13069 char * kwnames[] = {
13070 (char *) "pid", NULL
13071 };
13072
13073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
13074 ecode1 = SWIG_AsVal_int(obj0, &val1);
13075 if (!SWIG_IsOK(ecode1)) {
13076 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
13077 }
13078 arg1 = static_cast< int >(val1);
13079 {
13080 PyThreadState* __tstate = wxPyBeginAllowThreads();
13081 result = (bool)wxPyProcess::Exists(arg1);
13082 wxPyEndAllowThreads(__tstate);
13083 if (PyErr_Occurred()) SWIG_fail;
13084 }
13085 {
13086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13087 }
13088 return resultobj;
13089 fail:
13090 return NULL;
13091 }
13092
13093
13094 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13095 PyObject *resultobj = 0;
13096 wxString *arg1 = 0 ;
13097 int arg2 = (int) wxEXEC_ASYNC ;
13098 wxPyProcess *result = 0 ;
13099 bool temp1 = false ;
13100 int val2 ;
13101 int ecode2 = 0 ;
13102 PyObject * obj0 = 0 ;
13103 PyObject * obj1 = 0 ;
13104 char * kwnames[] = {
13105 (char *) "cmd",(char *) "flags", NULL
13106 };
13107
13108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
13109 {
13110 arg1 = wxString_in_helper(obj0);
13111 if (arg1 == NULL) SWIG_fail;
13112 temp1 = true;
13113 }
13114 if (obj1) {
13115 ecode2 = SWIG_AsVal_int(obj1, &val2);
13116 if (!SWIG_IsOK(ecode2)) {
13117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
13118 }
13119 arg2 = static_cast< int >(val2);
13120 }
13121 {
13122 PyThreadState* __tstate = wxPyBeginAllowThreads();
13123 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
13124 wxPyEndAllowThreads(__tstate);
13125 if (PyErr_Occurred()) SWIG_fail;
13126 }
13127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
13128 {
13129 if (temp1)
13130 delete arg1;
13131 }
13132 return resultobj;
13133 fail:
13134 {
13135 if (temp1)
13136 delete arg1;
13137 }
13138 return NULL;
13139 }
13140
13141
13142 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13143 PyObject *resultobj = 0;
13144 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
13145 int arg2 = (int) -1 ;
13146 wxPyProcess *result = 0 ;
13147 void *argp1 = 0 ;
13148 int res1 = 0 ;
13149 int val2 ;
13150 int ecode2 = 0 ;
13151 PyObject * obj0 = 0 ;
13152 PyObject * obj1 = 0 ;
13153 char * kwnames[] = {
13154 (char *) "parent",(char *) "id", NULL
13155 };
13156
13157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
13158 if (obj0) {
13159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
13160 if (!SWIG_IsOK(res1)) {
13161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
13162 }
13163 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
13164 }
13165 if (obj1) {
13166 ecode2 = SWIG_AsVal_int(obj1, &val2);
13167 if (!SWIG_IsOK(ecode2)) {
13168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
13169 }
13170 arg2 = static_cast< int >(val2);
13171 }
13172 {
13173 PyThreadState* __tstate = wxPyBeginAllowThreads();
13174 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
13175 wxPyEndAllowThreads(__tstate);
13176 if (PyErr_Occurred()) SWIG_fail;
13177 }
13178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
13179 return resultobj;
13180 fail:
13181 return NULL;
13182 }
13183
13184
13185 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13186 PyObject *resultobj = 0;
13187 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13188 PyObject *arg2 = (PyObject *) 0 ;
13189 PyObject *arg3 = (PyObject *) 0 ;
13190 void *argp1 = 0 ;
13191 int res1 = 0 ;
13192 PyObject * obj0 = 0 ;
13193 PyObject * obj1 = 0 ;
13194 PyObject * obj2 = 0 ;
13195 char * kwnames[] = {
13196 (char *) "self",(char *) "self",(char *) "_class", NULL
13197 };
13198
13199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13201 if (!SWIG_IsOK(res1)) {
13202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13203 }
13204 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13205 arg2 = obj1;
13206 arg3 = obj2;
13207 {
13208 PyThreadState* __tstate = wxPyBeginAllowThreads();
13209 (arg1)->_setCallbackInfo(arg2,arg3);
13210 wxPyEndAllowThreads(__tstate);
13211 if (PyErr_Occurred()) SWIG_fail;
13212 }
13213 resultobj = SWIG_Py_Void();
13214 return resultobj;
13215 fail:
13216 return NULL;
13217 }
13218
13219
13220 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13221 PyObject *resultobj = 0;
13222 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13223 int arg2 ;
13224 int arg3 ;
13225 void *argp1 = 0 ;
13226 int res1 = 0 ;
13227 int val2 ;
13228 int ecode2 = 0 ;
13229 int val3 ;
13230 int ecode3 = 0 ;
13231 PyObject * obj0 = 0 ;
13232 PyObject * obj1 = 0 ;
13233 PyObject * obj2 = 0 ;
13234 char * kwnames[] = {
13235 (char *) "self",(char *) "pid",(char *) "status", NULL
13236 };
13237
13238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13240 if (!SWIG_IsOK(res1)) {
13241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13242 }
13243 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13244 ecode2 = SWIG_AsVal_int(obj1, &val2);
13245 if (!SWIG_IsOK(ecode2)) {
13246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
13247 }
13248 arg2 = static_cast< int >(val2);
13249 ecode3 = SWIG_AsVal_int(obj2, &val3);
13250 if (!SWIG_IsOK(ecode3)) {
13251 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
13252 }
13253 arg3 = static_cast< int >(val3);
13254 {
13255 PyThreadState* __tstate = wxPyBeginAllowThreads();
13256 (arg1)->OnTerminate(arg2,arg3);
13257 wxPyEndAllowThreads(__tstate);
13258 if (PyErr_Occurred()) SWIG_fail;
13259 }
13260 resultobj = SWIG_Py_Void();
13261 return resultobj;
13262 fail:
13263 return NULL;
13264 }
13265
13266
13267 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13268 PyObject *resultobj = 0;
13269 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13270 void *argp1 = 0 ;
13271 int res1 = 0 ;
13272 PyObject *swig_obj[1] ;
13273
13274 if (!args) SWIG_fail;
13275 swig_obj[0] = args;
13276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13277 if (!SWIG_IsOK(res1)) {
13278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13279 }
13280 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13281 {
13282 PyThreadState* __tstate = wxPyBeginAllowThreads();
13283 (arg1)->Redirect();
13284 wxPyEndAllowThreads(__tstate);
13285 if (PyErr_Occurred()) SWIG_fail;
13286 }
13287 resultobj = SWIG_Py_Void();
13288 return resultobj;
13289 fail:
13290 return NULL;
13291 }
13292
13293
13294 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13295 PyObject *resultobj = 0;
13296 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13297 bool result;
13298 void *argp1 = 0 ;
13299 int res1 = 0 ;
13300 PyObject *swig_obj[1] ;
13301
13302 if (!args) SWIG_fail;
13303 swig_obj[0] = args;
13304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13305 if (!SWIG_IsOK(res1)) {
13306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13307 }
13308 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13309 {
13310 PyThreadState* __tstate = wxPyBeginAllowThreads();
13311 result = (bool)(arg1)->IsRedirected();
13312 wxPyEndAllowThreads(__tstate);
13313 if (PyErr_Occurred()) SWIG_fail;
13314 }
13315 {
13316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13317 }
13318 return resultobj;
13319 fail:
13320 return NULL;
13321 }
13322
13323
13324 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13325 PyObject *resultobj = 0;
13326 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13327 void *argp1 = 0 ;
13328 int res1 = 0 ;
13329 PyObject *swig_obj[1] ;
13330
13331 if (!args) SWIG_fail;
13332 swig_obj[0] = args;
13333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13334 if (!SWIG_IsOK(res1)) {
13335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13336 }
13337 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13338 {
13339 PyThreadState* __tstate = wxPyBeginAllowThreads();
13340 (arg1)->Detach();
13341 wxPyEndAllowThreads(__tstate);
13342 if (PyErr_Occurred()) SWIG_fail;
13343 }
13344 resultobj = SWIG_Py_Void();
13345 return resultobj;
13346 fail:
13347 return NULL;
13348 }
13349
13350
13351 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13352 PyObject *resultobj = 0;
13353 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13354 wxInputStream *result = 0 ;
13355 void *argp1 = 0 ;
13356 int res1 = 0 ;
13357 PyObject *swig_obj[1] ;
13358
13359 if (!args) SWIG_fail;
13360 swig_obj[0] = args;
13361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13362 if (!SWIG_IsOK(res1)) {
13363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13364 }
13365 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13366 {
13367 PyThreadState* __tstate = wxPyBeginAllowThreads();
13368 result = (wxInputStream *)(arg1)->GetInputStream();
13369 wxPyEndAllowThreads(__tstate);
13370 if (PyErr_Occurred()) SWIG_fail;
13371 }
13372 {
13373 wxPyInputStream * _ptr = NULL;
13374
13375 if (result) {
13376 _ptr = new wxPyInputStream(result);
13377 }
13378 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13379 }
13380 return resultobj;
13381 fail:
13382 return NULL;
13383 }
13384
13385
13386 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13387 PyObject *resultobj = 0;
13388 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13389 wxInputStream *result = 0 ;
13390 void *argp1 = 0 ;
13391 int res1 = 0 ;
13392 PyObject *swig_obj[1] ;
13393
13394 if (!args) SWIG_fail;
13395 swig_obj[0] = args;
13396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13397 if (!SWIG_IsOK(res1)) {
13398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13399 }
13400 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13401 {
13402 PyThreadState* __tstate = wxPyBeginAllowThreads();
13403 result = (wxInputStream *)(arg1)->GetErrorStream();
13404 wxPyEndAllowThreads(__tstate);
13405 if (PyErr_Occurred()) SWIG_fail;
13406 }
13407 {
13408 wxPyInputStream * _ptr = NULL;
13409
13410 if (result) {
13411 _ptr = new wxPyInputStream(result);
13412 }
13413 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13414 }
13415 return resultobj;
13416 fail:
13417 return NULL;
13418 }
13419
13420
13421 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13422 PyObject *resultobj = 0;
13423 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13424 wxOutputStream *result = 0 ;
13425 void *argp1 = 0 ;
13426 int res1 = 0 ;
13427 PyObject *swig_obj[1] ;
13428
13429 if (!args) SWIG_fail;
13430 swig_obj[0] = args;
13431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13432 if (!SWIG_IsOK(res1)) {
13433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13434 }
13435 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13436 {
13437 PyThreadState* __tstate = wxPyBeginAllowThreads();
13438 result = (wxOutputStream *)(arg1)->GetOutputStream();
13439 wxPyEndAllowThreads(__tstate);
13440 if (PyErr_Occurred()) SWIG_fail;
13441 }
13442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
13443 return resultobj;
13444 fail:
13445 return NULL;
13446 }
13447
13448
13449 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13450 PyObject *resultobj = 0;
13451 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13452 void *argp1 = 0 ;
13453 int res1 = 0 ;
13454 PyObject *swig_obj[1] ;
13455
13456 if (!args) SWIG_fail;
13457 swig_obj[0] = args;
13458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13459 if (!SWIG_IsOK(res1)) {
13460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13461 }
13462 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13463 {
13464 PyThreadState* __tstate = wxPyBeginAllowThreads();
13465 (arg1)->CloseOutput();
13466 wxPyEndAllowThreads(__tstate);
13467 if (PyErr_Occurred()) SWIG_fail;
13468 }
13469 resultobj = SWIG_Py_Void();
13470 return resultobj;
13471 fail:
13472 return NULL;
13473 }
13474
13475
13476 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13477 PyObject *resultobj = 0;
13478 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13479 bool result;
13480 void *argp1 = 0 ;
13481 int res1 = 0 ;
13482 PyObject *swig_obj[1] ;
13483
13484 if (!args) SWIG_fail;
13485 swig_obj[0] = args;
13486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13487 if (!SWIG_IsOK(res1)) {
13488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13489 }
13490 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13491 {
13492 PyThreadState* __tstate = wxPyBeginAllowThreads();
13493 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
13494 wxPyEndAllowThreads(__tstate);
13495 if (PyErr_Occurred()) SWIG_fail;
13496 }
13497 {
13498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13499 }
13500 return resultobj;
13501 fail:
13502 return NULL;
13503 }
13504
13505
13506 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13507 PyObject *resultobj = 0;
13508 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13509 bool result;
13510 void *argp1 = 0 ;
13511 int res1 = 0 ;
13512 PyObject *swig_obj[1] ;
13513
13514 if (!args) SWIG_fail;
13515 swig_obj[0] = args;
13516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13517 if (!SWIG_IsOK(res1)) {
13518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13519 }
13520 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13521 {
13522 PyThreadState* __tstate = wxPyBeginAllowThreads();
13523 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
13524 wxPyEndAllowThreads(__tstate);
13525 if (PyErr_Occurred()) SWIG_fail;
13526 }
13527 {
13528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13529 }
13530 return resultobj;
13531 fail:
13532 return NULL;
13533 }
13534
13535
13536 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13537 PyObject *resultobj = 0;
13538 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13539 bool result;
13540 void *argp1 = 0 ;
13541 int res1 = 0 ;
13542 PyObject *swig_obj[1] ;
13543
13544 if (!args) SWIG_fail;
13545 swig_obj[0] = args;
13546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13547 if (!SWIG_IsOK(res1)) {
13548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13549 }
13550 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13551 {
13552 PyThreadState* __tstate = wxPyBeginAllowThreads();
13553 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
13554 wxPyEndAllowThreads(__tstate);
13555 if (PyErr_Occurred()) SWIG_fail;
13556 }
13557 {
13558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13559 }
13560 return resultobj;
13561 fail:
13562 return NULL;
13563 }
13564
13565
13566 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13567 PyObject *obj;
13568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13569 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
13570 return SWIG_Py_Void();
13571 }
13572
13573 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13574 return SWIG_Python_InitShadowInstance(args);
13575 }
13576
13577 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13578 PyObject *resultobj = 0;
13579 int arg1 = (int) 0 ;
13580 int arg2 = (int) 0 ;
13581 int arg3 = (int) 0 ;
13582 wxProcessEvent *result = 0 ;
13583 int val1 ;
13584 int ecode1 = 0 ;
13585 int val2 ;
13586 int ecode2 = 0 ;
13587 int val3 ;
13588 int ecode3 = 0 ;
13589 PyObject * obj0 = 0 ;
13590 PyObject * obj1 = 0 ;
13591 PyObject * obj2 = 0 ;
13592 char * kwnames[] = {
13593 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
13594 };
13595
13596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13597 if (obj0) {
13598 ecode1 = SWIG_AsVal_int(obj0, &val1);
13599 if (!SWIG_IsOK(ecode1)) {
13600 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
13601 }
13602 arg1 = static_cast< int >(val1);
13603 }
13604 if (obj1) {
13605 ecode2 = SWIG_AsVal_int(obj1, &val2);
13606 if (!SWIG_IsOK(ecode2)) {
13607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
13608 }
13609 arg2 = static_cast< int >(val2);
13610 }
13611 if (obj2) {
13612 ecode3 = SWIG_AsVal_int(obj2, &val3);
13613 if (!SWIG_IsOK(ecode3)) {
13614 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
13615 }
13616 arg3 = static_cast< int >(val3);
13617 }
13618 {
13619 PyThreadState* __tstate = wxPyBeginAllowThreads();
13620 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
13621 wxPyEndAllowThreads(__tstate);
13622 if (PyErr_Occurred()) SWIG_fail;
13623 }
13624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
13625 return resultobj;
13626 fail:
13627 return NULL;
13628 }
13629
13630
13631 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13632 PyObject *resultobj = 0;
13633 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13634 int result;
13635 void *argp1 = 0 ;
13636 int res1 = 0 ;
13637 PyObject *swig_obj[1] ;
13638
13639 if (!args) SWIG_fail;
13640 swig_obj[0] = args;
13641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13642 if (!SWIG_IsOK(res1)) {
13643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13644 }
13645 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13646 {
13647 PyThreadState* __tstate = wxPyBeginAllowThreads();
13648 result = (int)(arg1)->GetPid();
13649 wxPyEndAllowThreads(__tstate);
13650 if (PyErr_Occurred()) SWIG_fail;
13651 }
13652 resultobj = SWIG_From_int(static_cast< int >(result));
13653 return resultobj;
13654 fail:
13655 return NULL;
13656 }
13657
13658
13659 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13660 PyObject *resultobj = 0;
13661 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13662 int result;
13663 void *argp1 = 0 ;
13664 int res1 = 0 ;
13665 PyObject *swig_obj[1] ;
13666
13667 if (!args) SWIG_fail;
13668 swig_obj[0] = args;
13669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13670 if (!SWIG_IsOK(res1)) {
13671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13672 }
13673 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13674 {
13675 PyThreadState* __tstate = wxPyBeginAllowThreads();
13676 result = (int)(arg1)->GetExitCode();
13677 wxPyEndAllowThreads(__tstate);
13678 if (PyErr_Occurred()) SWIG_fail;
13679 }
13680 resultobj = SWIG_From_int(static_cast< int >(result));
13681 return resultobj;
13682 fail:
13683 return NULL;
13684 }
13685
13686
13687 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13688 PyObject *resultobj = 0;
13689 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13690 int arg2 ;
13691 void *argp1 = 0 ;
13692 int res1 = 0 ;
13693 int val2 ;
13694 int ecode2 = 0 ;
13695 PyObject *swig_obj[2] ;
13696
13697 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
13698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13699 if (!SWIG_IsOK(res1)) {
13700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13701 }
13702 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13703 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13704 if (!SWIG_IsOK(ecode2)) {
13705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
13706 }
13707 arg2 = static_cast< int >(val2);
13708 if (arg1) (arg1)->m_pid = arg2;
13709
13710 resultobj = SWIG_Py_Void();
13711 return resultobj;
13712 fail:
13713 return NULL;
13714 }
13715
13716
13717 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13718 PyObject *resultobj = 0;
13719 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13720 int result;
13721 void *argp1 = 0 ;
13722 int res1 = 0 ;
13723 PyObject *swig_obj[1] ;
13724
13725 if (!args) SWIG_fail;
13726 swig_obj[0] = args;
13727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13728 if (!SWIG_IsOK(res1)) {
13729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13730 }
13731 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13732 result = (int) ((arg1)->m_pid);
13733 resultobj = SWIG_From_int(static_cast< int >(result));
13734 return resultobj;
13735 fail:
13736 return NULL;
13737 }
13738
13739
13740 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13741 PyObject *resultobj = 0;
13742 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13743 int arg2 ;
13744 void *argp1 = 0 ;
13745 int res1 = 0 ;
13746 int val2 ;
13747 int ecode2 = 0 ;
13748 PyObject *swig_obj[2] ;
13749
13750 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
13751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13752 if (!SWIG_IsOK(res1)) {
13753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13754 }
13755 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13756 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13757 if (!SWIG_IsOK(ecode2)) {
13758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
13759 }
13760 arg2 = static_cast< int >(val2);
13761 if (arg1) (arg1)->m_exitcode = arg2;
13762
13763 resultobj = SWIG_Py_Void();
13764 return resultobj;
13765 fail:
13766 return NULL;
13767 }
13768
13769
13770 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13771 PyObject *resultobj = 0;
13772 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13773 int result;
13774 void *argp1 = 0 ;
13775 int res1 = 0 ;
13776 PyObject *swig_obj[1] ;
13777
13778 if (!args) SWIG_fail;
13779 swig_obj[0] = args;
13780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13781 if (!SWIG_IsOK(res1)) {
13782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13783 }
13784 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13785 result = (int) ((arg1)->m_exitcode);
13786 resultobj = SWIG_From_int(static_cast< int >(result));
13787 return resultobj;
13788 fail:
13789 return NULL;
13790 }
13791
13792
13793 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13794 PyObject *obj;
13795 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13796 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
13797 return SWIG_Py_Void();
13798 }
13799
13800 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13801 return SWIG_Python_InitShadowInstance(args);
13802 }
13803
13804 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13805 PyObject *resultobj = 0;
13806 wxString *arg1 = 0 ;
13807 int arg2 = (int) wxEXEC_ASYNC ;
13808 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
13809 long result;
13810 bool temp1 = false ;
13811 int val2 ;
13812 int ecode2 = 0 ;
13813 void *argp3 = 0 ;
13814 int res3 = 0 ;
13815 PyObject * obj0 = 0 ;
13816 PyObject * obj1 = 0 ;
13817 PyObject * obj2 = 0 ;
13818 char * kwnames[] = {
13819 (char *) "command",(char *) "flags",(char *) "process", NULL
13820 };
13821
13822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13823 {
13824 arg1 = wxString_in_helper(obj0);
13825 if (arg1 == NULL) SWIG_fail;
13826 temp1 = true;
13827 }
13828 if (obj1) {
13829 ecode2 = SWIG_AsVal_int(obj1, &val2);
13830 if (!SWIG_IsOK(ecode2)) {
13831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
13832 }
13833 arg2 = static_cast< int >(val2);
13834 }
13835 if (obj2) {
13836 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13837 if (!SWIG_IsOK(res3)) {
13838 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
13839 }
13840 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
13841 }
13842 {
13843 if (!wxPyCheckForApp()) SWIG_fail;
13844 PyThreadState* __tstate = wxPyBeginAllowThreads();
13845 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
13846 wxPyEndAllowThreads(__tstate);
13847 if (PyErr_Occurred()) SWIG_fail;
13848 }
13849 resultobj = SWIG_From_long(static_cast< long >(result));
13850 {
13851 if (temp1)
13852 delete arg1;
13853 }
13854 return resultobj;
13855 fail:
13856 {
13857 if (temp1)
13858 delete arg1;
13859 }
13860 return NULL;
13861 }
13862
13863
13864 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13865 PyObject *resultobj = 0;
13866 long arg1 ;
13867 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13868 wxKillError *arg3 = (wxKillError *) 0 ;
13869 int arg4 = (int) wxKILL_NOCHILDREN ;
13870 int result;
13871 long val1 ;
13872 int ecode1 = 0 ;
13873 int val2 ;
13874 int ecode2 = 0 ;
13875 wxKillError temp3 ;
13876 int val4 ;
13877 int ecode4 = 0 ;
13878 PyObject * obj0 = 0 ;
13879 PyObject * obj1 = 0 ;
13880 PyObject * obj2 = 0 ;
13881 char * kwnames[] = {
13882 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13883 };
13884
13885 {
13886 arg3 = &temp3;
13887 }
13888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13889 ecode1 = SWIG_AsVal_long(obj0, &val1);
13890 if (!SWIG_IsOK(ecode1)) {
13891 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
13892 }
13893 arg1 = static_cast< long >(val1);
13894 if (obj1) {
13895 ecode2 = SWIG_AsVal_int(obj1, &val2);
13896 if (!SWIG_IsOK(ecode2)) {
13897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13898 }
13899 arg2 = static_cast< wxSignal >(val2);
13900 }
13901 if (obj2) {
13902 ecode4 = SWIG_AsVal_int(obj2, &val4);
13903 if (!SWIG_IsOK(ecode4)) {
13904 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
13905 }
13906 arg4 = static_cast< int >(val4);
13907 }
13908 {
13909 PyThreadState* __tstate = wxPyBeginAllowThreads();
13910 result = (int)wxKill(arg1,arg2,arg3,arg4);
13911 wxPyEndAllowThreads(__tstate);
13912 if (PyErr_Occurred()) SWIG_fail;
13913 }
13914 resultobj = SWIG_From_int(static_cast< int >(result));
13915 {
13916 PyObject* o;
13917 o = PyInt_FromLong((long) (*arg3));
13918
13919
13920
13921 resultobj = SWIG_Python_AppendOutput(resultobj, o);
13922
13923 }
13924 return resultobj;
13925 fail:
13926 return NULL;
13927 }
13928
13929
13930 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13931 PyObject *resultobj = 0;
13932 int arg1 = (int) wxJOYSTICK1 ;
13933 wxJoystick *result = 0 ;
13934 int val1 ;
13935 int ecode1 = 0 ;
13936 PyObject * obj0 = 0 ;
13937 char * kwnames[] = {
13938 (char *) "joystick", NULL
13939 };
13940
13941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
13942 if (obj0) {
13943 ecode1 = SWIG_AsVal_int(obj0, &val1);
13944 if (!SWIG_IsOK(ecode1)) {
13945 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
13946 }
13947 arg1 = static_cast< int >(val1);
13948 }
13949 {
13950 if (!wxPyCheckForApp()) SWIG_fail;
13951 PyThreadState* __tstate = wxPyBeginAllowThreads();
13952 result = (wxJoystick *)new wxJoystick(arg1);
13953 wxPyEndAllowThreads(__tstate);
13954 if (PyErr_Occurred()) SWIG_fail;
13955 }
13956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
13957 return resultobj;
13958 fail:
13959 return NULL;
13960 }
13961
13962
13963 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13964 PyObject *resultobj = 0;
13965 wxJoystick *arg1 = (wxJoystick *) 0 ;
13966 void *argp1 = 0 ;
13967 int res1 = 0 ;
13968 PyObject *swig_obj[1] ;
13969
13970 if (!args) SWIG_fail;
13971 swig_obj[0] = args;
13972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
13973 if (!SWIG_IsOK(res1)) {
13974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
13975 }
13976 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13977 {
13978 PyThreadState* __tstate = wxPyBeginAllowThreads();
13979 delete arg1;
13980
13981 wxPyEndAllowThreads(__tstate);
13982 if (PyErr_Occurred()) SWIG_fail;
13983 }
13984 resultobj = SWIG_Py_Void();
13985 return resultobj;
13986 fail:
13987 return NULL;
13988 }
13989
13990
13991 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13992 PyObject *resultobj = 0;
13993 wxJoystick *arg1 = (wxJoystick *) 0 ;
13994 wxPoint result;
13995 void *argp1 = 0 ;
13996 int res1 = 0 ;
13997 PyObject *swig_obj[1] ;
13998
13999 if (!args) SWIG_fail;
14000 swig_obj[0] = args;
14001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14002 if (!SWIG_IsOK(res1)) {
14003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14004 }
14005 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14006 {
14007 PyThreadState* __tstate = wxPyBeginAllowThreads();
14008 result = (arg1)->GetPosition();
14009 wxPyEndAllowThreads(__tstate);
14010 if (PyErr_Occurred()) SWIG_fail;
14011 }
14012 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
14013 return resultobj;
14014 fail:
14015 return NULL;
14016 }
14017
14018
14019 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14020 PyObject *resultobj = 0;
14021 wxJoystick *arg1 = (wxJoystick *) 0 ;
14022 int result;
14023 void *argp1 = 0 ;
14024 int res1 = 0 ;
14025 PyObject *swig_obj[1] ;
14026
14027 if (!args) SWIG_fail;
14028 swig_obj[0] = args;
14029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14030 if (!SWIG_IsOK(res1)) {
14031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14032 }
14033 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14034 {
14035 PyThreadState* __tstate = wxPyBeginAllowThreads();
14036 result = (int)(arg1)->GetZPosition();
14037 wxPyEndAllowThreads(__tstate);
14038 if (PyErr_Occurred()) SWIG_fail;
14039 }
14040 resultobj = SWIG_From_int(static_cast< int >(result));
14041 return resultobj;
14042 fail:
14043 return NULL;
14044 }
14045
14046
14047 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14048 PyObject *resultobj = 0;
14049 wxJoystick *arg1 = (wxJoystick *) 0 ;
14050 int result;
14051 void *argp1 = 0 ;
14052 int res1 = 0 ;
14053 PyObject *swig_obj[1] ;
14054
14055 if (!args) SWIG_fail;
14056 swig_obj[0] = args;
14057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14058 if (!SWIG_IsOK(res1)) {
14059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
14060 }
14061 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14062 {
14063 PyThreadState* __tstate = wxPyBeginAllowThreads();
14064 result = (int)(arg1)->GetButtonState();
14065 wxPyEndAllowThreads(__tstate);
14066 if (PyErr_Occurred()) SWIG_fail;
14067 }
14068 resultobj = SWIG_From_int(static_cast< int >(result));
14069 return resultobj;
14070 fail:
14071 return NULL;
14072 }
14073
14074
14075 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14076 PyObject *resultobj = 0;
14077 wxJoystick *arg1 = (wxJoystick *) 0 ;
14078 int result;
14079 void *argp1 = 0 ;
14080 int res1 = 0 ;
14081 PyObject *swig_obj[1] ;
14082
14083 if (!args) SWIG_fail;
14084 swig_obj[0] = args;
14085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14086 if (!SWIG_IsOK(res1)) {
14087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14088 }
14089 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14090 {
14091 PyThreadState* __tstate = wxPyBeginAllowThreads();
14092 result = (int)(arg1)->GetPOVPosition();
14093 wxPyEndAllowThreads(__tstate);
14094 if (PyErr_Occurred()) SWIG_fail;
14095 }
14096 resultobj = SWIG_From_int(static_cast< int >(result));
14097 return resultobj;
14098 fail:
14099 return NULL;
14100 }
14101
14102
14103 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14104 PyObject *resultobj = 0;
14105 wxJoystick *arg1 = (wxJoystick *) 0 ;
14106 int result;
14107 void *argp1 = 0 ;
14108 int res1 = 0 ;
14109 PyObject *swig_obj[1] ;
14110
14111 if (!args) SWIG_fail;
14112 swig_obj[0] = args;
14113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14114 if (!SWIG_IsOK(res1)) {
14115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14116 }
14117 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14118 {
14119 PyThreadState* __tstate = wxPyBeginAllowThreads();
14120 result = (int)(arg1)->GetPOVCTSPosition();
14121 wxPyEndAllowThreads(__tstate);
14122 if (PyErr_Occurred()) SWIG_fail;
14123 }
14124 resultobj = SWIG_From_int(static_cast< int >(result));
14125 return resultobj;
14126 fail:
14127 return NULL;
14128 }
14129
14130
14131 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14132 PyObject *resultobj = 0;
14133 wxJoystick *arg1 = (wxJoystick *) 0 ;
14134 int result;
14135 void *argp1 = 0 ;
14136 int res1 = 0 ;
14137 PyObject *swig_obj[1] ;
14138
14139 if (!args) SWIG_fail;
14140 swig_obj[0] = args;
14141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14142 if (!SWIG_IsOK(res1)) {
14143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14144 }
14145 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14146 {
14147 PyThreadState* __tstate = wxPyBeginAllowThreads();
14148 result = (int)(arg1)->GetRudderPosition();
14149 wxPyEndAllowThreads(__tstate);
14150 if (PyErr_Occurred()) SWIG_fail;
14151 }
14152 resultobj = SWIG_From_int(static_cast< int >(result));
14153 return resultobj;
14154 fail:
14155 return NULL;
14156 }
14157
14158
14159 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14160 PyObject *resultobj = 0;
14161 wxJoystick *arg1 = (wxJoystick *) 0 ;
14162 int result;
14163 void *argp1 = 0 ;
14164 int res1 = 0 ;
14165 PyObject *swig_obj[1] ;
14166
14167 if (!args) SWIG_fail;
14168 swig_obj[0] = args;
14169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14170 if (!SWIG_IsOK(res1)) {
14171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14172 }
14173 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14174 {
14175 PyThreadState* __tstate = wxPyBeginAllowThreads();
14176 result = (int)(arg1)->GetUPosition();
14177 wxPyEndAllowThreads(__tstate);
14178 if (PyErr_Occurred()) SWIG_fail;
14179 }
14180 resultobj = SWIG_From_int(static_cast< int >(result));
14181 return resultobj;
14182 fail:
14183 return NULL;
14184 }
14185
14186
14187 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14188 PyObject *resultobj = 0;
14189 wxJoystick *arg1 = (wxJoystick *) 0 ;
14190 int result;
14191 void *argp1 = 0 ;
14192 int res1 = 0 ;
14193 PyObject *swig_obj[1] ;
14194
14195 if (!args) SWIG_fail;
14196 swig_obj[0] = args;
14197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14198 if (!SWIG_IsOK(res1)) {
14199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14200 }
14201 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14202 {
14203 PyThreadState* __tstate = wxPyBeginAllowThreads();
14204 result = (int)(arg1)->GetVPosition();
14205 wxPyEndAllowThreads(__tstate);
14206 if (PyErr_Occurred()) SWIG_fail;
14207 }
14208 resultobj = SWIG_From_int(static_cast< int >(result));
14209 return resultobj;
14210 fail:
14211 return NULL;
14212 }
14213
14214
14215 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14216 PyObject *resultobj = 0;
14217 wxJoystick *arg1 = (wxJoystick *) 0 ;
14218 int result;
14219 void *argp1 = 0 ;
14220 int res1 = 0 ;
14221 PyObject *swig_obj[1] ;
14222
14223 if (!args) SWIG_fail;
14224 swig_obj[0] = args;
14225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14226 if (!SWIG_IsOK(res1)) {
14227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14228 }
14229 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14230 {
14231 PyThreadState* __tstate = wxPyBeginAllowThreads();
14232 result = (int)(arg1)->GetMovementThreshold();
14233 wxPyEndAllowThreads(__tstate);
14234 if (PyErr_Occurred()) SWIG_fail;
14235 }
14236 resultobj = SWIG_From_int(static_cast< int >(result));
14237 return resultobj;
14238 fail:
14239 return NULL;
14240 }
14241
14242
14243 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14244 PyObject *resultobj = 0;
14245 wxJoystick *arg1 = (wxJoystick *) 0 ;
14246 int arg2 ;
14247 void *argp1 = 0 ;
14248 int res1 = 0 ;
14249 int val2 ;
14250 int ecode2 = 0 ;
14251 PyObject * obj0 = 0 ;
14252 PyObject * obj1 = 0 ;
14253 char * kwnames[] = {
14254 (char *) "self",(char *) "threshold", NULL
14255 };
14256
14257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
14258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14259 if (!SWIG_IsOK(res1)) {
14260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14261 }
14262 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14263 ecode2 = SWIG_AsVal_int(obj1, &val2);
14264 if (!SWIG_IsOK(ecode2)) {
14265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
14266 }
14267 arg2 = static_cast< int >(val2);
14268 {
14269 PyThreadState* __tstate = wxPyBeginAllowThreads();
14270 (arg1)->SetMovementThreshold(arg2);
14271 wxPyEndAllowThreads(__tstate);
14272 if (PyErr_Occurred()) SWIG_fail;
14273 }
14274 resultobj = SWIG_Py_Void();
14275 return resultobj;
14276 fail:
14277 return NULL;
14278 }
14279
14280
14281 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14282 PyObject *resultobj = 0;
14283 wxJoystick *arg1 = (wxJoystick *) 0 ;
14284 bool result;
14285 void *argp1 = 0 ;
14286 int res1 = 0 ;
14287 PyObject *swig_obj[1] ;
14288
14289 if (!args) SWIG_fail;
14290 swig_obj[0] = args;
14291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14292 if (!SWIG_IsOK(res1)) {
14293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
14294 }
14295 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14296 {
14297 PyThreadState* __tstate = wxPyBeginAllowThreads();
14298 result = (bool)(arg1)->IsOk();
14299 wxPyEndAllowThreads(__tstate);
14300 if (PyErr_Occurred()) SWIG_fail;
14301 }
14302 {
14303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14304 }
14305 return resultobj;
14306 fail:
14307 return NULL;
14308 }
14309
14310
14311 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14312 PyObject *resultobj = 0;
14313 wxJoystick *arg1 = (wxJoystick *) 0 ;
14314 int result;
14315 void *argp1 = 0 ;
14316 int res1 = 0 ;
14317 PyObject *swig_obj[1] ;
14318
14319 if (!args) SWIG_fail;
14320 swig_obj[0] = args;
14321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14322 if (!SWIG_IsOK(res1)) {
14323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
14324 }
14325 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14326 {
14327 PyThreadState* __tstate = wxPyBeginAllowThreads();
14328 result = (int)(arg1)->GetNumberJoysticks();
14329 wxPyEndAllowThreads(__tstate);
14330 if (PyErr_Occurred()) SWIG_fail;
14331 }
14332 resultobj = SWIG_From_int(static_cast< int >(result));
14333 return resultobj;
14334 fail:
14335 return NULL;
14336 }
14337
14338
14339 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14340 PyObject *resultobj = 0;
14341 wxJoystick *arg1 = (wxJoystick *) 0 ;
14342 int result;
14343 void *argp1 = 0 ;
14344 int res1 = 0 ;
14345 PyObject *swig_obj[1] ;
14346
14347 if (!args) SWIG_fail;
14348 swig_obj[0] = args;
14349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14350 if (!SWIG_IsOK(res1)) {
14351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14352 }
14353 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14354 {
14355 PyThreadState* __tstate = wxPyBeginAllowThreads();
14356 result = (int)(arg1)->GetManufacturerId();
14357 wxPyEndAllowThreads(__tstate);
14358 if (PyErr_Occurred()) SWIG_fail;
14359 }
14360 resultobj = SWIG_From_int(static_cast< int >(result));
14361 return resultobj;
14362 fail:
14363 return NULL;
14364 }
14365
14366
14367 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14368 PyObject *resultobj = 0;
14369 wxJoystick *arg1 = (wxJoystick *) 0 ;
14370 int result;
14371 void *argp1 = 0 ;
14372 int res1 = 0 ;
14373 PyObject *swig_obj[1] ;
14374
14375 if (!args) SWIG_fail;
14376 swig_obj[0] = args;
14377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14378 if (!SWIG_IsOK(res1)) {
14379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14380 }
14381 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14382 {
14383 PyThreadState* __tstate = wxPyBeginAllowThreads();
14384 result = (int)(arg1)->GetProductId();
14385 wxPyEndAllowThreads(__tstate);
14386 if (PyErr_Occurred()) SWIG_fail;
14387 }
14388 resultobj = SWIG_From_int(static_cast< int >(result));
14389 return resultobj;
14390 fail:
14391 return NULL;
14392 }
14393
14394
14395 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14396 PyObject *resultobj = 0;
14397 wxJoystick *arg1 = (wxJoystick *) 0 ;
14398 wxString result;
14399 void *argp1 = 0 ;
14400 int res1 = 0 ;
14401 PyObject *swig_obj[1] ;
14402
14403 if (!args) SWIG_fail;
14404 swig_obj[0] = args;
14405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14406 if (!SWIG_IsOK(res1)) {
14407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
14408 }
14409 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14410 {
14411 PyThreadState* __tstate = wxPyBeginAllowThreads();
14412 result = (arg1)->GetProductName();
14413 wxPyEndAllowThreads(__tstate);
14414 if (PyErr_Occurred()) SWIG_fail;
14415 }
14416 {
14417 #if wxUSE_UNICODE
14418 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14419 #else
14420 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14421 #endif
14422 }
14423 return resultobj;
14424 fail:
14425 return NULL;
14426 }
14427
14428
14429 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14430 PyObject *resultobj = 0;
14431 wxJoystick *arg1 = (wxJoystick *) 0 ;
14432 int result;
14433 void *argp1 = 0 ;
14434 int res1 = 0 ;
14435 PyObject *swig_obj[1] ;
14436
14437 if (!args) SWIG_fail;
14438 swig_obj[0] = args;
14439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14440 if (!SWIG_IsOK(res1)) {
14441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14442 }
14443 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14444 {
14445 PyThreadState* __tstate = wxPyBeginAllowThreads();
14446 result = (int)(arg1)->GetXMin();
14447 wxPyEndAllowThreads(__tstate);
14448 if (PyErr_Occurred()) SWIG_fail;
14449 }
14450 resultobj = SWIG_From_int(static_cast< int >(result));
14451 return resultobj;
14452 fail:
14453 return NULL;
14454 }
14455
14456
14457 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14458 PyObject *resultobj = 0;
14459 wxJoystick *arg1 = (wxJoystick *) 0 ;
14460 int result;
14461 void *argp1 = 0 ;
14462 int res1 = 0 ;
14463 PyObject *swig_obj[1] ;
14464
14465 if (!args) SWIG_fail;
14466 swig_obj[0] = args;
14467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14468 if (!SWIG_IsOK(res1)) {
14469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14470 }
14471 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14472 {
14473 PyThreadState* __tstate = wxPyBeginAllowThreads();
14474 result = (int)(arg1)->GetYMin();
14475 wxPyEndAllowThreads(__tstate);
14476 if (PyErr_Occurred()) SWIG_fail;
14477 }
14478 resultobj = SWIG_From_int(static_cast< int >(result));
14479 return resultobj;
14480 fail:
14481 return NULL;
14482 }
14483
14484
14485 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14486 PyObject *resultobj = 0;
14487 wxJoystick *arg1 = (wxJoystick *) 0 ;
14488 int result;
14489 void *argp1 = 0 ;
14490 int res1 = 0 ;
14491 PyObject *swig_obj[1] ;
14492
14493 if (!args) SWIG_fail;
14494 swig_obj[0] = args;
14495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14496 if (!SWIG_IsOK(res1)) {
14497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14498 }
14499 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14500 {
14501 PyThreadState* __tstate = wxPyBeginAllowThreads();
14502 result = (int)(arg1)->GetZMin();
14503 wxPyEndAllowThreads(__tstate);
14504 if (PyErr_Occurred()) SWIG_fail;
14505 }
14506 resultobj = SWIG_From_int(static_cast< int >(result));
14507 return resultobj;
14508 fail:
14509 return NULL;
14510 }
14511
14512
14513 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14514 PyObject *resultobj = 0;
14515 wxJoystick *arg1 = (wxJoystick *) 0 ;
14516 int result;
14517 void *argp1 = 0 ;
14518 int res1 = 0 ;
14519 PyObject *swig_obj[1] ;
14520
14521 if (!args) SWIG_fail;
14522 swig_obj[0] = args;
14523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14524 if (!SWIG_IsOK(res1)) {
14525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14526 }
14527 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14528 {
14529 PyThreadState* __tstate = wxPyBeginAllowThreads();
14530 result = (int)(arg1)->GetXMax();
14531 wxPyEndAllowThreads(__tstate);
14532 if (PyErr_Occurred()) SWIG_fail;
14533 }
14534 resultobj = SWIG_From_int(static_cast< int >(result));
14535 return resultobj;
14536 fail:
14537 return NULL;
14538 }
14539
14540
14541 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14542 PyObject *resultobj = 0;
14543 wxJoystick *arg1 = (wxJoystick *) 0 ;
14544 int result;
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_wxJoystick, 0 | 0 );
14552 if (!SWIG_IsOK(res1)) {
14553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14554 }
14555 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14556 {
14557 PyThreadState* __tstate = wxPyBeginAllowThreads();
14558 result = (int)(arg1)->GetYMax();
14559 wxPyEndAllowThreads(__tstate);
14560 if (PyErr_Occurred()) SWIG_fail;
14561 }
14562 resultobj = SWIG_From_int(static_cast< int >(result));
14563 return resultobj;
14564 fail:
14565 return NULL;
14566 }
14567
14568
14569 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14570 PyObject *resultobj = 0;
14571 wxJoystick *arg1 = (wxJoystick *) 0 ;
14572 int 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_wxJoystick, 0 | 0 );
14580 if (!SWIG_IsOK(res1)) {
14581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14582 }
14583 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14584 {
14585 PyThreadState* __tstate = wxPyBeginAllowThreads();
14586 result = (int)(arg1)->GetZMax();
14587 wxPyEndAllowThreads(__tstate);
14588 if (PyErr_Occurred()) SWIG_fail;
14589 }
14590 resultobj = SWIG_From_int(static_cast< int >(result));
14591 return resultobj;
14592 fail:
14593 return NULL;
14594 }
14595
14596
14597 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14598 PyObject *resultobj = 0;
14599 wxJoystick *arg1 = (wxJoystick *) 0 ;
14600 int result;
14601 void *argp1 = 0 ;
14602 int res1 = 0 ;
14603 PyObject *swig_obj[1] ;
14604
14605 if (!args) SWIG_fail;
14606 swig_obj[0] = args;
14607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14608 if (!SWIG_IsOK(res1)) {
14609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14610 }
14611 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14612 {
14613 PyThreadState* __tstate = wxPyBeginAllowThreads();
14614 result = (int)(arg1)->GetNumberButtons();
14615 wxPyEndAllowThreads(__tstate);
14616 if (PyErr_Occurred()) SWIG_fail;
14617 }
14618 resultobj = SWIG_From_int(static_cast< int >(result));
14619 return resultobj;
14620 fail:
14621 return NULL;
14622 }
14623
14624
14625 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14626 PyObject *resultobj = 0;
14627 wxJoystick *arg1 = (wxJoystick *) 0 ;
14628 int result;
14629 void *argp1 = 0 ;
14630 int res1 = 0 ;
14631 PyObject *swig_obj[1] ;
14632
14633 if (!args) SWIG_fail;
14634 swig_obj[0] = args;
14635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14636 if (!SWIG_IsOK(res1)) {
14637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14638 }
14639 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14640 {
14641 PyThreadState* __tstate = wxPyBeginAllowThreads();
14642 result = (int)(arg1)->GetNumberAxes();
14643 wxPyEndAllowThreads(__tstate);
14644 if (PyErr_Occurred()) SWIG_fail;
14645 }
14646 resultobj = SWIG_From_int(static_cast< int >(result));
14647 return resultobj;
14648 fail:
14649 return NULL;
14650 }
14651
14652
14653 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14654 PyObject *resultobj = 0;
14655 wxJoystick *arg1 = (wxJoystick *) 0 ;
14656 int result;
14657 void *argp1 = 0 ;
14658 int res1 = 0 ;
14659 PyObject *swig_obj[1] ;
14660
14661 if (!args) SWIG_fail;
14662 swig_obj[0] = args;
14663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14664 if (!SWIG_IsOK(res1)) {
14665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14666 }
14667 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14668 {
14669 PyThreadState* __tstate = wxPyBeginAllowThreads();
14670 result = (int)(arg1)->GetMaxButtons();
14671 wxPyEndAllowThreads(__tstate);
14672 if (PyErr_Occurred()) SWIG_fail;
14673 }
14674 resultobj = SWIG_From_int(static_cast< int >(result));
14675 return resultobj;
14676 fail:
14677 return NULL;
14678 }
14679
14680
14681 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14682 PyObject *resultobj = 0;
14683 wxJoystick *arg1 = (wxJoystick *) 0 ;
14684 int result;
14685 void *argp1 = 0 ;
14686 int res1 = 0 ;
14687 PyObject *swig_obj[1] ;
14688
14689 if (!args) SWIG_fail;
14690 swig_obj[0] = args;
14691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14692 if (!SWIG_IsOK(res1)) {
14693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14694 }
14695 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14696 {
14697 PyThreadState* __tstate = wxPyBeginAllowThreads();
14698 result = (int)(arg1)->GetMaxAxes();
14699 wxPyEndAllowThreads(__tstate);
14700 if (PyErr_Occurred()) SWIG_fail;
14701 }
14702 resultobj = SWIG_From_int(static_cast< int >(result));
14703 return resultobj;
14704 fail:
14705 return NULL;
14706 }
14707
14708
14709 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14710 PyObject *resultobj = 0;
14711 wxJoystick *arg1 = (wxJoystick *) 0 ;
14712 int result;
14713 void *argp1 = 0 ;
14714 int res1 = 0 ;
14715 PyObject *swig_obj[1] ;
14716
14717 if (!args) SWIG_fail;
14718 swig_obj[0] = args;
14719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14720 if (!SWIG_IsOK(res1)) {
14721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14722 }
14723 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14724 {
14725 PyThreadState* __tstate = wxPyBeginAllowThreads();
14726 result = (int)(arg1)->GetPollingMin();
14727 wxPyEndAllowThreads(__tstate);
14728 if (PyErr_Occurred()) SWIG_fail;
14729 }
14730 resultobj = SWIG_From_int(static_cast< int >(result));
14731 return resultobj;
14732 fail:
14733 return NULL;
14734 }
14735
14736
14737 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14738 PyObject *resultobj = 0;
14739 wxJoystick *arg1 = (wxJoystick *) 0 ;
14740 int result;
14741 void *argp1 = 0 ;
14742 int res1 = 0 ;
14743 PyObject *swig_obj[1] ;
14744
14745 if (!args) SWIG_fail;
14746 swig_obj[0] = args;
14747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14748 if (!SWIG_IsOK(res1)) {
14749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14750 }
14751 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14752 {
14753 PyThreadState* __tstate = wxPyBeginAllowThreads();
14754 result = (int)(arg1)->GetPollingMax();
14755 wxPyEndAllowThreads(__tstate);
14756 if (PyErr_Occurred()) SWIG_fail;
14757 }
14758 resultobj = SWIG_From_int(static_cast< int >(result));
14759 return resultobj;
14760 fail:
14761 return NULL;
14762 }
14763
14764
14765 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14766 PyObject *resultobj = 0;
14767 wxJoystick *arg1 = (wxJoystick *) 0 ;
14768 int result;
14769 void *argp1 = 0 ;
14770 int res1 = 0 ;
14771 PyObject *swig_obj[1] ;
14772
14773 if (!args) SWIG_fail;
14774 swig_obj[0] = args;
14775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14776 if (!SWIG_IsOK(res1)) {
14777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14778 }
14779 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14780 {
14781 PyThreadState* __tstate = wxPyBeginAllowThreads();
14782 result = (int)(arg1)->GetRudderMin();
14783 wxPyEndAllowThreads(__tstate);
14784 if (PyErr_Occurred()) SWIG_fail;
14785 }
14786 resultobj = SWIG_From_int(static_cast< int >(result));
14787 return resultobj;
14788 fail:
14789 return NULL;
14790 }
14791
14792
14793 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14794 PyObject *resultobj = 0;
14795 wxJoystick *arg1 = (wxJoystick *) 0 ;
14796 int result;
14797 void *argp1 = 0 ;
14798 int res1 = 0 ;
14799 PyObject *swig_obj[1] ;
14800
14801 if (!args) SWIG_fail;
14802 swig_obj[0] = args;
14803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14804 if (!SWIG_IsOK(res1)) {
14805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14806 }
14807 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14808 {
14809 PyThreadState* __tstate = wxPyBeginAllowThreads();
14810 result = (int)(arg1)->GetRudderMax();
14811 wxPyEndAllowThreads(__tstate);
14812 if (PyErr_Occurred()) SWIG_fail;
14813 }
14814 resultobj = SWIG_From_int(static_cast< int >(result));
14815 return resultobj;
14816 fail:
14817 return NULL;
14818 }
14819
14820
14821 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14822 PyObject *resultobj = 0;
14823 wxJoystick *arg1 = (wxJoystick *) 0 ;
14824 int result;
14825 void *argp1 = 0 ;
14826 int res1 = 0 ;
14827 PyObject *swig_obj[1] ;
14828
14829 if (!args) SWIG_fail;
14830 swig_obj[0] = args;
14831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14832 if (!SWIG_IsOK(res1)) {
14833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14834 }
14835 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14836 {
14837 PyThreadState* __tstate = wxPyBeginAllowThreads();
14838 result = (int)(arg1)->GetUMin();
14839 wxPyEndAllowThreads(__tstate);
14840 if (PyErr_Occurred()) SWIG_fail;
14841 }
14842 resultobj = SWIG_From_int(static_cast< int >(result));
14843 return resultobj;
14844 fail:
14845 return NULL;
14846 }
14847
14848
14849 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14850 PyObject *resultobj = 0;
14851 wxJoystick *arg1 = (wxJoystick *) 0 ;
14852 int result;
14853 void *argp1 = 0 ;
14854 int res1 = 0 ;
14855 PyObject *swig_obj[1] ;
14856
14857 if (!args) SWIG_fail;
14858 swig_obj[0] = args;
14859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14860 if (!SWIG_IsOK(res1)) {
14861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14862 }
14863 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14864 {
14865 PyThreadState* __tstate = wxPyBeginAllowThreads();
14866 result = (int)(arg1)->GetUMax();
14867 wxPyEndAllowThreads(__tstate);
14868 if (PyErr_Occurred()) SWIG_fail;
14869 }
14870 resultobj = SWIG_From_int(static_cast< int >(result));
14871 return resultobj;
14872 fail:
14873 return NULL;
14874 }
14875
14876
14877 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14878 PyObject *resultobj = 0;
14879 wxJoystick *arg1 = (wxJoystick *) 0 ;
14880 int result;
14881 void *argp1 = 0 ;
14882 int res1 = 0 ;
14883 PyObject *swig_obj[1] ;
14884
14885 if (!args) SWIG_fail;
14886 swig_obj[0] = args;
14887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14888 if (!SWIG_IsOK(res1)) {
14889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14890 }
14891 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14892 {
14893 PyThreadState* __tstate = wxPyBeginAllowThreads();
14894 result = (int)(arg1)->GetVMin();
14895 wxPyEndAllowThreads(__tstate);
14896 if (PyErr_Occurred()) SWIG_fail;
14897 }
14898 resultobj = SWIG_From_int(static_cast< int >(result));
14899 return resultobj;
14900 fail:
14901 return NULL;
14902 }
14903
14904
14905 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14906 PyObject *resultobj = 0;
14907 wxJoystick *arg1 = (wxJoystick *) 0 ;
14908 int result;
14909 void *argp1 = 0 ;
14910 int res1 = 0 ;
14911 PyObject *swig_obj[1] ;
14912
14913 if (!args) SWIG_fail;
14914 swig_obj[0] = args;
14915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14916 if (!SWIG_IsOK(res1)) {
14917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14918 }
14919 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14920 {
14921 PyThreadState* __tstate = wxPyBeginAllowThreads();
14922 result = (int)(arg1)->GetVMax();
14923 wxPyEndAllowThreads(__tstate);
14924 if (PyErr_Occurred()) SWIG_fail;
14925 }
14926 resultobj = SWIG_From_int(static_cast< int >(result));
14927 return resultobj;
14928 fail:
14929 return NULL;
14930 }
14931
14932
14933 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14934 PyObject *resultobj = 0;
14935 wxJoystick *arg1 = (wxJoystick *) 0 ;
14936 bool result;
14937 void *argp1 = 0 ;
14938 int res1 = 0 ;
14939 PyObject *swig_obj[1] ;
14940
14941 if (!args) SWIG_fail;
14942 swig_obj[0] = args;
14943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14944 if (!SWIG_IsOK(res1)) {
14945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
14946 }
14947 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14948 {
14949 PyThreadState* __tstate = wxPyBeginAllowThreads();
14950 result = (bool)(arg1)->HasRudder();
14951 wxPyEndAllowThreads(__tstate);
14952 if (PyErr_Occurred()) SWIG_fail;
14953 }
14954 {
14955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14956 }
14957 return resultobj;
14958 fail:
14959 return NULL;
14960 }
14961
14962
14963 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14964 PyObject *resultobj = 0;
14965 wxJoystick *arg1 = (wxJoystick *) 0 ;
14966 bool result;
14967 void *argp1 = 0 ;
14968 int res1 = 0 ;
14969 PyObject *swig_obj[1] ;
14970
14971 if (!args) SWIG_fail;
14972 swig_obj[0] = args;
14973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14974 if (!SWIG_IsOK(res1)) {
14975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
14976 }
14977 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14978 {
14979 PyThreadState* __tstate = wxPyBeginAllowThreads();
14980 result = (bool)(arg1)->HasZ();
14981 wxPyEndAllowThreads(__tstate);
14982 if (PyErr_Occurred()) SWIG_fail;
14983 }
14984 {
14985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14986 }
14987 return resultobj;
14988 fail:
14989 return NULL;
14990 }
14991
14992
14993 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14994 PyObject *resultobj = 0;
14995 wxJoystick *arg1 = (wxJoystick *) 0 ;
14996 bool result;
14997 void *argp1 = 0 ;
14998 int res1 = 0 ;
14999 PyObject *swig_obj[1] ;
15000
15001 if (!args) SWIG_fail;
15002 swig_obj[0] = args;
15003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15004 if (!SWIG_IsOK(res1)) {
15005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
15006 }
15007 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15008 {
15009 PyThreadState* __tstate = wxPyBeginAllowThreads();
15010 result = (bool)(arg1)->HasU();
15011 wxPyEndAllowThreads(__tstate);
15012 if (PyErr_Occurred()) SWIG_fail;
15013 }
15014 {
15015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15016 }
15017 return resultobj;
15018 fail:
15019 return NULL;
15020 }
15021
15022
15023 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15024 PyObject *resultobj = 0;
15025 wxJoystick *arg1 = (wxJoystick *) 0 ;
15026 bool result;
15027 void *argp1 = 0 ;
15028 int res1 = 0 ;
15029 PyObject *swig_obj[1] ;
15030
15031 if (!args) SWIG_fail;
15032 swig_obj[0] = args;
15033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15034 if (!SWIG_IsOK(res1)) {
15035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15036 }
15037 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15038 {
15039 PyThreadState* __tstate = wxPyBeginAllowThreads();
15040 result = (bool)(arg1)->HasV();
15041 wxPyEndAllowThreads(__tstate);
15042 if (PyErr_Occurred()) SWIG_fail;
15043 }
15044 {
15045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15046 }
15047 return resultobj;
15048 fail:
15049 return NULL;
15050 }
15051
15052
15053 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15054 PyObject *resultobj = 0;
15055 wxJoystick *arg1 = (wxJoystick *) 0 ;
15056 bool result;
15057 void *argp1 = 0 ;
15058 int res1 = 0 ;
15059 PyObject *swig_obj[1] ;
15060
15061 if (!args) SWIG_fail;
15062 swig_obj[0] = args;
15063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15064 if (!SWIG_IsOK(res1)) {
15065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15066 }
15067 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15068 {
15069 PyThreadState* __tstate = wxPyBeginAllowThreads();
15070 result = (bool)(arg1)->HasPOV();
15071 wxPyEndAllowThreads(__tstate);
15072 if (PyErr_Occurred()) SWIG_fail;
15073 }
15074 {
15075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15076 }
15077 return resultobj;
15078 fail:
15079 return NULL;
15080 }
15081
15082
15083 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15084 PyObject *resultobj = 0;
15085 wxJoystick *arg1 = (wxJoystick *) 0 ;
15086 bool result;
15087 void *argp1 = 0 ;
15088 int res1 = 0 ;
15089 PyObject *swig_obj[1] ;
15090
15091 if (!args) SWIG_fail;
15092 swig_obj[0] = args;
15093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15094 if (!SWIG_IsOK(res1)) {
15095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
15096 }
15097 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15098 {
15099 PyThreadState* __tstate = wxPyBeginAllowThreads();
15100 result = (bool)(arg1)->HasPOV4Dir();
15101 wxPyEndAllowThreads(__tstate);
15102 if (PyErr_Occurred()) SWIG_fail;
15103 }
15104 {
15105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15106 }
15107 return resultobj;
15108 fail:
15109 return NULL;
15110 }
15111
15112
15113 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15114 PyObject *resultobj = 0;
15115 wxJoystick *arg1 = (wxJoystick *) 0 ;
15116 bool result;
15117 void *argp1 = 0 ;
15118 int res1 = 0 ;
15119 PyObject *swig_obj[1] ;
15120
15121 if (!args) SWIG_fail;
15122 swig_obj[0] = args;
15123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15124 if (!SWIG_IsOK(res1)) {
15125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
15126 }
15127 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15128 {
15129 PyThreadState* __tstate = wxPyBeginAllowThreads();
15130 result = (bool)(arg1)->HasPOVCTS();
15131 wxPyEndAllowThreads(__tstate);
15132 if (PyErr_Occurred()) SWIG_fail;
15133 }
15134 {
15135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15136 }
15137 return resultobj;
15138 fail:
15139 return NULL;
15140 }
15141
15142
15143 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15144 PyObject *resultobj = 0;
15145 wxJoystick *arg1 = (wxJoystick *) 0 ;
15146 wxWindow *arg2 = (wxWindow *) 0 ;
15147 int arg3 = (int) 0 ;
15148 bool result;
15149 void *argp1 = 0 ;
15150 int res1 = 0 ;
15151 void *argp2 = 0 ;
15152 int res2 = 0 ;
15153 int val3 ;
15154 int ecode3 = 0 ;
15155 PyObject * obj0 = 0 ;
15156 PyObject * obj1 = 0 ;
15157 PyObject * obj2 = 0 ;
15158 char * kwnames[] = {
15159 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
15160 };
15161
15162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15164 if (!SWIG_IsOK(res1)) {
15165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15166 }
15167 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15168 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
15169 if (!SWIG_IsOK(res2)) {
15170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
15171 }
15172 arg2 = reinterpret_cast< wxWindow * >(argp2);
15173 if (obj2) {
15174 ecode3 = SWIG_AsVal_int(obj2, &val3);
15175 if (!SWIG_IsOK(ecode3)) {
15176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
15177 }
15178 arg3 = static_cast< int >(val3);
15179 }
15180 {
15181 PyThreadState* __tstate = wxPyBeginAllowThreads();
15182 result = (bool)(arg1)->SetCapture(arg2,arg3);
15183 wxPyEndAllowThreads(__tstate);
15184 if (PyErr_Occurred()) SWIG_fail;
15185 }
15186 {
15187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15188 }
15189 return resultobj;
15190 fail:
15191 return NULL;
15192 }
15193
15194
15195 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15196 PyObject *resultobj = 0;
15197 wxJoystick *arg1 = (wxJoystick *) 0 ;
15198 bool result;
15199 void *argp1 = 0 ;
15200 int res1 = 0 ;
15201 PyObject *swig_obj[1] ;
15202
15203 if (!args) SWIG_fail;
15204 swig_obj[0] = args;
15205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15206 if (!SWIG_IsOK(res1)) {
15207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15208 }
15209 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15210 {
15211 PyThreadState* __tstate = wxPyBeginAllowThreads();
15212 result = (bool)(arg1)->ReleaseCapture();
15213 wxPyEndAllowThreads(__tstate);
15214 if (PyErr_Occurred()) SWIG_fail;
15215 }
15216 {
15217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15218 }
15219 return resultobj;
15220 fail:
15221 return NULL;
15222 }
15223
15224
15225 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15226 PyObject *obj;
15227 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15228 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
15229 return SWIG_Py_Void();
15230 }
15231
15232 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15233 return SWIG_Python_InitShadowInstance(args);
15234 }
15235
15236 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15237 PyObject *resultobj = 0;
15238 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15239 int arg2 = (int) 0 ;
15240 int arg3 = (int) wxJOYSTICK1 ;
15241 int arg4 = (int) 0 ;
15242 wxJoystickEvent *result = 0 ;
15243 int val1 ;
15244 int ecode1 = 0 ;
15245 int val2 ;
15246 int ecode2 = 0 ;
15247 int val3 ;
15248 int ecode3 = 0 ;
15249 int val4 ;
15250 int ecode4 = 0 ;
15251 PyObject * obj0 = 0 ;
15252 PyObject * obj1 = 0 ;
15253 PyObject * obj2 = 0 ;
15254 PyObject * obj3 = 0 ;
15255 char * kwnames[] = {
15256 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
15257 };
15258
15259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15260 if (obj0) {
15261 ecode1 = SWIG_AsVal_int(obj0, &val1);
15262 if (!SWIG_IsOK(ecode1)) {
15263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
15264 }
15265 arg1 = static_cast< wxEventType >(val1);
15266 }
15267 if (obj1) {
15268 ecode2 = SWIG_AsVal_int(obj1, &val2);
15269 if (!SWIG_IsOK(ecode2)) {
15270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
15271 }
15272 arg2 = static_cast< int >(val2);
15273 }
15274 if (obj2) {
15275 ecode3 = SWIG_AsVal_int(obj2, &val3);
15276 if (!SWIG_IsOK(ecode3)) {
15277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
15278 }
15279 arg3 = static_cast< int >(val3);
15280 }
15281 if (obj3) {
15282 ecode4 = SWIG_AsVal_int(obj3, &val4);
15283 if (!SWIG_IsOK(ecode4)) {
15284 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
15285 }
15286 arg4 = static_cast< int >(val4);
15287 }
15288 {
15289 PyThreadState* __tstate = wxPyBeginAllowThreads();
15290 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
15291 wxPyEndAllowThreads(__tstate);
15292 if (PyErr_Occurred()) SWIG_fail;
15293 }
15294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
15295 return resultobj;
15296 fail:
15297 return NULL;
15298 }
15299
15300
15301 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15302 PyObject *resultobj = 0;
15303 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15304 wxPoint result;
15305 void *argp1 = 0 ;
15306 int res1 = 0 ;
15307 PyObject *swig_obj[1] ;
15308
15309 if (!args) SWIG_fail;
15310 swig_obj[0] = args;
15311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15312 if (!SWIG_IsOK(res1)) {
15313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15314 }
15315 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15316 {
15317 PyThreadState* __tstate = wxPyBeginAllowThreads();
15318 result = ((wxJoystickEvent const *)arg1)->GetPosition();
15319 wxPyEndAllowThreads(__tstate);
15320 if (PyErr_Occurred()) SWIG_fail;
15321 }
15322 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15323 return resultobj;
15324 fail:
15325 return NULL;
15326 }
15327
15328
15329 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15330 PyObject *resultobj = 0;
15331 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15332 int result;
15333 void *argp1 = 0 ;
15334 int res1 = 0 ;
15335 PyObject *swig_obj[1] ;
15336
15337 if (!args) SWIG_fail;
15338 swig_obj[0] = args;
15339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15340 if (!SWIG_IsOK(res1)) {
15341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15342 }
15343 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15344 {
15345 PyThreadState* __tstate = wxPyBeginAllowThreads();
15346 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
15347 wxPyEndAllowThreads(__tstate);
15348 if (PyErr_Occurred()) SWIG_fail;
15349 }
15350 resultobj = SWIG_From_int(static_cast< int >(result));
15351 return resultobj;
15352 fail:
15353 return NULL;
15354 }
15355
15356
15357 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15358 PyObject *resultobj = 0;
15359 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15360 int result;
15361 void *argp1 = 0 ;
15362 int res1 = 0 ;
15363 PyObject *swig_obj[1] ;
15364
15365 if (!args) SWIG_fail;
15366 swig_obj[0] = args;
15367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15368 if (!SWIG_IsOK(res1)) {
15369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15370 }
15371 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15372 {
15373 PyThreadState* __tstate = wxPyBeginAllowThreads();
15374 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
15375 wxPyEndAllowThreads(__tstate);
15376 if (PyErr_Occurred()) SWIG_fail;
15377 }
15378 resultobj = SWIG_From_int(static_cast< int >(result));
15379 return resultobj;
15380 fail:
15381 return NULL;
15382 }
15383
15384
15385 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15386 PyObject *resultobj = 0;
15387 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15388 int result;
15389 void *argp1 = 0 ;
15390 int res1 = 0 ;
15391 PyObject *swig_obj[1] ;
15392
15393 if (!args) SWIG_fail;
15394 swig_obj[0] = args;
15395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15396 if (!SWIG_IsOK(res1)) {
15397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15398 }
15399 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15400 {
15401 PyThreadState* __tstate = wxPyBeginAllowThreads();
15402 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
15403 wxPyEndAllowThreads(__tstate);
15404 if (PyErr_Occurred()) SWIG_fail;
15405 }
15406 resultobj = SWIG_From_int(static_cast< int >(result));
15407 return resultobj;
15408 fail:
15409 return NULL;
15410 }
15411
15412
15413 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15414 PyObject *resultobj = 0;
15415 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15416 int result;
15417 void *argp1 = 0 ;
15418 int res1 = 0 ;
15419 PyObject *swig_obj[1] ;
15420
15421 if (!args) SWIG_fail;
15422 swig_obj[0] = args;
15423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15424 if (!SWIG_IsOK(res1)) {
15425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15426 }
15427 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15428 {
15429 PyThreadState* __tstate = wxPyBeginAllowThreads();
15430 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
15431 wxPyEndAllowThreads(__tstate);
15432 if (PyErr_Occurred()) SWIG_fail;
15433 }
15434 resultobj = SWIG_From_int(static_cast< int >(result));
15435 return resultobj;
15436 fail:
15437 return NULL;
15438 }
15439
15440
15441 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15442 PyObject *resultobj = 0;
15443 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15444 int arg2 ;
15445 void *argp1 = 0 ;
15446 int res1 = 0 ;
15447 int val2 ;
15448 int ecode2 = 0 ;
15449 PyObject * obj0 = 0 ;
15450 PyObject * obj1 = 0 ;
15451 char * kwnames[] = {
15452 (char *) "self",(char *) "stick", NULL
15453 };
15454
15455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
15456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15457 if (!SWIG_IsOK(res1)) {
15458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15459 }
15460 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15461 ecode2 = SWIG_AsVal_int(obj1, &val2);
15462 if (!SWIG_IsOK(ecode2)) {
15463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
15464 }
15465 arg2 = static_cast< int >(val2);
15466 {
15467 PyThreadState* __tstate = wxPyBeginAllowThreads();
15468 (arg1)->SetJoystick(arg2);
15469 wxPyEndAllowThreads(__tstate);
15470 if (PyErr_Occurred()) SWIG_fail;
15471 }
15472 resultobj = SWIG_Py_Void();
15473 return resultobj;
15474 fail:
15475 return NULL;
15476 }
15477
15478
15479 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15480 PyObject *resultobj = 0;
15481 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15482 int arg2 ;
15483 void *argp1 = 0 ;
15484 int res1 = 0 ;
15485 int val2 ;
15486 int ecode2 = 0 ;
15487 PyObject * obj0 = 0 ;
15488 PyObject * obj1 = 0 ;
15489 char * kwnames[] = {
15490 (char *) "self",(char *) "state", NULL
15491 };
15492
15493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
15494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15495 if (!SWIG_IsOK(res1)) {
15496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15497 }
15498 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15499 ecode2 = SWIG_AsVal_int(obj1, &val2);
15500 if (!SWIG_IsOK(ecode2)) {
15501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
15502 }
15503 arg2 = static_cast< int >(val2);
15504 {
15505 PyThreadState* __tstate = wxPyBeginAllowThreads();
15506 (arg1)->SetButtonState(arg2);
15507 wxPyEndAllowThreads(__tstate);
15508 if (PyErr_Occurred()) SWIG_fail;
15509 }
15510 resultobj = SWIG_Py_Void();
15511 return resultobj;
15512 fail:
15513 return NULL;
15514 }
15515
15516
15517 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15518 PyObject *resultobj = 0;
15519 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15520 int arg2 ;
15521 void *argp1 = 0 ;
15522 int res1 = 0 ;
15523 int val2 ;
15524 int ecode2 = 0 ;
15525 PyObject * obj0 = 0 ;
15526 PyObject * obj1 = 0 ;
15527 char * kwnames[] = {
15528 (char *) "self",(char *) "change", NULL
15529 };
15530
15531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
15532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15533 if (!SWIG_IsOK(res1)) {
15534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15535 }
15536 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15537 ecode2 = SWIG_AsVal_int(obj1, &val2);
15538 if (!SWIG_IsOK(ecode2)) {
15539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
15540 }
15541 arg2 = static_cast< int >(val2);
15542 {
15543 PyThreadState* __tstate = wxPyBeginAllowThreads();
15544 (arg1)->SetButtonChange(arg2);
15545 wxPyEndAllowThreads(__tstate);
15546 if (PyErr_Occurred()) SWIG_fail;
15547 }
15548 resultobj = SWIG_Py_Void();
15549 return resultobj;
15550 fail:
15551 return NULL;
15552 }
15553
15554
15555 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15556 PyObject *resultobj = 0;
15557 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15558 wxPoint *arg2 = 0 ;
15559 void *argp1 = 0 ;
15560 int res1 = 0 ;
15561 wxPoint temp2 ;
15562 PyObject * obj0 = 0 ;
15563 PyObject * obj1 = 0 ;
15564 char * kwnames[] = {
15565 (char *) "self",(char *) "pos", NULL
15566 };
15567
15568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15570 if (!SWIG_IsOK(res1)) {
15571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15572 }
15573 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15574 {
15575 arg2 = &temp2;
15576 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15577 }
15578 {
15579 PyThreadState* __tstate = wxPyBeginAllowThreads();
15580 (arg1)->SetPosition((wxPoint const &)*arg2);
15581 wxPyEndAllowThreads(__tstate);
15582 if (PyErr_Occurred()) SWIG_fail;
15583 }
15584 resultobj = SWIG_Py_Void();
15585 return resultobj;
15586 fail:
15587 return NULL;
15588 }
15589
15590
15591 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15592 PyObject *resultobj = 0;
15593 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15594 int arg2 ;
15595 void *argp1 = 0 ;
15596 int res1 = 0 ;
15597 int val2 ;
15598 int ecode2 = 0 ;
15599 PyObject * obj0 = 0 ;
15600 PyObject * obj1 = 0 ;
15601 char * kwnames[] = {
15602 (char *) "self",(char *) "zPos", NULL
15603 };
15604
15605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15607 if (!SWIG_IsOK(res1)) {
15608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15609 }
15610 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15611 ecode2 = SWIG_AsVal_int(obj1, &val2);
15612 if (!SWIG_IsOK(ecode2)) {
15613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
15614 }
15615 arg2 = static_cast< int >(val2);
15616 {
15617 PyThreadState* __tstate = wxPyBeginAllowThreads();
15618 (arg1)->SetZPosition(arg2);
15619 wxPyEndAllowThreads(__tstate);
15620 if (PyErr_Occurred()) SWIG_fail;
15621 }
15622 resultobj = SWIG_Py_Void();
15623 return resultobj;
15624 fail:
15625 return NULL;
15626 }
15627
15628
15629 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15630 PyObject *resultobj = 0;
15631 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15632 bool result;
15633 void *argp1 = 0 ;
15634 int res1 = 0 ;
15635 PyObject *swig_obj[1] ;
15636
15637 if (!args) SWIG_fail;
15638 swig_obj[0] = args;
15639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15640 if (!SWIG_IsOK(res1)) {
15641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15642 }
15643 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15644 {
15645 PyThreadState* __tstate = wxPyBeginAllowThreads();
15646 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
15647 wxPyEndAllowThreads(__tstate);
15648 if (PyErr_Occurred()) SWIG_fail;
15649 }
15650 {
15651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15652 }
15653 return resultobj;
15654 fail:
15655 return NULL;
15656 }
15657
15658
15659 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15660 PyObject *resultobj = 0;
15661 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15662 bool result;
15663 void *argp1 = 0 ;
15664 int res1 = 0 ;
15665 PyObject *swig_obj[1] ;
15666
15667 if (!args) SWIG_fail;
15668 swig_obj[0] = args;
15669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15670 if (!SWIG_IsOK(res1)) {
15671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15672 }
15673 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15674 {
15675 PyThreadState* __tstate = wxPyBeginAllowThreads();
15676 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
15677 wxPyEndAllowThreads(__tstate);
15678 if (PyErr_Occurred()) SWIG_fail;
15679 }
15680 {
15681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15682 }
15683 return resultobj;
15684 fail:
15685 return NULL;
15686 }
15687
15688
15689 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15690 PyObject *resultobj = 0;
15691 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15692 bool result;
15693 void *argp1 = 0 ;
15694 int res1 = 0 ;
15695 PyObject *swig_obj[1] ;
15696
15697 if (!args) SWIG_fail;
15698 swig_obj[0] = args;
15699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15700 if (!SWIG_IsOK(res1)) {
15701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15702 }
15703 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15704 {
15705 PyThreadState* __tstate = wxPyBeginAllowThreads();
15706 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
15707 wxPyEndAllowThreads(__tstate);
15708 if (PyErr_Occurred()) SWIG_fail;
15709 }
15710 {
15711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15712 }
15713 return resultobj;
15714 fail:
15715 return NULL;
15716 }
15717
15718
15719 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15720 PyObject *resultobj = 0;
15721 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15722 int arg2 = (int) wxJOY_BUTTON_ANY ;
15723 bool result;
15724 void *argp1 = 0 ;
15725 int res1 = 0 ;
15726 int val2 ;
15727 int ecode2 = 0 ;
15728 PyObject * obj0 = 0 ;
15729 PyObject * obj1 = 0 ;
15730 char * kwnames[] = {
15731 (char *) "self",(char *) "but", NULL
15732 };
15733
15734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
15735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15736 if (!SWIG_IsOK(res1)) {
15737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15738 }
15739 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15740 if (obj1) {
15741 ecode2 = SWIG_AsVal_int(obj1, &val2);
15742 if (!SWIG_IsOK(ecode2)) {
15743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
15744 }
15745 arg2 = static_cast< int >(val2);
15746 }
15747 {
15748 PyThreadState* __tstate = wxPyBeginAllowThreads();
15749 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
15750 wxPyEndAllowThreads(__tstate);
15751 if (PyErr_Occurred()) SWIG_fail;
15752 }
15753 {
15754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15755 }
15756 return resultobj;
15757 fail:
15758 return NULL;
15759 }
15760
15761
15762 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15763 PyObject *resultobj = 0;
15764 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15765 int arg2 = (int) wxJOY_BUTTON_ANY ;
15766 bool result;
15767 void *argp1 = 0 ;
15768 int res1 = 0 ;
15769 int val2 ;
15770 int ecode2 = 0 ;
15771 PyObject * obj0 = 0 ;
15772 PyObject * obj1 = 0 ;
15773 char * kwnames[] = {
15774 (char *) "self",(char *) "but", NULL
15775 };
15776
15777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
15778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15779 if (!SWIG_IsOK(res1)) {
15780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15781 }
15782 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15783 if (obj1) {
15784 ecode2 = SWIG_AsVal_int(obj1, &val2);
15785 if (!SWIG_IsOK(ecode2)) {
15786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
15787 }
15788 arg2 = static_cast< int >(val2);
15789 }
15790 {
15791 PyThreadState* __tstate = wxPyBeginAllowThreads();
15792 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
15793 wxPyEndAllowThreads(__tstate);
15794 if (PyErr_Occurred()) SWIG_fail;
15795 }
15796 {
15797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15798 }
15799 return resultobj;
15800 fail:
15801 return NULL;
15802 }
15803
15804
15805 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15806 PyObject *resultobj = 0;
15807 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15808 int arg2 = (int) wxJOY_BUTTON_ANY ;
15809 bool result;
15810 void *argp1 = 0 ;
15811 int res1 = 0 ;
15812 int val2 ;
15813 int ecode2 = 0 ;
15814 PyObject * obj0 = 0 ;
15815 PyObject * obj1 = 0 ;
15816 char * kwnames[] = {
15817 (char *) "self",(char *) "but", NULL
15818 };
15819
15820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
15821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15822 if (!SWIG_IsOK(res1)) {
15823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15824 }
15825 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15826 if (obj1) {
15827 ecode2 = SWIG_AsVal_int(obj1, &val2);
15828 if (!SWIG_IsOK(ecode2)) {
15829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
15830 }
15831 arg2 = static_cast< int >(val2);
15832 }
15833 {
15834 PyThreadState* __tstate = wxPyBeginAllowThreads();
15835 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
15836 wxPyEndAllowThreads(__tstate);
15837 if (PyErr_Occurred()) SWIG_fail;
15838 }
15839 {
15840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15841 }
15842 return resultobj;
15843 fail:
15844 return NULL;
15845 }
15846
15847
15848 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15849 PyObject *obj;
15850 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15851 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
15852 return SWIG_Py_Void();
15853 }
15854
15855 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15856 return SWIG_Python_InitShadowInstance(args);
15857 }
15858
15859 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15860 PyObject *resultobj = 0;
15861 wxString const &arg1_defvalue = wxPyEmptyString ;
15862 wxString *arg1 = (wxString *) &arg1_defvalue ;
15863 wxSound *result = 0 ;
15864 bool temp1 = false ;
15865 PyObject * obj0 = 0 ;
15866 char * kwnames[] = {
15867 (char *) "fileName", NULL
15868 };
15869
15870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
15871 if (obj0) {
15872 {
15873 arg1 = wxString_in_helper(obj0);
15874 if (arg1 == NULL) SWIG_fail;
15875 temp1 = true;
15876 }
15877 }
15878 {
15879 if (!wxPyCheckForApp()) SWIG_fail;
15880 PyThreadState* __tstate = wxPyBeginAllowThreads();
15881 result = (wxSound *)new_wxSound((wxString const &)*arg1);
15882 wxPyEndAllowThreads(__tstate);
15883 if (PyErr_Occurred()) SWIG_fail;
15884 }
15885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
15886 {
15887 if (temp1)
15888 delete arg1;
15889 }
15890 return resultobj;
15891 fail:
15892 {
15893 if (temp1)
15894 delete arg1;
15895 }
15896 return NULL;
15897 }
15898
15899
15900 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15901 PyObject *resultobj = 0;
15902 PyObject *arg1 = (PyObject *) 0 ;
15903 wxSound *result = 0 ;
15904 PyObject * obj0 = 0 ;
15905 char * kwnames[] = {
15906 (char *) "data", NULL
15907 };
15908
15909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
15910 arg1 = obj0;
15911 {
15912 if (!wxPyCheckForApp()) SWIG_fail;
15913 PyThreadState* __tstate = wxPyBeginAllowThreads();
15914 result = (wxSound *)new_wxSound(arg1);
15915 wxPyEndAllowThreads(__tstate);
15916 if (PyErr_Occurred()) SWIG_fail;
15917 }
15918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
15919 return resultobj;
15920 fail:
15921 return NULL;
15922 }
15923
15924
15925 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15926 PyObject *resultobj = 0;
15927 wxSound *arg1 = (wxSound *) 0 ;
15928 void *argp1 = 0 ;
15929 int res1 = 0 ;
15930 PyObject *swig_obj[1] ;
15931
15932 if (!args) SWIG_fail;
15933 swig_obj[0] = args;
15934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
15935 if (!SWIG_IsOK(res1)) {
15936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
15937 }
15938 arg1 = reinterpret_cast< wxSound * >(argp1);
15939 {
15940 PyThreadState* __tstate = wxPyBeginAllowThreads();
15941 delete arg1;
15942
15943 wxPyEndAllowThreads(__tstate);
15944 if (PyErr_Occurred()) SWIG_fail;
15945 }
15946 resultobj = SWIG_Py_Void();
15947 return resultobj;
15948 fail:
15949 return NULL;
15950 }
15951
15952
15953 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15954 PyObject *resultobj = 0;
15955 wxSound *arg1 = (wxSound *) 0 ;
15956 wxString *arg2 = 0 ;
15957 bool result;
15958 void *argp1 = 0 ;
15959 int res1 = 0 ;
15960 bool temp2 = false ;
15961 PyObject * obj0 = 0 ;
15962 PyObject * obj1 = 0 ;
15963 char * kwnames[] = {
15964 (char *) "self",(char *) "fileName", NULL
15965 };
15966
15967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
15968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15969 if (!SWIG_IsOK(res1)) {
15970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
15971 }
15972 arg1 = reinterpret_cast< wxSound * >(argp1);
15973 {
15974 arg2 = wxString_in_helper(obj1);
15975 if (arg2 == NULL) SWIG_fail;
15976 temp2 = true;
15977 }
15978 {
15979 PyThreadState* __tstate = wxPyBeginAllowThreads();
15980 result = (bool)(arg1)->Create((wxString const &)*arg2);
15981 wxPyEndAllowThreads(__tstate);
15982 if (PyErr_Occurred()) SWIG_fail;
15983 }
15984 {
15985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15986 }
15987 {
15988 if (temp2)
15989 delete arg2;
15990 }
15991 return resultobj;
15992 fail:
15993 {
15994 if (temp2)
15995 delete arg2;
15996 }
15997 return NULL;
15998 }
15999
16000
16001 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16002 PyObject *resultobj = 0;
16003 wxSound *arg1 = (wxSound *) 0 ;
16004 PyObject *arg2 = (PyObject *) 0 ;
16005 bool result;
16006 void *argp1 = 0 ;
16007 int res1 = 0 ;
16008 PyObject * obj0 = 0 ;
16009 PyObject * obj1 = 0 ;
16010 char * kwnames[] = {
16011 (char *) "self",(char *) "data", NULL
16012 };
16013
16014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
16015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16016 if (!SWIG_IsOK(res1)) {
16017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
16018 }
16019 arg1 = reinterpret_cast< wxSound * >(argp1);
16020 arg2 = obj1;
16021 {
16022 PyThreadState* __tstate = wxPyBeginAllowThreads();
16023 result = (bool)wxSound_CreateFromData(arg1,arg2);
16024 wxPyEndAllowThreads(__tstate);
16025 if (PyErr_Occurred()) SWIG_fail;
16026 }
16027 {
16028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16029 }
16030 return resultobj;
16031 fail:
16032 return NULL;
16033 }
16034
16035
16036 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16037 PyObject *resultobj = 0;
16038 wxSound *arg1 = (wxSound *) 0 ;
16039 bool result;
16040 void *argp1 = 0 ;
16041 int res1 = 0 ;
16042 PyObject *swig_obj[1] ;
16043
16044 if (!args) SWIG_fail;
16045 swig_obj[0] = args;
16046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16047 if (!SWIG_IsOK(res1)) {
16048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
16049 }
16050 arg1 = reinterpret_cast< wxSound * >(argp1);
16051 {
16052 PyThreadState* __tstate = wxPyBeginAllowThreads();
16053 result = (bool)(arg1)->IsOk();
16054 wxPyEndAllowThreads(__tstate);
16055 if (PyErr_Occurred()) SWIG_fail;
16056 }
16057 {
16058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16059 }
16060 return resultobj;
16061 fail:
16062 return NULL;
16063 }
16064
16065
16066 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16067 PyObject *resultobj = 0;
16068 wxSound *arg1 = (wxSound *) 0 ;
16069 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16070 bool result;
16071 void *argp1 = 0 ;
16072 int res1 = 0 ;
16073 unsigned int val2 ;
16074 int ecode2 = 0 ;
16075 PyObject * obj0 = 0 ;
16076 PyObject * obj1 = 0 ;
16077 char * kwnames[] = {
16078 (char *) "self",(char *) "flags", NULL
16079 };
16080
16081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
16082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16083 if (!SWIG_IsOK(res1)) {
16084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
16085 }
16086 arg1 = reinterpret_cast< wxSound * >(argp1);
16087 if (obj1) {
16088 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16089 if (!SWIG_IsOK(ecode2)) {
16090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
16091 }
16092 arg2 = static_cast< unsigned int >(val2);
16093 }
16094 {
16095 if (!wxPyCheckForApp()) SWIG_fail;
16096 PyThreadState* __tstate = wxPyBeginAllowThreads();
16097 result = (bool)((wxSound const *)arg1)->Play(arg2);
16098 wxPyEndAllowThreads(__tstate);
16099 if (PyErr_Occurred()) SWIG_fail;
16100 }
16101 {
16102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16103 }
16104 return resultobj;
16105 fail:
16106 return NULL;
16107 }
16108
16109
16110 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16111 PyObject *resultobj = 0;
16112 wxString *arg1 = 0 ;
16113 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16114 bool result;
16115 bool temp1 = false ;
16116 unsigned int val2 ;
16117 int ecode2 = 0 ;
16118 PyObject * obj0 = 0 ;
16119 PyObject * obj1 = 0 ;
16120 char * kwnames[] = {
16121 (char *) "filename",(char *) "flags", NULL
16122 };
16123
16124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
16125 {
16126 arg1 = wxString_in_helper(obj0);
16127 if (arg1 == NULL) SWIG_fail;
16128 temp1 = true;
16129 }
16130 if (obj1) {
16131 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16132 if (!SWIG_IsOK(ecode2)) {
16133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
16134 }
16135 arg2 = static_cast< unsigned int >(val2);
16136 }
16137 {
16138 if (!wxPyCheckForApp()) SWIG_fail;
16139 PyThreadState* __tstate = wxPyBeginAllowThreads();
16140 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
16141 wxPyEndAllowThreads(__tstate);
16142 if (PyErr_Occurred()) SWIG_fail;
16143 }
16144 {
16145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16146 }
16147 {
16148 if (temp1)
16149 delete arg1;
16150 }
16151 return resultobj;
16152 fail:
16153 {
16154 if (temp1)
16155 delete arg1;
16156 }
16157 return NULL;
16158 }
16159
16160
16161 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16162 PyObject *resultobj = 0;
16163
16164 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
16165 {
16166 if (!wxPyCheckForApp()) SWIG_fail;
16167 PyThreadState* __tstate = wxPyBeginAllowThreads();
16168 wxSound::Stop();
16169 wxPyEndAllowThreads(__tstate);
16170 if (PyErr_Occurred()) SWIG_fail;
16171 }
16172 resultobj = SWIG_Py_Void();
16173 return resultobj;
16174 fail:
16175 return NULL;
16176 }
16177
16178
16179 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16180 PyObject *obj;
16181 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16182 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
16183 return SWIG_Py_Void();
16184 }
16185
16186 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16187 return SWIG_Python_InitShadowInstance(args);
16188 }
16189
16190 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16191 PyObject *resultobj = 0;
16192 wxString *arg1 = 0 ;
16193 wxString *arg2 = 0 ;
16194 wxString *arg3 = 0 ;
16195 wxString *arg4 = 0 ;
16196 wxFileTypeInfo *result = 0 ;
16197 bool temp1 = false ;
16198 bool temp2 = false ;
16199 bool temp3 = false ;
16200 bool temp4 = false ;
16201 PyObject * obj0 = 0 ;
16202 PyObject * obj1 = 0 ;
16203 PyObject * obj2 = 0 ;
16204 PyObject * obj3 = 0 ;
16205 char * kwnames[] = {
16206 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
16207 };
16208
16209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16210 {
16211 arg1 = wxString_in_helper(obj0);
16212 if (arg1 == NULL) SWIG_fail;
16213 temp1 = true;
16214 }
16215 {
16216 arg2 = wxString_in_helper(obj1);
16217 if (arg2 == NULL) SWIG_fail;
16218 temp2 = true;
16219 }
16220 {
16221 arg3 = wxString_in_helper(obj2);
16222 if (arg3 == NULL) SWIG_fail;
16223 temp3 = true;
16224 }
16225 {
16226 arg4 = wxString_in_helper(obj3);
16227 if (arg4 == NULL) SWIG_fail;
16228 temp4 = true;
16229 }
16230 {
16231 PyThreadState* __tstate = wxPyBeginAllowThreads();
16232 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
16233 wxPyEndAllowThreads(__tstate);
16234 if (PyErr_Occurred()) SWIG_fail;
16235 }
16236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
16237 {
16238 if (temp1)
16239 delete arg1;
16240 }
16241 {
16242 if (temp2)
16243 delete arg2;
16244 }
16245 {
16246 if (temp3)
16247 delete arg3;
16248 }
16249 {
16250 if (temp4)
16251 delete arg4;
16252 }
16253 return resultobj;
16254 fail:
16255 {
16256 if (temp1)
16257 delete arg1;
16258 }
16259 {
16260 if (temp2)
16261 delete arg2;
16262 }
16263 {
16264 if (temp3)
16265 delete arg3;
16266 }
16267 {
16268 if (temp4)
16269 delete arg4;
16270 }
16271 return NULL;
16272 }
16273
16274
16275 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16276 PyObject *resultobj = 0;
16277 wxArrayString *arg1 = 0 ;
16278 wxFileTypeInfo *result = 0 ;
16279 bool temp1 = false ;
16280 PyObject * obj0 = 0 ;
16281 char * kwnames[] = {
16282 (char *) "sArray", NULL
16283 };
16284
16285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
16286 {
16287 if (! PySequence_Check(obj0)) {
16288 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
16289 SWIG_fail;
16290 }
16291 arg1 = new wxArrayString;
16292 temp1 = true;
16293 int i, len=PySequence_Length(obj0);
16294 for (i=0; i<len; i++) {
16295 PyObject* item = PySequence_GetItem(obj0, i);
16296 wxString* s = wxString_in_helper(item);
16297 if (PyErr_Occurred()) SWIG_fail;
16298 arg1->Add(*s);
16299 delete s;
16300 Py_DECREF(item);
16301 }
16302 }
16303 {
16304 PyThreadState* __tstate = wxPyBeginAllowThreads();
16305 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
16306 wxPyEndAllowThreads(__tstate);
16307 if (PyErr_Occurred()) SWIG_fail;
16308 }
16309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16310 {
16311 if (temp1) delete arg1;
16312 }
16313 return resultobj;
16314 fail:
16315 {
16316 if (temp1) delete arg1;
16317 }
16318 return NULL;
16319 }
16320
16321
16322 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16323 PyObject *resultobj = 0;
16324 wxFileTypeInfo *result = 0 ;
16325
16326 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
16327 {
16328 PyThreadState* __tstate = wxPyBeginAllowThreads();
16329 result = (wxFileTypeInfo *)new wxFileTypeInfo();
16330 wxPyEndAllowThreads(__tstate);
16331 if (PyErr_Occurred()) SWIG_fail;
16332 }
16333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16334 return resultobj;
16335 fail:
16336 return NULL;
16337 }
16338
16339
16340 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16341 PyObject *resultobj = 0;
16342 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16343 bool result;
16344 void *argp1 = 0 ;
16345 int res1 = 0 ;
16346 PyObject *swig_obj[1] ;
16347
16348 if (!args) SWIG_fail;
16349 swig_obj[0] = args;
16350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16351 if (!SWIG_IsOK(res1)) {
16352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16353 }
16354 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16355 {
16356 PyThreadState* __tstate = wxPyBeginAllowThreads();
16357 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
16358 wxPyEndAllowThreads(__tstate);
16359 if (PyErr_Occurred()) SWIG_fail;
16360 }
16361 {
16362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16363 }
16364 return resultobj;
16365 fail:
16366 return NULL;
16367 }
16368
16369
16370 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16371 PyObject *resultobj = 0;
16372 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16373 wxString *arg2 = 0 ;
16374 int arg3 = (int) 0 ;
16375 void *argp1 = 0 ;
16376 int res1 = 0 ;
16377 bool temp2 = false ;
16378 int val3 ;
16379 int ecode3 = 0 ;
16380 PyObject * obj0 = 0 ;
16381 PyObject * obj1 = 0 ;
16382 PyObject * obj2 = 0 ;
16383 char * kwnames[] = {
16384 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
16385 };
16386
16387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16389 if (!SWIG_IsOK(res1)) {
16390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16391 }
16392 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16393 {
16394 arg2 = wxString_in_helper(obj1);
16395 if (arg2 == NULL) SWIG_fail;
16396 temp2 = true;
16397 }
16398 if (obj2) {
16399 ecode3 = SWIG_AsVal_int(obj2, &val3);
16400 if (!SWIG_IsOK(ecode3)) {
16401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
16402 }
16403 arg3 = static_cast< int >(val3);
16404 }
16405 {
16406 PyThreadState* __tstate = wxPyBeginAllowThreads();
16407 (arg1)->SetIcon((wxString const &)*arg2,arg3);
16408 wxPyEndAllowThreads(__tstate);
16409 if (PyErr_Occurred()) SWIG_fail;
16410 }
16411 resultobj = SWIG_Py_Void();
16412 {
16413 if (temp2)
16414 delete arg2;
16415 }
16416 return resultobj;
16417 fail:
16418 {
16419 if (temp2)
16420 delete arg2;
16421 }
16422 return NULL;
16423 }
16424
16425
16426 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16427 PyObject *resultobj = 0;
16428 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16429 wxString *arg2 = 0 ;
16430 void *argp1 = 0 ;
16431 int res1 = 0 ;
16432 bool temp2 = false ;
16433 PyObject * obj0 = 0 ;
16434 PyObject * obj1 = 0 ;
16435 char * kwnames[] = {
16436 (char *) "self",(char *) "shortDesc", NULL
16437 };
16438
16439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
16440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16441 if (!SWIG_IsOK(res1)) {
16442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16443 }
16444 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16445 {
16446 arg2 = wxString_in_helper(obj1);
16447 if (arg2 == NULL) SWIG_fail;
16448 temp2 = true;
16449 }
16450 {
16451 PyThreadState* __tstate = wxPyBeginAllowThreads();
16452 (arg1)->SetShortDesc((wxString const &)*arg2);
16453 wxPyEndAllowThreads(__tstate);
16454 if (PyErr_Occurred()) SWIG_fail;
16455 }
16456 resultobj = SWIG_Py_Void();
16457 {
16458 if (temp2)
16459 delete arg2;
16460 }
16461 return resultobj;
16462 fail:
16463 {
16464 if (temp2)
16465 delete arg2;
16466 }
16467 return NULL;
16468 }
16469
16470
16471 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16472 PyObject *resultobj = 0;
16473 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16474 wxString *result = 0 ;
16475 void *argp1 = 0 ;
16476 int res1 = 0 ;
16477 PyObject *swig_obj[1] ;
16478
16479 if (!args) SWIG_fail;
16480 swig_obj[0] = args;
16481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16482 if (!SWIG_IsOK(res1)) {
16483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16484 }
16485 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16486 {
16487 PyThreadState* __tstate = wxPyBeginAllowThreads();
16488 {
16489 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
16490 result = (wxString *) &_result_ref;
16491 }
16492 wxPyEndAllowThreads(__tstate);
16493 if (PyErr_Occurred()) SWIG_fail;
16494 }
16495 {
16496 #if wxUSE_UNICODE
16497 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16498 #else
16499 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16500 #endif
16501 }
16502 return resultobj;
16503 fail:
16504 return NULL;
16505 }
16506
16507
16508 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16509 PyObject *resultobj = 0;
16510 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16511 wxString *result = 0 ;
16512 void *argp1 = 0 ;
16513 int res1 = 0 ;
16514 PyObject *swig_obj[1] ;
16515
16516 if (!args) SWIG_fail;
16517 swig_obj[0] = args;
16518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16519 if (!SWIG_IsOK(res1)) {
16520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16521 }
16522 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16523 {
16524 PyThreadState* __tstate = wxPyBeginAllowThreads();
16525 {
16526 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
16527 result = (wxString *) &_result_ref;
16528 }
16529 wxPyEndAllowThreads(__tstate);
16530 if (PyErr_Occurred()) SWIG_fail;
16531 }
16532 {
16533 #if wxUSE_UNICODE
16534 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16535 #else
16536 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16537 #endif
16538 }
16539 return resultobj;
16540 fail:
16541 return NULL;
16542 }
16543
16544
16545 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16546 PyObject *resultobj = 0;
16547 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16548 wxString *result = 0 ;
16549 void *argp1 = 0 ;
16550 int res1 = 0 ;
16551 PyObject *swig_obj[1] ;
16552
16553 if (!args) SWIG_fail;
16554 swig_obj[0] = args;
16555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16556 if (!SWIG_IsOK(res1)) {
16557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16558 }
16559 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16560 {
16561 PyThreadState* __tstate = wxPyBeginAllowThreads();
16562 {
16563 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
16564 result = (wxString *) &_result_ref;
16565 }
16566 wxPyEndAllowThreads(__tstate);
16567 if (PyErr_Occurred()) SWIG_fail;
16568 }
16569 {
16570 #if wxUSE_UNICODE
16571 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16572 #else
16573 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16574 #endif
16575 }
16576 return resultobj;
16577 fail:
16578 return NULL;
16579 }
16580
16581
16582 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16583 PyObject *resultobj = 0;
16584 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16585 wxString *result = 0 ;
16586 void *argp1 = 0 ;
16587 int res1 = 0 ;
16588 PyObject *swig_obj[1] ;
16589
16590 if (!args) SWIG_fail;
16591 swig_obj[0] = args;
16592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16593 if (!SWIG_IsOK(res1)) {
16594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16595 }
16596 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16597 {
16598 PyThreadState* __tstate = wxPyBeginAllowThreads();
16599 {
16600 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
16601 result = (wxString *) &_result_ref;
16602 }
16603 wxPyEndAllowThreads(__tstate);
16604 if (PyErr_Occurred()) SWIG_fail;
16605 }
16606 {
16607 #if wxUSE_UNICODE
16608 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16609 #else
16610 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16611 #endif
16612 }
16613 return resultobj;
16614 fail:
16615 return NULL;
16616 }
16617
16618
16619 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16620 PyObject *resultobj = 0;
16621 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16622 wxString *result = 0 ;
16623 void *argp1 = 0 ;
16624 int res1 = 0 ;
16625 PyObject *swig_obj[1] ;
16626
16627 if (!args) SWIG_fail;
16628 swig_obj[0] = args;
16629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16630 if (!SWIG_IsOK(res1)) {
16631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16632 }
16633 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16634 {
16635 PyThreadState* __tstate = wxPyBeginAllowThreads();
16636 {
16637 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
16638 result = (wxString *) &_result_ref;
16639 }
16640 wxPyEndAllowThreads(__tstate);
16641 if (PyErr_Occurred()) SWIG_fail;
16642 }
16643 {
16644 #if wxUSE_UNICODE
16645 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16646 #else
16647 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16648 #endif
16649 }
16650 return resultobj;
16651 fail:
16652 return NULL;
16653 }
16654
16655
16656 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16657 PyObject *resultobj = 0;
16658 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16659 wxArrayString *result = 0 ;
16660 void *argp1 = 0 ;
16661 int res1 = 0 ;
16662 PyObject *swig_obj[1] ;
16663
16664 if (!args) SWIG_fail;
16665 swig_obj[0] = args;
16666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16667 if (!SWIG_IsOK(res1)) {
16668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16669 }
16670 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16671 {
16672 PyThreadState* __tstate = wxPyBeginAllowThreads();
16673 {
16674 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
16675 result = (wxArrayString *) &_result_ref;
16676 }
16677 wxPyEndAllowThreads(__tstate);
16678 if (PyErr_Occurred()) SWIG_fail;
16679 }
16680 {
16681 resultobj = wxArrayString2PyList_helper(*result);
16682 }
16683 return resultobj;
16684 fail:
16685 return NULL;
16686 }
16687
16688
16689 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16690 PyObject *resultobj = 0;
16691 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16692 size_t result;
16693 void *argp1 = 0 ;
16694 int res1 = 0 ;
16695 PyObject *swig_obj[1] ;
16696
16697 if (!args) SWIG_fail;
16698 swig_obj[0] = args;
16699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16700 if (!SWIG_IsOK(res1)) {
16701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16702 }
16703 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16704 {
16705 PyThreadState* __tstate = wxPyBeginAllowThreads();
16706 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
16707 wxPyEndAllowThreads(__tstate);
16708 if (PyErr_Occurred()) SWIG_fail;
16709 }
16710 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16711 return resultobj;
16712 fail:
16713 return NULL;
16714 }
16715
16716
16717 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16718 PyObject *resultobj = 0;
16719 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16720 wxString *result = 0 ;
16721 void *argp1 = 0 ;
16722 int res1 = 0 ;
16723 PyObject *swig_obj[1] ;
16724
16725 if (!args) SWIG_fail;
16726 swig_obj[0] = args;
16727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16728 if (!SWIG_IsOK(res1)) {
16729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16730 }
16731 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16732 {
16733 PyThreadState* __tstate = wxPyBeginAllowThreads();
16734 {
16735 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
16736 result = (wxString *) &_result_ref;
16737 }
16738 wxPyEndAllowThreads(__tstate);
16739 if (PyErr_Occurred()) SWIG_fail;
16740 }
16741 {
16742 #if wxUSE_UNICODE
16743 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16744 #else
16745 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16746 #endif
16747 }
16748 return resultobj;
16749 fail:
16750 return NULL;
16751 }
16752
16753
16754 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16755 PyObject *resultobj = 0;
16756 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16757 int result;
16758 void *argp1 = 0 ;
16759 int res1 = 0 ;
16760 PyObject *swig_obj[1] ;
16761
16762 if (!args) SWIG_fail;
16763 swig_obj[0] = args;
16764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16765 if (!SWIG_IsOK(res1)) {
16766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16767 }
16768 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16769 {
16770 PyThreadState* __tstate = wxPyBeginAllowThreads();
16771 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
16772 wxPyEndAllowThreads(__tstate);
16773 if (PyErr_Occurred()) SWIG_fail;
16774 }
16775 resultobj = SWIG_From_int(static_cast< int >(result));
16776 return resultobj;
16777 fail:
16778 return NULL;
16779 }
16780
16781
16782 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16783 PyObject *obj;
16784 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16785 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
16786 return SWIG_Py_Void();
16787 }
16788
16789 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16790 return SWIG_Python_InitShadowInstance(args);
16791 }
16792
16793 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16794 PyObject *resultobj = 0;
16795 wxFileTypeInfo *arg1 = 0 ;
16796 wxFileType *result = 0 ;
16797 void *argp1 = 0 ;
16798 int res1 = 0 ;
16799 PyObject * obj0 = 0 ;
16800 char * kwnames[] = {
16801 (char *) "ftInfo", NULL
16802 };
16803
16804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
16805 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
16806 if (!SWIG_IsOK(res1)) {
16807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16808 }
16809 if (!argp1) {
16810 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16811 }
16812 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16813 {
16814 PyThreadState* __tstate = wxPyBeginAllowThreads();
16815 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
16816 wxPyEndAllowThreads(__tstate);
16817 if (PyErr_Occurred()) SWIG_fail;
16818 }
16819 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
16820 return resultobj;
16821 fail:
16822 return NULL;
16823 }
16824
16825
16826 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16827 PyObject *resultobj = 0;
16828 wxFileType *arg1 = (wxFileType *) 0 ;
16829 void *argp1 = 0 ;
16830 int res1 = 0 ;
16831 PyObject *swig_obj[1] ;
16832
16833 if (!args) SWIG_fail;
16834 swig_obj[0] = args;
16835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
16836 if (!SWIG_IsOK(res1)) {
16837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
16838 }
16839 arg1 = reinterpret_cast< wxFileType * >(argp1);
16840 {
16841 PyThreadState* __tstate = wxPyBeginAllowThreads();
16842 delete arg1;
16843
16844 wxPyEndAllowThreads(__tstate);
16845 if (PyErr_Occurred()) SWIG_fail;
16846 }
16847 resultobj = SWIG_Py_Void();
16848 return resultobj;
16849 fail:
16850 return NULL;
16851 }
16852
16853
16854 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16855 PyObject *resultobj = 0;
16856 wxFileType *arg1 = (wxFileType *) 0 ;
16857 PyObject *result = 0 ;
16858 void *argp1 = 0 ;
16859 int res1 = 0 ;
16860 PyObject *swig_obj[1] ;
16861
16862 if (!args) SWIG_fail;
16863 swig_obj[0] = args;
16864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16865 if (!SWIG_IsOK(res1)) {
16866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
16867 }
16868 arg1 = reinterpret_cast< wxFileType * >(argp1);
16869 {
16870 PyThreadState* __tstate = wxPyBeginAllowThreads();
16871 result = (PyObject *)wxFileType_GetMimeType(arg1);
16872 wxPyEndAllowThreads(__tstate);
16873 if (PyErr_Occurred()) SWIG_fail;
16874 }
16875 resultobj = result;
16876 return resultobj;
16877 fail:
16878 return NULL;
16879 }
16880
16881
16882 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16883 PyObject *resultobj = 0;
16884 wxFileType *arg1 = (wxFileType *) 0 ;
16885 PyObject *result = 0 ;
16886 void *argp1 = 0 ;
16887 int res1 = 0 ;
16888 PyObject *swig_obj[1] ;
16889
16890 if (!args) SWIG_fail;
16891 swig_obj[0] = args;
16892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16893 if (!SWIG_IsOK(res1)) {
16894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
16895 }
16896 arg1 = reinterpret_cast< wxFileType * >(argp1);
16897 {
16898 PyThreadState* __tstate = wxPyBeginAllowThreads();
16899 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
16900 wxPyEndAllowThreads(__tstate);
16901 if (PyErr_Occurred()) SWIG_fail;
16902 }
16903 resultobj = result;
16904 return resultobj;
16905 fail:
16906 return NULL;
16907 }
16908
16909
16910 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16911 PyObject *resultobj = 0;
16912 wxFileType *arg1 = (wxFileType *) 0 ;
16913 PyObject *result = 0 ;
16914 void *argp1 = 0 ;
16915 int res1 = 0 ;
16916 PyObject *swig_obj[1] ;
16917
16918 if (!args) SWIG_fail;
16919 swig_obj[0] = args;
16920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16921 if (!SWIG_IsOK(res1)) {
16922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
16923 }
16924 arg1 = reinterpret_cast< wxFileType * >(argp1);
16925 {
16926 PyThreadState* __tstate = wxPyBeginAllowThreads();
16927 result = (PyObject *)wxFileType_GetExtensions(arg1);
16928 wxPyEndAllowThreads(__tstate);
16929 if (PyErr_Occurred()) SWIG_fail;
16930 }
16931 resultobj = result;
16932 return resultobj;
16933 fail:
16934 return NULL;
16935 }
16936
16937
16938 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16939 PyObject *resultobj = 0;
16940 wxFileType *arg1 = (wxFileType *) 0 ;
16941 wxIcon *result = 0 ;
16942 void *argp1 = 0 ;
16943 int res1 = 0 ;
16944 PyObject *swig_obj[1] ;
16945
16946 if (!args) SWIG_fail;
16947 swig_obj[0] = args;
16948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16949 if (!SWIG_IsOK(res1)) {
16950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
16951 }
16952 arg1 = reinterpret_cast< wxFileType * >(argp1);
16953 {
16954 PyThreadState* __tstate = wxPyBeginAllowThreads();
16955 result = (wxIcon *)wxFileType_GetIcon(arg1);
16956 wxPyEndAllowThreads(__tstate);
16957 if (PyErr_Occurred()) SWIG_fail;
16958 }
16959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
16960 return resultobj;
16961 fail:
16962 return NULL;
16963 }
16964
16965
16966 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16967 PyObject *resultobj = 0;
16968 wxFileType *arg1 = (wxFileType *) 0 ;
16969 PyObject *result = 0 ;
16970 void *argp1 = 0 ;
16971 int res1 = 0 ;
16972 PyObject *swig_obj[1] ;
16973
16974 if (!args) SWIG_fail;
16975 swig_obj[0] = args;
16976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16977 if (!SWIG_IsOK(res1)) {
16978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
16979 }
16980 arg1 = reinterpret_cast< wxFileType * >(argp1);
16981 {
16982 PyThreadState* __tstate = wxPyBeginAllowThreads();
16983 result = (PyObject *)wxFileType_GetIconInfo(arg1);
16984 wxPyEndAllowThreads(__tstate);
16985 if (PyErr_Occurred()) SWIG_fail;
16986 }
16987 resultobj = result;
16988 return resultobj;
16989 fail:
16990 return NULL;
16991 }
16992
16993
16994 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16995 PyObject *resultobj = 0;
16996 wxFileType *arg1 = (wxFileType *) 0 ;
16997 PyObject *result = 0 ;
16998 void *argp1 = 0 ;
16999 int res1 = 0 ;
17000 PyObject *swig_obj[1] ;
17001
17002 if (!args) SWIG_fail;
17003 swig_obj[0] = args;
17004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17005 if (!SWIG_IsOK(res1)) {
17006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
17007 }
17008 arg1 = reinterpret_cast< wxFileType * >(argp1);
17009 {
17010 PyThreadState* __tstate = wxPyBeginAllowThreads();
17011 result = (PyObject *)wxFileType_GetDescription(arg1);
17012 wxPyEndAllowThreads(__tstate);
17013 if (PyErr_Occurred()) SWIG_fail;
17014 }
17015 resultobj = result;
17016 return resultobj;
17017 fail:
17018 return NULL;
17019 }
17020
17021
17022 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17023 PyObject *resultobj = 0;
17024 wxFileType *arg1 = (wxFileType *) 0 ;
17025 wxString *arg2 = 0 ;
17026 wxString const &arg3_defvalue = wxPyEmptyString ;
17027 wxString *arg3 = (wxString *) &arg3_defvalue ;
17028 PyObject *result = 0 ;
17029 void *argp1 = 0 ;
17030 int res1 = 0 ;
17031 bool temp2 = false ;
17032 bool temp3 = false ;
17033 PyObject * obj0 = 0 ;
17034 PyObject * obj1 = 0 ;
17035 PyObject * obj2 = 0 ;
17036 char * kwnames[] = {
17037 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17038 };
17039
17040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17042 if (!SWIG_IsOK(res1)) {
17043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17044 }
17045 arg1 = reinterpret_cast< wxFileType * >(argp1);
17046 {
17047 arg2 = wxString_in_helper(obj1);
17048 if (arg2 == NULL) SWIG_fail;
17049 temp2 = true;
17050 }
17051 if (obj2) {
17052 {
17053 arg3 = wxString_in_helper(obj2);
17054 if (arg3 == NULL) SWIG_fail;
17055 temp3 = true;
17056 }
17057 }
17058 {
17059 PyThreadState* __tstate = wxPyBeginAllowThreads();
17060 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17061 wxPyEndAllowThreads(__tstate);
17062 if (PyErr_Occurred()) SWIG_fail;
17063 }
17064 resultobj = result;
17065 {
17066 if (temp2)
17067 delete arg2;
17068 }
17069 {
17070 if (temp3)
17071 delete arg3;
17072 }
17073 return resultobj;
17074 fail:
17075 {
17076 if (temp2)
17077 delete arg2;
17078 }
17079 {
17080 if (temp3)
17081 delete arg3;
17082 }
17083 return NULL;
17084 }
17085
17086
17087 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17088 PyObject *resultobj = 0;
17089 wxFileType *arg1 = (wxFileType *) 0 ;
17090 wxString *arg2 = 0 ;
17091 wxString const &arg3_defvalue = wxPyEmptyString ;
17092 wxString *arg3 = (wxString *) &arg3_defvalue ;
17093 PyObject *result = 0 ;
17094 void *argp1 = 0 ;
17095 int res1 = 0 ;
17096 bool temp2 = false ;
17097 bool temp3 = false ;
17098 PyObject * obj0 = 0 ;
17099 PyObject * obj1 = 0 ;
17100 PyObject * obj2 = 0 ;
17101 char * kwnames[] = {
17102 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17103 };
17104
17105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17107 if (!SWIG_IsOK(res1)) {
17108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17109 }
17110 arg1 = reinterpret_cast< wxFileType * >(argp1);
17111 {
17112 arg2 = wxString_in_helper(obj1);
17113 if (arg2 == NULL) SWIG_fail;
17114 temp2 = true;
17115 }
17116 if (obj2) {
17117 {
17118 arg3 = wxString_in_helper(obj2);
17119 if (arg3 == NULL) SWIG_fail;
17120 temp3 = true;
17121 }
17122 }
17123 {
17124 PyThreadState* __tstate = wxPyBeginAllowThreads();
17125 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17126 wxPyEndAllowThreads(__tstate);
17127 if (PyErr_Occurred()) SWIG_fail;
17128 }
17129 resultobj = result;
17130 {
17131 if (temp2)
17132 delete arg2;
17133 }
17134 {
17135 if (temp3)
17136 delete arg3;
17137 }
17138 return resultobj;
17139 fail:
17140 {
17141 if (temp2)
17142 delete arg2;
17143 }
17144 {
17145 if (temp3)
17146 delete arg3;
17147 }
17148 return NULL;
17149 }
17150
17151
17152 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17153 PyObject *resultobj = 0;
17154 wxFileType *arg1 = (wxFileType *) 0 ;
17155 wxString *arg2 = 0 ;
17156 wxString const &arg3_defvalue = wxPyEmptyString ;
17157 wxString *arg3 = (wxString *) &arg3_defvalue ;
17158 PyObject *result = 0 ;
17159 void *argp1 = 0 ;
17160 int res1 = 0 ;
17161 bool temp2 = false ;
17162 bool temp3 = false ;
17163 PyObject * obj0 = 0 ;
17164 PyObject * obj1 = 0 ;
17165 PyObject * obj2 = 0 ;
17166 char * kwnames[] = {
17167 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17168 };
17169
17170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17172 if (!SWIG_IsOK(res1)) {
17173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
17174 }
17175 arg1 = reinterpret_cast< wxFileType * >(argp1);
17176 {
17177 arg2 = wxString_in_helper(obj1);
17178 if (arg2 == NULL) SWIG_fail;
17179 temp2 = true;
17180 }
17181 if (obj2) {
17182 {
17183 arg3 = wxString_in_helper(obj2);
17184 if (arg3 == NULL) SWIG_fail;
17185 temp3 = true;
17186 }
17187 }
17188 {
17189 PyThreadState* __tstate = wxPyBeginAllowThreads();
17190 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17191 wxPyEndAllowThreads(__tstate);
17192 if (PyErr_Occurred()) SWIG_fail;
17193 }
17194 resultobj = result;
17195 {
17196 if (temp2)
17197 delete arg2;
17198 }
17199 {
17200 if (temp3)
17201 delete arg3;
17202 }
17203 return resultobj;
17204 fail:
17205 {
17206 if (temp2)
17207 delete arg2;
17208 }
17209 {
17210 if (temp3)
17211 delete arg3;
17212 }
17213 return NULL;
17214 }
17215
17216
17217 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17218 PyObject *resultobj = 0;
17219 wxFileType *arg1 = (wxFileType *) 0 ;
17220 wxString *arg2 = 0 ;
17221 wxString *arg3 = 0 ;
17222 bool arg4 = (bool) true ;
17223 bool result;
17224 void *argp1 = 0 ;
17225 int res1 = 0 ;
17226 bool temp2 = false ;
17227 bool temp3 = false ;
17228 bool val4 ;
17229 int ecode4 = 0 ;
17230 PyObject * obj0 = 0 ;
17231 PyObject * obj1 = 0 ;
17232 PyObject * obj2 = 0 ;
17233 PyObject * obj3 = 0 ;
17234 char * kwnames[] = {
17235 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
17236 };
17237
17238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17240 if (!SWIG_IsOK(res1)) {
17241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17242 }
17243 arg1 = reinterpret_cast< wxFileType * >(argp1);
17244 {
17245 arg2 = wxString_in_helper(obj1);
17246 if (arg2 == NULL) SWIG_fail;
17247 temp2 = true;
17248 }
17249 {
17250 arg3 = wxString_in_helper(obj2);
17251 if (arg3 == NULL) SWIG_fail;
17252 temp3 = true;
17253 }
17254 if (obj3) {
17255 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17256 if (!SWIG_IsOK(ecode4)) {
17257 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
17258 }
17259 arg4 = static_cast< bool >(val4);
17260 }
17261 {
17262 PyThreadState* __tstate = wxPyBeginAllowThreads();
17263 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17264 wxPyEndAllowThreads(__tstate);
17265 if (PyErr_Occurred()) SWIG_fail;
17266 }
17267 {
17268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17269 }
17270 {
17271 if (temp2)
17272 delete arg2;
17273 }
17274 {
17275 if (temp3)
17276 delete arg3;
17277 }
17278 return resultobj;
17279 fail:
17280 {
17281 if (temp2)
17282 delete arg2;
17283 }
17284 {
17285 if (temp3)
17286 delete arg3;
17287 }
17288 return NULL;
17289 }
17290
17291
17292 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17293 PyObject *resultobj = 0;
17294 wxFileType *arg1 = (wxFileType *) 0 ;
17295 wxString const &arg2_defvalue = wxPyEmptyString ;
17296 wxString *arg2 = (wxString *) &arg2_defvalue ;
17297 int arg3 = (int) 0 ;
17298 bool result;
17299 void *argp1 = 0 ;
17300 int res1 = 0 ;
17301 bool temp2 = false ;
17302 int val3 ;
17303 int ecode3 = 0 ;
17304 PyObject * obj0 = 0 ;
17305 PyObject * obj1 = 0 ;
17306 PyObject * obj2 = 0 ;
17307 char * kwnames[] = {
17308 (char *) "self",(char *) "cmd",(char *) "index", NULL
17309 };
17310
17311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17313 if (!SWIG_IsOK(res1)) {
17314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17315 }
17316 arg1 = reinterpret_cast< wxFileType * >(argp1);
17317 if (obj1) {
17318 {
17319 arg2 = wxString_in_helper(obj1);
17320 if (arg2 == NULL) SWIG_fail;
17321 temp2 = true;
17322 }
17323 }
17324 if (obj2) {
17325 ecode3 = SWIG_AsVal_int(obj2, &val3);
17326 if (!SWIG_IsOK(ecode3)) {
17327 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
17328 }
17329 arg3 = static_cast< int >(val3);
17330 }
17331 {
17332 PyThreadState* __tstate = wxPyBeginAllowThreads();
17333 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
17334 wxPyEndAllowThreads(__tstate);
17335 if (PyErr_Occurred()) SWIG_fail;
17336 }
17337 {
17338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17339 }
17340 {
17341 if (temp2)
17342 delete arg2;
17343 }
17344 return resultobj;
17345 fail:
17346 {
17347 if (temp2)
17348 delete arg2;
17349 }
17350 return NULL;
17351 }
17352
17353
17354 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17355 PyObject *resultobj = 0;
17356 wxFileType *arg1 = (wxFileType *) 0 ;
17357 bool result;
17358 void *argp1 = 0 ;
17359 int res1 = 0 ;
17360 PyObject *swig_obj[1] ;
17361
17362 if (!args) SWIG_fail;
17363 swig_obj[0] = args;
17364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17365 if (!SWIG_IsOK(res1)) {
17366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
17367 }
17368 arg1 = reinterpret_cast< wxFileType * >(argp1);
17369 {
17370 PyThreadState* __tstate = wxPyBeginAllowThreads();
17371 result = (bool)(arg1)->Unassociate();
17372 wxPyEndAllowThreads(__tstate);
17373 if (PyErr_Occurred()) SWIG_fail;
17374 }
17375 {
17376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17377 }
17378 return resultobj;
17379 fail:
17380 return NULL;
17381 }
17382
17383
17384 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17385 PyObject *resultobj = 0;
17386 wxString *arg1 = 0 ;
17387 wxString *arg2 = 0 ;
17388 wxString const &arg3_defvalue = wxPyEmptyString ;
17389 wxString *arg3 = (wxString *) &arg3_defvalue ;
17390 wxString result;
17391 bool temp1 = false ;
17392 bool temp2 = false ;
17393 bool temp3 = false ;
17394 PyObject * obj0 = 0 ;
17395 PyObject * obj1 = 0 ;
17396 PyObject * obj2 = 0 ;
17397 char * kwnames[] = {
17398 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
17399 };
17400
17401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17402 {
17403 arg1 = wxString_in_helper(obj0);
17404 if (arg1 == NULL) SWIG_fail;
17405 temp1 = true;
17406 }
17407 {
17408 arg2 = wxString_in_helper(obj1);
17409 if (arg2 == NULL) SWIG_fail;
17410 temp2 = true;
17411 }
17412 if (obj2) {
17413 {
17414 arg3 = wxString_in_helper(obj2);
17415 if (arg3 == NULL) SWIG_fail;
17416 temp3 = true;
17417 }
17418 }
17419 {
17420 PyThreadState* __tstate = wxPyBeginAllowThreads();
17421 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17422 wxPyEndAllowThreads(__tstate);
17423 if (PyErr_Occurred()) SWIG_fail;
17424 }
17425 {
17426 #if wxUSE_UNICODE
17427 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17428 #else
17429 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17430 #endif
17431 }
17432 {
17433 if (temp1)
17434 delete arg1;
17435 }
17436 {
17437 if (temp2)
17438 delete arg2;
17439 }
17440 {
17441 if (temp3)
17442 delete arg3;
17443 }
17444 return resultobj;
17445 fail:
17446 {
17447 if (temp1)
17448 delete arg1;
17449 }
17450 {
17451 if (temp2)
17452 delete arg2;
17453 }
17454 {
17455 if (temp3)
17456 delete arg3;
17457 }
17458 return NULL;
17459 }
17460
17461
17462 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17463 PyObject *obj;
17464 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17465 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
17466 return SWIG_Py_Void();
17467 }
17468
17469 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17470 return SWIG_Python_InitShadowInstance(args);
17471 }
17472
17473 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
17474 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
17475 return 1;
17476 }
17477
17478
17479 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
17480 PyObject *pyobj = 0;
17481
17482 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
17483 return pyobj;
17484 }
17485
17486
17487 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17488 PyObject *resultobj = 0;
17489 wxString *arg1 = 0 ;
17490 wxString *arg2 = 0 ;
17491 bool result;
17492 bool temp1 = false ;
17493 bool temp2 = false ;
17494 PyObject * obj0 = 0 ;
17495 PyObject * obj1 = 0 ;
17496 char * kwnames[] = {
17497 (char *) "mimeType",(char *) "wildcard", NULL
17498 };
17499
17500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
17501 {
17502 arg1 = wxString_in_helper(obj0);
17503 if (arg1 == NULL) SWIG_fail;
17504 temp1 = true;
17505 }
17506 {
17507 arg2 = wxString_in_helper(obj1);
17508 if (arg2 == NULL) SWIG_fail;
17509 temp2 = true;
17510 }
17511 {
17512 PyThreadState* __tstate = wxPyBeginAllowThreads();
17513 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
17514 wxPyEndAllowThreads(__tstate);
17515 if (PyErr_Occurred()) SWIG_fail;
17516 }
17517 {
17518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17519 }
17520 {
17521 if (temp1)
17522 delete arg1;
17523 }
17524 {
17525 if (temp2)
17526 delete arg2;
17527 }
17528 return resultobj;
17529 fail:
17530 {
17531 if (temp1)
17532 delete arg1;
17533 }
17534 {
17535 if (temp2)
17536 delete arg2;
17537 }
17538 return NULL;
17539 }
17540
17541
17542 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17543 PyObject *resultobj = 0;
17544 wxMimeTypesManager *result = 0 ;
17545
17546 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
17547 {
17548 PyThreadState* __tstate = wxPyBeginAllowThreads();
17549 result = (wxMimeTypesManager *)new wxMimeTypesManager();
17550 wxPyEndAllowThreads(__tstate);
17551 if (PyErr_Occurred()) SWIG_fail;
17552 }
17553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
17554 return resultobj;
17555 fail:
17556 return NULL;
17557 }
17558
17559
17560 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17561 PyObject *resultobj = 0;
17562 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17563 int arg2 = (int) wxMAILCAP_ALL ;
17564 wxString const &arg3_defvalue = wxPyEmptyString ;
17565 wxString *arg3 = (wxString *) &arg3_defvalue ;
17566 void *argp1 = 0 ;
17567 int res1 = 0 ;
17568 int val2 ;
17569 int ecode2 = 0 ;
17570 bool temp3 = false ;
17571 PyObject * obj0 = 0 ;
17572 PyObject * obj1 = 0 ;
17573 PyObject * obj2 = 0 ;
17574 char * kwnames[] = {
17575 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
17576 };
17577
17578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17580 if (!SWIG_IsOK(res1)) {
17581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17582 }
17583 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17584 if (obj1) {
17585 ecode2 = SWIG_AsVal_int(obj1, &val2);
17586 if (!SWIG_IsOK(ecode2)) {
17587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
17588 }
17589 arg2 = static_cast< int >(val2);
17590 }
17591 if (obj2) {
17592 {
17593 arg3 = wxString_in_helper(obj2);
17594 if (arg3 == NULL) SWIG_fail;
17595 temp3 = true;
17596 }
17597 }
17598 {
17599 PyThreadState* __tstate = wxPyBeginAllowThreads();
17600 (arg1)->Initialize(arg2,(wxString const &)*arg3);
17601 wxPyEndAllowThreads(__tstate);
17602 if (PyErr_Occurred()) SWIG_fail;
17603 }
17604 resultobj = SWIG_Py_Void();
17605 {
17606 if (temp3)
17607 delete arg3;
17608 }
17609 return resultobj;
17610 fail:
17611 {
17612 if (temp3)
17613 delete arg3;
17614 }
17615 return NULL;
17616 }
17617
17618
17619 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17620 PyObject *resultobj = 0;
17621 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17622 void *argp1 = 0 ;
17623 int res1 = 0 ;
17624 PyObject *swig_obj[1] ;
17625
17626 if (!args) SWIG_fail;
17627 swig_obj[0] = args;
17628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17629 if (!SWIG_IsOK(res1)) {
17630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17631 }
17632 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17633 {
17634 PyThreadState* __tstate = wxPyBeginAllowThreads();
17635 (arg1)->ClearData();
17636 wxPyEndAllowThreads(__tstate);
17637 if (PyErr_Occurred()) SWIG_fail;
17638 }
17639 resultobj = SWIG_Py_Void();
17640 return resultobj;
17641 fail:
17642 return NULL;
17643 }
17644
17645
17646 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17647 PyObject *resultobj = 0;
17648 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17649 wxString *arg2 = 0 ;
17650 wxFileType *result = 0 ;
17651 void *argp1 = 0 ;
17652 int res1 = 0 ;
17653 bool temp2 = false ;
17654 PyObject * obj0 = 0 ;
17655 PyObject * obj1 = 0 ;
17656 char * kwnames[] = {
17657 (char *) "self",(char *) "ext", NULL
17658 };
17659
17660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
17661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17662 if (!SWIG_IsOK(res1)) {
17663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17664 }
17665 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17666 {
17667 arg2 = wxString_in_helper(obj1);
17668 if (arg2 == NULL) SWIG_fail;
17669 temp2 = true;
17670 }
17671 {
17672 PyThreadState* __tstate = wxPyBeginAllowThreads();
17673 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
17674 wxPyEndAllowThreads(__tstate);
17675 if (PyErr_Occurred()) SWIG_fail;
17676 }
17677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17678 {
17679 if (temp2)
17680 delete arg2;
17681 }
17682 return resultobj;
17683 fail:
17684 {
17685 if (temp2)
17686 delete arg2;
17687 }
17688 return NULL;
17689 }
17690
17691
17692 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17693 PyObject *resultobj = 0;
17694 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17695 wxString *arg2 = 0 ;
17696 wxFileType *result = 0 ;
17697 void *argp1 = 0 ;
17698 int res1 = 0 ;
17699 bool temp2 = false ;
17700 PyObject * obj0 = 0 ;
17701 PyObject * obj1 = 0 ;
17702 char * kwnames[] = {
17703 (char *) "self",(char *) "mimeType", NULL
17704 };
17705
17706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
17707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17708 if (!SWIG_IsOK(res1)) {
17709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17710 }
17711 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17712 {
17713 arg2 = wxString_in_helper(obj1);
17714 if (arg2 == NULL) SWIG_fail;
17715 temp2 = true;
17716 }
17717 {
17718 PyThreadState* __tstate = wxPyBeginAllowThreads();
17719 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
17720 wxPyEndAllowThreads(__tstate);
17721 if (PyErr_Occurred()) SWIG_fail;
17722 }
17723 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17724 {
17725 if (temp2)
17726 delete arg2;
17727 }
17728 return resultobj;
17729 fail:
17730 {
17731 if (temp2)
17732 delete arg2;
17733 }
17734 return NULL;
17735 }
17736
17737
17738 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17739 PyObject *resultobj = 0;
17740 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17741 wxString *arg2 = 0 ;
17742 bool arg3 = (bool) false ;
17743 bool result;
17744 void *argp1 = 0 ;
17745 int res1 = 0 ;
17746 bool temp2 = false ;
17747 bool val3 ;
17748 int ecode3 = 0 ;
17749 PyObject * obj0 = 0 ;
17750 PyObject * obj1 = 0 ;
17751 PyObject * obj2 = 0 ;
17752 char * kwnames[] = {
17753 (char *) "self",(char *) "filename",(char *) "fallback", NULL
17754 };
17755
17756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17758 if (!SWIG_IsOK(res1)) {
17759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17760 }
17761 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17762 {
17763 arg2 = wxString_in_helper(obj1);
17764 if (arg2 == NULL) SWIG_fail;
17765 temp2 = true;
17766 }
17767 if (obj2) {
17768 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17769 if (!SWIG_IsOK(ecode3)) {
17770 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
17771 }
17772 arg3 = static_cast< bool >(val3);
17773 }
17774 {
17775 PyThreadState* __tstate = wxPyBeginAllowThreads();
17776 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
17777 wxPyEndAllowThreads(__tstate);
17778 if (PyErr_Occurred()) SWIG_fail;
17779 }
17780 {
17781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17782 }
17783 {
17784 if (temp2)
17785 delete arg2;
17786 }
17787 return resultobj;
17788 fail:
17789 {
17790 if (temp2)
17791 delete arg2;
17792 }
17793 return NULL;
17794 }
17795
17796
17797 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17798 PyObject *resultobj = 0;
17799 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17800 wxString *arg2 = 0 ;
17801 bool result;
17802 void *argp1 = 0 ;
17803 int res1 = 0 ;
17804 bool temp2 = false ;
17805 PyObject * obj0 = 0 ;
17806 PyObject * obj1 = 0 ;
17807 char * kwnames[] = {
17808 (char *) "self",(char *) "filename", NULL
17809 };
17810
17811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
17812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17813 if (!SWIG_IsOK(res1)) {
17814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17815 }
17816 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17817 {
17818 arg2 = wxString_in_helper(obj1);
17819 if (arg2 == NULL) SWIG_fail;
17820 temp2 = true;
17821 }
17822 {
17823 PyThreadState* __tstate = wxPyBeginAllowThreads();
17824 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
17825 wxPyEndAllowThreads(__tstate);
17826 if (PyErr_Occurred()) SWIG_fail;
17827 }
17828 {
17829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17830 }
17831 {
17832 if (temp2)
17833 delete arg2;
17834 }
17835 return resultobj;
17836 fail:
17837 {
17838 if (temp2)
17839 delete arg2;
17840 }
17841 return NULL;
17842 }
17843
17844
17845 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17846 PyObject *resultobj = 0;
17847 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17848 PyObject *result = 0 ;
17849 void *argp1 = 0 ;
17850 int res1 = 0 ;
17851 PyObject *swig_obj[1] ;
17852
17853 if (!args) SWIG_fail;
17854 swig_obj[0] = args;
17855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17856 if (!SWIG_IsOK(res1)) {
17857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17858 }
17859 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17860 {
17861 PyThreadState* __tstate = wxPyBeginAllowThreads();
17862 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
17863 wxPyEndAllowThreads(__tstate);
17864 if (PyErr_Occurred()) SWIG_fail;
17865 }
17866 resultobj = result;
17867 return resultobj;
17868 fail:
17869 return NULL;
17870 }
17871
17872
17873 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17874 PyObject *resultobj = 0;
17875 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17876 wxFileTypeInfo *arg2 = 0 ;
17877 void *argp1 = 0 ;
17878 int res1 = 0 ;
17879 void *argp2 = 0 ;
17880 int res2 = 0 ;
17881 PyObject * obj0 = 0 ;
17882 PyObject * obj1 = 0 ;
17883 char * kwnames[] = {
17884 (char *) "self",(char *) "ft", NULL
17885 };
17886
17887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
17888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17889 if (!SWIG_IsOK(res1)) {
17890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17891 }
17892 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17893 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17894 if (!SWIG_IsOK(res2)) {
17895 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17896 }
17897 if (!argp2) {
17898 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17899 }
17900 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17901 {
17902 PyThreadState* __tstate = wxPyBeginAllowThreads();
17903 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
17904 wxPyEndAllowThreads(__tstate);
17905 if (PyErr_Occurred()) SWIG_fail;
17906 }
17907 resultobj = SWIG_Py_Void();
17908 return resultobj;
17909 fail:
17910 return NULL;
17911 }
17912
17913
17914 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17915 PyObject *resultobj = 0;
17916 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17917 wxFileTypeInfo *arg2 = 0 ;
17918 wxFileType *result = 0 ;
17919 void *argp1 = 0 ;
17920 int res1 = 0 ;
17921 void *argp2 = 0 ;
17922 int res2 = 0 ;
17923 PyObject * obj0 = 0 ;
17924 PyObject * obj1 = 0 ;
17925 char * kwnames[] = {
17926 (char *) "self",(char *) "ftInfo", NULL
17927 };
17928
17929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
17930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17931 if (!SWIG_IsOK(res1)) {
17932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17933 }
17934 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17935 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17936 if (!SWIG_IsOK(res2)) {
17937 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17938 }
17939 if (!argp2) {
17940 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17941 }
17942 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17943 {
17944 PyThreadState* __tstate = wxPyBeginAllowThreads();
17945 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
17946 wxPyEndAllowThreads(__tstate);
17947 if (PyErr_Occurred()) SWIG_fail;
17948 }
17949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17950 return resultobj;
17951 fail:
17952 return NULL;
17953 }
17954
17955
17956 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17957 PyObject *resultobj = 0;
17958 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17959 wxFileType *arg2 = (wxFileType *) 0 ;
17960 bool result;
17961 void *argp1 = 0 ;
17962 int res1 = 0 ;
17963 void *argp2 = 0 ;
17964 int res2 = 0 ;
17965 PyObject * obj0 = 0 ;
17966 PyObject * obj1 = 0 ;
17967 char * kwnames[] = {
17968 (char *) "self",(char *) "ft", NULL
17969 };
17970
17971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
17972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17973 if (!SWIG_IsOK(res1)) {
17974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17975 }
17976 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17977 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
17978 if (!SWIG_IsOK(res2)) {
17979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
17980 }
17981 arg2 = reinterpret_cast< wxFileType * >(argp2);
17982 {
17983 PyThreadState* __tstate = wxPyBeginAllowThreads();
17984 result = (bool)(arg1)->Unassociate(arg2);
17985 wxPyEndAllowThreads(__tstate);
17986 if (PyErr_Occurred()) SWIG_fail;
17987 }
17988 {
17989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17990 }
17991 return resultobj;
17992 fail:
17993 return NULL;
17994 }
17995
17996
17997 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17998 PyObject *resultobj = 0;
17999 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18000 void *argp1 = 0 ;
18001 int res1 = 0 ;
18002 PyObject *swig_obj[1] ;
18003
18004 if (!args) SWIG_fail;
18005 swig_obj[0] = args;
18006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
18007 if (!SWIG_IsOK(res1)) {
18008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18009 }
18010 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18011 {
18012 PyThreadState* __tstate = wxPyBeginAllowThreads();
18013 delete arg1;
18014
18015 wxPyEndAllowThreads(__tstate);
18016 if (PyErr_Occurred()) SWIG_fail;
18017 }
18018 resultobj = SWIG_Py_Void();
18019 return resultobj;
18020 fail:
18021 return NULL;
18022 }
18023
18024
18025 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18026 PyObject *obj;
18027 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18028 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
18029 return SWIG_Py_Void();
18030 }
18031
18032 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18033 return SWIG_Python_InitShadowInstance(args);
18034 }
18035
18036 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
18037 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
18038 return 1;
18039 }
18040
18041
18042 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
18043 PyObject *pyobj = 0;
18044
18045 {
18046 #if wxUSE_UNICODE
18047 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18048 #else
18049 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18050 #endif
18051 }
18052 return pyobj;
18053 }
18054
18055
18056 SWIGINTERN int ART_MENU_set(PyObject *) {
18057 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
18058 return 1;
18059 }
18060
18061
18062 SWIGINTERN PyObject *ART_MENU_get(void) {
18063 PyObject *pyobj = 0;
18064
18065 {
18066 #if wxUSE_UNICODE
18067 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18068 #else
18069 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18070 #endif
18071 }
18072 return pyobj;
18073 }
18074
18075
18076 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
18077 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
18078 return 1;
18079 }
18080
18081
18082 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
18083 PyObject *pyobj = 0;
18084
18085 {
18086 #if wxUSE_UNICODE
18087 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18088 #else
18089 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18090 #endif
18091 }
18092 return pyobj;
18093 }
18094
18095
18096 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
18097 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
18098 return 1;
18099 }
18100
18101
18102 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
18103 PyObject *pyobj = 0;
18104
18105 {
18106 #if wxUSE_UNICODE
18107 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18108 #else
18109 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18110 #endif
18111 }
18112 return pyobj;
18113 }
18114
18115
18116 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
18117 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
18118 return 1;
18119 }
18120
18121
18122 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
18123 PyObject *pyobj = 0;
18124
18125 {
18126 #if wxUSE_UNICODE
18127 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18128 #else
18129 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18130 #endif
18131 }
18132 return pyobj;
18133 }
18134
18135
18136 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
18137 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
18138 return 1;
18139 }
18140
18141
18142 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
18143 PyObject *pyobj = 0;
18144
18145 {
18146 #if wxUSE_UNICODE
18147 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18148 #else
18149 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18150 #endif
18151 }
18152 return pyobj;
18153 }
18154
18155
18156 SWIGINTERN int ART_BUTTON_set(PyObject *) {
18157 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
18158 return 1;
18159 }
18160
18161
18162 SWIGINTERN PyObject *ART_BUTTON_get(void) {
18163 PyObject *pyobj = 0;
18164
18165 {
18166 #if wxUSE_UNICODE
18167 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18168 #else
18169 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18170 #endif
18171 }
18172 return pyobj;
18173 }
18174
18175
18176 SWIGINTERN int ART_OTHER_set(PyObject *) {
18177 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
18178 return 1;
18179 }
18180
18181
18182 SWIGINTERN PyObject *ART_OTHER_get(void) {
18183 PyObject *pyobj = 0;
18184
18185 {
18186 #if wxUSE_UNICODE
18187 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18188 #else
18189 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18190 #endif
18191 }
18192 return pyobj;
18193 }
18194
18195
18196 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
18197 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
18198 return 1;
18199 }
18200
18201
18202 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
18203 PyObject *pyobj = 0;
18204
18205 {
18206 #if wxUSE_UNICODE
18207 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18208 #else
18209 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18210 #endif
18211 }
18212 return pyobj;
18213 }
18214
18215
18216 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
18217 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
18218 return 1;
18219 }
18220
18221
18222 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
18223 PyObject *pyobj = 0;
18224
18225 {
18226 #if wxUSE_UNICODE
18227 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18228 #else
18229 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18230 #endif
18231 }
18232 return pyobj;
18233 }
18234
18235
18236 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
18237 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
18238 return 1;
18239 }
18240
18241
18242 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
18243 PyObject *pyobj = 0;
18244
18245 {
18246 #if wxUSE_UNICODE
18247 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18248 #else
18249 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18250 #endif
18251 }
18252 return pyobj;
18253 }
18254
18255
18256 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
18257 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
18258 return 1;
18259 }
18260
18261
18262 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
18263 PyObject *pyobj = 0;
18264
18265 {
18266 #if wxUSE_UNICODE
18267 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18268 #else
18269 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18270 #endif
18271 }
18272 return pyobj;
18273 }
18274
18275
18276 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
18277 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
18278 return 1;
18279 }
18280
18281
18282 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
18283 PyObject *pyobj = 0;
18284
18285 {
18286 #if wxUSE_UNICODE
18287 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18288 #else
18289 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18290 #endif
18291 }
18292 return pyobj;
18293 }
18294
18295
18296 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
18297 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
18298 return 1;
18299 }
18300
18301
18302 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
18303 PyObject *pyobj = 0;
18304
18305 {
18306 #if wxUSE_UNICODE
18307 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18308 #else
18309 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18310 #endif
18311 }
18312 return pyobj;
18313 }
18314
18315
18316 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
18317 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
18318 return 1;
18319 }
18320
18321
18322 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
18323 PyObject *pyobj = 0;
18324
18325 {
18326 #if wxUSE_UNICODE
18327 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18328 #else
18329 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18330 #endif
18331 }
18332 return pyobj;
18333 }
18334
18335
18336 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
18337 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
18338 return 1;
18339 }
18340
18341
18342 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
18343 PyObject *pyobj = 0;
18344
18345 {
18346 #if wxUSE_UNICODE
18347 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18348 #else
18349 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18350 #endif
18351 }
18352 return pyobj;
18353 }
18354
18355
18356 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
18357 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
18358 return 1;
18359 }
18360
18361
18362 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
18363 PyObject *pyobj = 0;
18364
18365 {
18366 #if wxUSE_UNICODE
18367 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18368 #else
18369 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18370 #endif
18371 }
18372 return pyobj;
18373 }
18374
18375
18376 SWIGINTERN int ART_GO_UP_set(PyObject *) {
18377 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
18378 return 1;
18379 }
18380
18381
18382 SWIGINTERN PyObject *ART_GO_UP_get(void) {
18383 PyObject *pyobj = 0;
18384
18385 {
18386 #if wxUSE_UNICODE
18387 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18388 #else
18389 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18390 #endif
18391 }
18392 return pyobj;
18393 }
18394
18395
18396 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
18397 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
18398 return 1;
18399 }
18400
18401
18402 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
18403 PyObject *pyobj = 0;
18404
18405 {
18406 #if wxUSE_UNICODE
18407 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18408 #else
18409 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18410 #endif
18411 }
18412 return pyobj;
18413 }
18414
18415
18416 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
18417 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
18418 return 1;
18419 }
18420
18421
18422 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
18423 PyObject *pyobj = 0;
18424
18425 {
18426 #if wxUSE_UNICODE
18427 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18428 #else
18429 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18430 #endif
18431 }
18432 return pyobj;
18433 }
18434
18435
18436 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
18437 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
18438 return 1;
18439 }
18440
18441
18442 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
18443 PyObject *pyobj = 0;
18444
18445 {
18446 #if wxUSE_UNICODE
18447 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18448 #else
18449 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18450 #endif
18451 }
18452 return pyobj;
18453 }
18454
18455
18456 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
18457 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
18458 return 1;
18459 }
18460
18461
18462 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
18463 PyObject *pyobj = 0;
18464
18465 {
18466 #if wxUSE_UNICODE
18467 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18468 #else
18469 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18470 #endif
18471 }
18472 return pyobj;
18473 }
18474
18475
18476 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
18477 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
18478 return 1;
18479 }
18480
18481
18482 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
18483 PyObject *pyobj = 0;
18484
18485 {
18486 #if wxUSE_UNICODE
18487 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18488 #else
18489 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18490 #endif
18491 }
18492 return pyobj;
18493 }
18494
18495
18496 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
18497 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
18498 return 1;
18499 }
18500
18501
18502 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
18503 PyObject *pyobj = 0;
18504
18505 {
18506 #if wxUSE_UNICODE
18507 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18508 #else
18509 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18510 #endif
18511 }
18512 return pyobj;
18513 }
18514
18515
18516 SWIGINTERN int ART_PRINT_set(PyObject *) {
18517 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
18518 return 1;
18519 }
18520
18521
18522 SWIGINTERN PyObject *ART_PRINT_get(void) {
18523 PyObject *pyobj = 0;
18524
18525 {
18526 #if wxUSE_UNICODE
18527 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18528 #else
18529 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18530 #endif
18531 }
18532 return pyobj;
18533 }
18534
18535
18536 SWIGINTERN int ART_HELP_set(PyObject *) {
18537 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
18538 return 1;
18539 }
18540
18541
18542 SWIGINTERN PyObject *ART_HELP_get(void) {
18543 PyObject *pyobj = 0;
18544
18545 {
18546 #if wxUSE_UNICODE
18547 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18548 #else
18549 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18550 #endif
18551 }
18552 return pyobj;
18553 }
18554
18555
18556 SWIGINTERN int ART_TIP_set(PyObject *) {
18557 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
18558 return 1;
18559 }
18560
18561
18562 SWIGINTERN PyObject *ART_TIP_get(void) {
18563 PyObject *pyobj = 0;
18564
18565 {
18566 #if wxUSE_UNICODE
18567 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18568 #else
18569 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18570 #endif
18571 }
18572 return pyobj;
18573 }
18574
18575
18576 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
18577 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
18578 return 1;
18579 }
18580
18581
18582 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
18583 PyObject *pyobj = 0;
18584
18585 {
18586 #if wxUSE_UNICODE
18587 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18588 #else
18589 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18590 #endif
18591 }
18592 return pyobj;
18593 }
18594
18595
18596 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
18597 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
18598 return 1;
18599 }
18600
18601
18602 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
18603 PyObject *pyobj = 0;
18604
18605 {
18606 #if wxUSE_UNICODE
18607 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18608 #else
18609 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18610 #endif
18611 }
18612 return pyobj;
18613 }
18614
18615
18616 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
18617 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
18618 return 1;
18619 }
18620
18621
18622 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
18623 PyObject *pyobj = 0;
18624
18625 {
18626 #if wxUSE_UNICODE
18627 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18628 #else
18629 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18630 #endif
18631 }
18632 return pyobj;
18633 }
18634
18635
18636 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
18637 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
18638 return 1;
18639 }
18640
18641
18642 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
18643 PyObject *pyobj = 0;
18644
18645 {
18646 #if wxUSE_UNICODE
18647 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18648 #else
18649 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18650 #endif
18651 }
18652 return pyobj;
18653 }
18654
18655
18656 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
18657 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
18658 return 1;
18659 }
18660
18661
18662 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
18663 PyObject *pyobj = 0;
18664
18665 {
18666 #if wxUSE_UNICODE
18667 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18668 #else
18669 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18670 #endif
18671 }
18672 return pyobj;
18673 }
18674
18675
18676 SWIGINTERN int ART_CDROM_set(PyObject *) {
18677 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
18678 return 1;
18679 }
18680
18681
18682 SWIGINTERN PyObject *ART_CDROM_get(void) {
18683 PyObject *pyobj = 0;
18684
18685 {
18686 #if wxUSE_UNICODE
18687 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18688 #else
18689 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18690 #endif
18691 }
18692 return pyobj;
18693 }
18694
18695
18696 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
18697 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
18698 return 1;
18699 }
18700
18701
18702 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
18703 PyObject *pyobj = 0;
18704
18705 {
18706 #if wxUSE_UNICODE
18707 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18708 #else
18709 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18710 #endif
18711 }
18712 return pyobj;
18713 }
18714
18715
18716 SWIGINTERN int ART_FOLDER_set(PyObject *) {
18717 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
18718 return 1;
18719 }
18720
18721
18722 SWIGINTERN PyObject *ART_FOLDER_get(void) {
18723 PyObject *pyobj = 0;
18724
18725 {
18726 #if wxUSE_UNICODE
18727 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18728 #else
18729 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18730 #endif
18731 }
18732 return pyobj;
18733 }
18734
18735
18736 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
18737 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
18738 return 1;
18739 }
18740
18741
18742 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
18743 PyObject *pyobj = 0;
18744
18745 {
18746 #if wxUSE_UNICODE
18747 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18748 #else
18749 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18750 #endif
18751 }
18752 return pyobj;
18753 }
18754
18755
18756 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
18757 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
18758 return 1;
18759 }
18760
18761
18762 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
18763 PyObject *pyobj = 0;
18764
18765 {
18766 #if wxUSE_UNICODE
18767 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18768 #else
18769 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18770 #endif
18771 }
18772 return pyobj;
18773 }
18774
18775
18776 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
18777 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
18778 return 1;
18779 }
18780
18781
18782 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
18783 PyObject *pyobj = 0;
18784
18785 {
18786 #if wxUSE_UNICODE
18787 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18788 #else
18789 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18790 #endif
18791 }
18792 return pyobj;
18793 }
18794
18795
18796 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
18797 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
18798 return 1;
18799 }
18800
18801
18802 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
18803 PyObject *pyobj = 0;
18804
18805 {
18806 #if wxUSE_UNICODE
18807 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18808 #else
18809 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18810 #endif
18811 }
18812 return pyobj;
18813 }
18814
18815
18816 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
18817 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
18818 return 1;
18819 }
18820
18821
18822 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
18823 PyObject *pyobj = 0;
18824
18825 {
18826 #if wxUSE_UNICODE
18827 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18828 #else
18829 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18830 #endif
18831 }
18832 return pyobj;
18833 }
18834
18835
18836 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
18837 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
18838 return 1;
18839 }
18840
18841
18842 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
18843 PyObject *pyobj = 0;
18844
18845 {
18846 #if wxUSE_UNICODE
18847 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18848 #else
18849 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18850 #endif
18851 }
18852 return pyobj;
18853 }
18854
18855
18856 SWIGINTERN int ART_ERROR_set(PyObject *) {
18857 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
18858 return 1;
18859 }
18860
18861
18862 SWIGINTERN PyObject *ART_ERROR_get(void) {
18863 PyObject *pyobj = 0;
18864
18865 {
18866 #if wxUSE_UNICODE
18867 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18868 #else
18869 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18870 #endif
18871 }
18872 return pyobj;
18873 }
18874
18875
18876 SWIGINTERN int ART_QUESTION_set(PyObject *) {
18877 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
18878 return 1;
18879 }
18880
18881
18882 SWIGINTERN PyObject *ART_QUESTION_get(void) {
18883 PyObject *pyobj = 0;
18884
18885 {
18886 #if wxUSE_UNICODE
18887 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18888 #else
18889 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18890 #endif
18891 }
18892 return pyobj;
18893 }
18894
18895
18896 SWIGINTERN int ART_WARNING_set(PyObject *) {
18897 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
18898 return 1;
18899 }
18900
18901
18902 SWIGINTERN PyObject *ART_WARNING_get(void) {
18903 PyObject *pyobj = 0;
18904
18905 {
18906 #if wxUSE_UNICODE
18907 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18908 #else
18909 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18910 #endif
18911 }
18912 return pyobj;
18913 }
18914
18915
18916 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
18917 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
18918 return 1;
18919 }
18920
18921
18922 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
18923 PyObject *pyobj = 0;
18924
18925 {
18926 #if wxUSE_UNICODE
18927 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18928 #else
18929 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18930 #endif
18931 }
18932 return pyobj;
18933 }
18934
18935
18936 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
18937 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
18938 return 1;
18939 }
18940
18941
18942 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
18943 PyObject *pyobj = 0;
18944
18945 {
18946 #if wxUSE_UNICODE
18947 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18948 #else
18949 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18950 #endif
18951 }
18952 return pyobj;
18953 }
18954
18955
18956 SWIGINTERN int ART_COPY_set(PyObject *) {
18957 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
18958 return 1;
18959 }
18960
18961
18962 SWIGINTERN PyObject *ART_COPY_get(void) {
18963 PyObject *pyobj = 0;
18964
18965 {
18966 #if wxUSE_UNICODE
18967 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18968 #else
18969 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18970 #endif
18971 }
18972 return pyobj;
18973 }
18974
18975
18976 SWIGINTERN int ART_CUT_set(PyObject *) {
18977 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
18978 return 1;
18979 }
18980
18981
18982 SWIGINTERN PyObject *ART_CUT_get(void) {
18983 PyObject *pyobj = 0;
18984
18985 {
18986 #if wxUSE_UNICODE
18987 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18988 #else
18989 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18990 #endif
18991 }
18992 return pyobj;
18993 }
18994
18995
18996 SWIGINTERN int ART_PASTE_set(PyObject *) {
18997 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
18998 return 1;
18999 }
19000
19001
19002 SWIGINTERN PyObject *ART_PASTE_get(void) {
19003 PyObject *pyobj = 0;
19004
19005 {
19006 #if wxUSE_UNICODE
19007 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
19008 #else
19009 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
19010 #endif
19011 }
19012 return pyobj;
19013 }
19014
19015
19016 SWIGINTERN int ART_DELETE_set(PyObject *) {
19017 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
19018 return 1;
19019 }
19020
19021
19022 SWIGINTERN PyObject *ART_DELETE_get(void) {
19023 PyObject *pyobj = 0;
19024
19025 {
19026 #if wxUSE_UNICODE
19027 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19028 #else
19029 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19030 #endif
19031 }
19032 return pyobj;
19033 }
19034
19035
19036 SWIGINTERN int ART_NEW_set(PyObject *) {
19037 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
19038 return 1;
19039 }
19040
19041
19042 SWIGINTERN PyObject *ART_NEW_get(void) {
19043 PyObject *pyobj = 0;
19044
19045 {
19046 #if wxUSE_UNICODE
19047 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19048 #else
19049 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19050 #endif
19051 }
19052 return pyobj;
19053 }
19054
19055
19056 SWIGINTERN int ART_UNDO_set(PyObject *) {
19057 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
19058 return 1;
19059 }
19060
19061
19062 SWIGINTERN PyObject *ART_UNDO_get(void) {
19063 PyObject *pyobj = 0;
19064
19065 {
19066 #if wxUSE_UNICODE
19067 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19068 #else
19069 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19070 #endif
19071 }
19072 return pyobj;
19073 }
19074
19075
19076 SWIGINTERN int ART_REDO_set(PyObject *) {
19077 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
19078 return 1;
19079 }
19080
19081
19082 SWIGINTERN PyObject *ART_REDO_get(void) {
19083 PyObject *pyobj = 0;
19084
19085 {
19086 #if wxUSE_UNICODE
19087 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19088 #else
19089 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19090 #endif
19091 }
19092 return pyobj;
19093 }
19094
19095
19096 SWIGINTERN int ART_QUIT_set(PyObject *) {
19097 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
19098 return 1;
19099 }
19100
19101
19102 SWIGINTERN PyObject *ART_QUIT_get(void) {
19103 PyObject *pyobj = 0;
19104
19105 {
19106 #if wxUSE_UNICODE
19107 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19108 #else
19109 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19110 #endif
19111 }
19112 return pyobj;
19113 }
19114
19115
19116 SWIGINTERN int ART_FIND_set(PyObject *) {
19117 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
19118 return 1;
19119 }
19120
19121
19122 SWIGINTERN PyObject *ART_FIND_get(void) {
19123 PyObject *pyobj = 0;
19124
19125 {
19126 #if wxUSE_UNICODE
19127 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19128 #else
19129 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19130 #endif
19131 }
19132 return pyobj;
19133 }
19134
19135
19136 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
19137 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
19138 return 1;
19139 }
19140
19141
19142 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
19143 PyObject *pyobj = 0;
19144
19145 {
19146 #if wxUSE_UNICODE
19147 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19148 #else
19149 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19150 #endif
19151 }
19152 return pyobj;
19153 }
19154
19155
19156 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19157 PyObject *resultobj = 0;
19158 wxPyArtProvider *result = 0 ;
19159
19160 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
19161 {
19162 if (!wxPyCheckForApp()) SWIG_fail;
19163 PyThreadState* __tstate = wxPyBeginAllowThreads();
19164 result = (wxPyArtProvider *)new wxPyArtProvider();
19165 wxPyEndAllowThreads(__tstate);
19166 if (PyErr_Occurred()) SWIG_fail;
19167 }
19168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
19169 return resultobj;
19170 fail:
19171 return NULL;
19172 }
19173
19174
19175 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19176 PyObject *resultobj = 0;
19177 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19178 void *argp1 = 0 ;
19179 int res1 = 0 ;
19180 PyObject *swig_obj[1] ;
19181
19182 if (!args) SWIG_fail;
19183 swig_obj[0] = args;
19184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19185 if (!SWIG_IsOK(res1)) {
19186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19187 }
19188 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19189 {
19190 PyThreadState* __tstate = wxPyBeginAllowThreads();
19191 delete arg1;
19192
19193 wxPyEndAllowThreads(__tstate);
19194 if (PyErr_Occurred()) SWIG_fail;
19195 }
19196 resultobj = SWIG_Py_Void();
19197 return resultobj;
19198 fail:
19199 return NULL;
19200 }
19201
19202
19203 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19204 PyObject *resultobj = 0;
19205 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19206 PyObject *arg2 = (PyObject *) 0 ;
19207 PyObject *arg3 = (PyObject *) 0 ;
19208 void *argp1 = 0 ;
19209 int res1 = 0 ;
19210 PyObject * obj0 = 0 ;
19211 PyObject * obj1 = 0 ;
19212 PyObject * obj2 = 0 ;
19213 char * kwnames[] = {
19214 (char *) "self",(char *) "self",(char *) "_class", NULL
19215 };
19216
19217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19219 if (!SWIG_IsOK(res1)) {
19220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19221 }
19222 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19223 arg2 = obj1;
19224 arg3 = obj2;
19225 {
19226 PyThreadState* __tstate = wxPyBeginAllowThreads();
19227 (arg1)->_setCallbackInfo(arg2,arg3);
19228 wxPyEndAllowThreads(__tstate);
19229 if (PyErr_Occurred()) SWIG_fail;
19230 }
19231 resultobj = SWIG_Py_Void();
19232 return resultobj;
19233 fail:
19234 return NULL;
19235 }
19236
19237
19238 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19239 PyObject *resultobj = 0;
19240 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19241 int res1 = 0 ;
19242 PyObject * obj0 = 0 ;
19243 char * kwnames[] = {
19244 (char *) "provider", NULL
19245 };
19246
19247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
19248 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19249 if (!SWIG_IsOK(res1)) {
19250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19251 }
19252 {
19253 PyThreadState* __tstate = wxPyBeginAllowThreads();
19254 wxPyArtProvider::PushProvider(arg1);
19255 wxPyEndAllowThreads(__tstate);
19256 if (PyErr_Occurred()) SWIG_fail;
19257 }
19258 resultobj = SWIG_Py_Void();
19259 return resultobj;
19260 fail:
19261 return NULL;
19262 }
19263
19264
19265 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19266 PyObject *resultobj = 0;
19267 bool result;
19268
19269 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
19270 {
19271 PyThreadState* __tstate = wxPyBeginAllowThreads();
19272 result = (bool)wxPyArtProvider::PopProvider();
19273 wxPyEndAllowThreads(__tstate);
19274 if (PyErr_Occurred()) SWIG_fail;
19275 }
19276 {
19277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19278 }
19279 return resultobj;
19280 fail:
19281 return NULL;
19282 }
19283
19284
19285 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19286 PyObject *resultobj = 0;
19287 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19288 bool result;
19289 void *argp1 = 0 ;
19290 int res1 = 0 ;
19291 PyObject * obj0 = 0 ;
19292 char * kwnames[] = {
19293 (char *) "provider", NULL
19294 };
19295
19296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
19297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19298 if (!SWIG_IsOK(res1)) {
19299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19300 }
19301 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19302 {
19303 PyThreadState* __tstate = wxPyBeginAllowThreads();
19304 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
19305 wxPyEndAllowThreads(__tstate);
19306 if (PyErr_Occurred()) SWIG_fail;
19307 }
19308 {
19309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19310 }
19311 return resultobj;
19312 fail:
19313 return NULL;
19314 }
19315
19316
19317 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19318 PyObject *resultobj = 0;
19319 wxString *arg1 = 0 ;
19320 wxString const &arg2_defvalue = wxPyART_OTHER ;
19321 wxString *arg2 = (wxString *) &arg2_defvalue ;
19322 wxSize const &arg3_defvalue = wxDefaultSize ;
19323 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19324 wxBitmap result;
19325 bool temp1 = false ;
19326 bool temp2 = false ;
19327 wxSize temp3 ;
19328 PyObject * obj0 = 0 ;
19329 PyObject * obj1 = 0 ;
19330 PyObject * obj2 = 0 ;
19331 char * kwnames[] = {
19332 (char *) "id",(char *) "client",(char *) "size", NULL
19333 };
19334
19335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19336 {
19337 arg1 = wxString_in_helper(obj0);
19338 if (arg1 == NULL) SWIG_fail;
19339 temp1 = true;
19340 }
19341 if (obj1) {
19342 {
19343 arg2 = wxString_in_helper(obj1);
19344 if (arg2 == NULL) SWIG_fail;
19345 temp2 = true;
19346 }
19347 }
19348 if (obj2) {
19349 {
19350 arg3 = &temp3;
19351 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19352 }
19353 }
19354 {
19355 if (!wxPyCheckForApp()) SWIG_fail;
19356 PyThreadState* __tstate = wxPyBeginAllowThreads();
19357 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19358 wxPyEndAllowThreads(__tstate);
19359 if (PyErr_Occurred()) SWIG_fail;
19360 }
19361 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19362 {
19363 if (temp1)
19364 delete arg1;
19365 }
19366 {
19367 if (temp2)
19368 delete arg2;
19369 }
19370 return resultobj;
19371 fail:
19372 {
19373 if (temp1)
19374 delete arg1;
19375 }
19376 {
19377 if (temp2)
19378 delete arg2;
19379 }
19380 return NULL;
19381 }
19382
19383
19384 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19385 PyObject *resultobj = 0;
19386 wxString *arg1 = 0 ;
19387 wxString const &arg2_defvalue = wxPyART_OTHER ;
19388 wxString *arg2 = (wxString *) &arg2_defvalue ;
19389 wxSize const &arg3_defvalue = wxDefaultSize ;
19390 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19391 wxIcon result;
19392 bool temp1 = false ;
19393 bool temp2 = false ;
19394 wxSize temp3 ;
19395 PyObject * obj0 = 0 ;
19396 PyObject * obj1 = 0 ;
19397 PyObject * obj2 = 0 ;
19398 char * kwnames[] = {
19399 (char *) "id",(char *) "client",(char *) "size", NULL
19400 };
19401
19402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19403 {
19404 arg1 = wxString_in_helper(obj0);
19405 if (arg1 == NULL) SWIG_fail;
19406 temp1 = true;
19407 }
19408 if (obj1) {
19409 {
19410 arg2 = wxString_in_helper(obj1);
19411 if (arg2 == NULL) SWIG_fail;
19412 temp2 = true;
19413 }
19414 }
19415 if (obj2) {
19416 {
19417 arg3 = &temp3;
19418 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19419 }
19420 }
19421 {
19422 if (!wxPyCheckForApp()) SWIG_fail;
19423 PyThreadState* __tstate = wxPyBeginAllowThreads();
19424 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19425 wxPyEndAllowThreads(__tstate);
19426 if (PyErr_Occurred()) SWIG_fail;
19427 }
19428 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
19429 {
19430 if (temp1)
19431 delete arg1;
19432 }
19433 {
19434 if (temp2)
19435 delete arg2;
19436 }
19437 return resultobj;
19438 fail:
19439 {
19440 if (temp1)
19441 delete arg1;
19442 }
19443 {
19444 if (temp2)
19445 delete arg2;
19446 }
19447 return NULL;
19448 }
19449
19450
19451 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19452 PyObject *resultobj = 0;
19453 wxString *arg1 = 0 ;
19454 bool arg2 = (bool) false ;
19455 wxSize result;
19456 bool temp1 = false ;
19457 bool val2 ;
19458 int ecode2 = 0 ;
19459 PyObject * obj0 = 0 ;
19460 PyObject * obj1 = 0 ;
19461 char * kwnames[] = {
19462 (char *) "client",(char *) "platform_dependent", NULL
19463 };
19464
19465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
19466 {
19467 arg1 = wxString_in_helper(obj0);
19468 if (arg1 == NULL) SWIG_fail;
19469 temp1 = true;
19470 }
19471 if (obj1) {
19472 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19473 if (!SWIG_IsOK(ecode2)) {
19474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
19475 }
19476 arg2 = static_cast< bool >(val2);
19477 }
19478 {
19479 PyThreadState* __tstate = wxPyBeginAllowThreads();
19480 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
19481 wxPyEndAllowThreads(__tstate);
19482 if (PyErr_Occurred()) SWIG_fail;
19483 }
19484 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
19485 {
19486 if (temp1)
19487 delete arg1;
19488 }
19489 return resultobj;
19490 fail:
19491 {
19492 if (temp1)
19493 delete arg1;
19494 }
19495 return NULL;
19496 }
19497
19498
19499 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19500 PyObject *resultobj = 0;
19501 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19502 void *argp1 = 0 ;
19503 int res1 = 0 ;
19504 PyObject *swig_obj[1] ;
19505
19506 if (!args) SWIG_fail;
19507 swig_obj[0] = args;
19508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19509 if (!SWIG_IsOK(res1)) {
19510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19511 }
19512 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19513 {
19514 PyThreadState* __tstate = wxPyBeginAllowThreads();
19515 wxPyArtProvider_Destroy(arg1);
19516 wxPyEndAllowThreads(__tstate);
19517 if (PyErr_Occurred()) SWIG_fail;
19518 }
19519 resultobj = SWIG_Py_Void();
19520 return resultobj;
19521 fail:
19522 return NULL;
19523 }
19524
19525
19526 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19527 PyObject *obj;
19528 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19529 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
19530 return SWIG_Py_Void();
19531 }
19532
19533 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19534 return SWIG_Python_InitShadowInstance(args);
19535 }
19536
19537 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19538 PyObject *resultobj = 0;
19539 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19540 void *argp1 = 0 ;
19541 int res1 = 0 ;
19542 PyObject *swig_obj[1] ;
19543
19544 if (!args) SWIG_fail;
19545 swig_obj[0] = args;
19546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19547 if (!SWIG_IsOK(res1)) {
19548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19549 }
19550 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19551 {
19552 PyThreadState* __tstate = wxPyBeginAllowThreads();
19553 delete arg1;
19554
19555 wxPyEndAllowThreads(__tstate);
19556 if (PyErr_Occurred()) SWIG_fail;
19557 }
19558 resultobj = SWIG_Py_Void();
19559 return resultobj;
19560 fail:
19561 return NULL;
19562 }
19563
19564
19565 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19566 PyObject *resultobj = 0;
19567 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19568 wxConfigBase *result = 0 ;
19569 int res1 = 0 ;
19570 PyObject * obj0 = 0 ;
19571 char * kwnames[] = {
19572 (char *) "config", NULL
19573 };
19574
19575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
19576 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19577 if (!SWIG_IsOK(res1)) {
19578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19579 }
19580 {
19581 PyThreadState* __tstate = wxPyBeginAllowThreads();
19582 result = (wxConfigBase *)wxConfigBase::Set(arg1);
19583 wxPyEndAllowThreads(__tstate);
19584 if (PyErr_Occurred()) SWIG_fail;
19585 }
19586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19587 return resultobj;
19588 fail:
19589 return NULL;
19590 }
19591
19592
19593 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19594 PyObject *resultobj = 0;
19595 bool arg1 = (bool) true ;
19596 wxConfigBase *result = 0 ;
19597 bool val1 ;
19598 int ecode1 = 0 ;
19599 PyObject * obj0 = 0 ;
19600 char * kwnames[] = {
19601 (char *) "createOnDemand", NULL
19602 };
19603
19604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
19605 if (obj0) {
19606 ecode1 = SWIG_AsVal_bool(obj0, &val1);
19607 if (!SWIG_IsOK(ecode1)) {
19608 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
19609 }
19610 arg1 = static_cast< bool >(val1);
19611 }
19612 {
19613 PyThreadState* __tstate = wxPyBeginAllowThreads();
19614 result = (wxConfigBase *)wxConfigBase::Get(arg1);
19615 wxPyEndAllowThreads(__tstate);
19616 if (PyErr_Occurred()) SWIG_fail;
19617 }
19618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19619 return resultobj;
19620 fail:
19621 return NULL;
19622 }
19623
19624
19625 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19626 PyObject *resultobj = 0;
19627 wxConfigBase *result = 0 ;
19628
19629 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
19630 {
19631 PyThreadState* __tstate = wxPyBeginAllowThreads();
19632 result = (wxConfigBase *)wxConfigBase::Create();
19633 wxPyEndAllowThreads(__tstate);
19634 if (PyErr_Occurred()) SWIG_fail;
19635 }
19636 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19637 return resultobj;
19638 fail:
19639 return NULL;
19640 }
19641
19642
19643 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19644 PyObject *resultobj = 0;
19645
19646 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
19647 {
19648 PyThreadState* __tstate = wxPyBeginAllowThreads();
19649 wxConfigBase::DontCreateOnDemand();
19650 wxPyEndAllowThreads(__tstate);
19651 if (PyErr_Occurred()) SWIG_fail;
19652 }
19653 resultobj = SWIG_Py_Void();
19654 return resultobj;
19655 fail:
19656 return NULL;
19657 }
19658
19659
19660 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19661 PyObject *resultobj = 0;
19662 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19663 wxString *arg2 = 0 ;
19664 void *argp1 = 0 ;
19665 int res1 = 0 ;
19666 bool temp2 = false ;
19667 PyObject * obj0 = 0 ;
19668 PyObject * obj1 = 0 ;
19669 char * kwnames[] = {
19670 (char *) "self",(char *) "path", NULL
19671 };
19672
19673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
19674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19675 if (!SWIG_IsOK(res1)) {
19676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19677 }
19678 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19679 {
19680 arg2 = wxString_in_helper(obj1);
19681 if (arg2 == NULL) SWIG_fail;
19682 temp2 = true;
19683 }
19684 {
19685 PyThreadState* __tstate = wxPyBeginAllowThreads();
19686 (arg1)->SetPath((wxString const &)*arg2);
19687 wxPyEndAllowThreads(__tstate);
19688 if (PyErr_Occurred()) SWIG_fail;
19689 }
19690 resultobj = SWIG_Py_Void();
19691 {
19692 if (temp2)
19693 delete arg2;
19694 }
19695 return resultobj;
19696 fail:
19697 {
19698 if (temp2)
19699 delete arg2;
19700 }
19701 return NULL;
19702 }
19703
19704
19705 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19706 PyObject *resultobj = 0;
19707 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19708 wxString *result = 0 ;
19709 void *argp1 = 0 ;
19710 int res1 = 0 ;
19711 PyObject *swig_obj[1] ;
19712
19713 if (!args) SWIG_fail;
19714 swig_obj[0] = args;
19715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19716 if (!SWIG_IsOK(res1)) {
19717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19718 }
19719 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19720 {
19721 PyThreadState* __tstate = wxPyBeginAllowThreads();
19722 {
19723 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
19724 result = (wxString *) &_result_ref;
19725 }
19726 wxPyEndAllowThreads(__tstate);
19727 if (PyErr_Occurred()) SWIG_fail;
19728 }
19729 {
19730 #if wxUSE_UNICODE
19731 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19732 #else
19733 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19734 #endif
19735 }
19736 return resultobj;
19737 fail:
19738 return NULL;
19739 }
19740
19741
19742 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19743 PyObject *resultobj = 0;
19744 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19745 PyObject *result = 0 ;
19746 void *argp1 = 0 ;
19747 int res1 = 0 ;
19748 PyObject *swig_obj[1] ;
19749
19750 if (!args) SWIG_fail;
19751 swig_obj[0] = args;
19752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19753 if (!SWIG_IsOK(res1)) {
19754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19755 }
19756 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19757 {
19758 PyThreadState* __tstate = wxPyBeginAllowThreads();
19759 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
19760 wxPyEndAllowThreads(__tstate);
19761 if (PyErr_Occurred()) SWIG_fail;
19762 }
19763 resultobj = result;
19764 return resultobj;
19765 fail:
19766 return NULL;
19767 }
19768
19769
19770 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19771 PyObject *resultobj = 0;
19772 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19773 long arg2 ;
19774 PyObject *result = 0 ;
19775 void *argp1 = 0 ;
19776 int res1 = 0 ;
19777 long val2 ;
19778 int ecode2 = 0 ;
19779 PyObject * obj0 = 0 ;
19780 PyObject * obj1 = 0 ;
19781 char * kwnames[] = {
19782 (char *) "self",(char *) "index", NULL
19783 };
19784
19785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19787 if (!SWIG_IsOK(res1)) {
19788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19789 }
19790 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19791 ecode2 = SWIG_AsVal_long(obj1, &val2);
19792 if (!SWIG_IsOK(ecode2)) {
19793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
19794 }
19795 arg2 = static_cast< long >(val2);
19796 {
19797 PyThreadState* __tstate = wxPyBeginAllowThreads();
19798 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
19799 wxPyEndAllowThreads(__tstate);
19800 if (PyErr_Occurred()) SWIG_fail;
19801 }
19802 resultobj = result;
19803 return resultobj;
19804 fail:
19805 return NULL;
19806 }
19807
19808
19809 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19810 PyObject *resultobj = 0;
19811 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19812 PyObject *result = 0 ;
19813 void *argp1 = 0 ;
19814 int res1 = 0 ;
19815 PyObject *swig_obj[1] ;
19816
19817 if (!args) SWIG_fail;
19818 swig_obj[0] = args;
19819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19820 if (!SWIG_IsOK(res1)) {
19821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19822 }
19823 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19824 {
19825 PyThreadState* __tstate = wxPyBeginAllowThreads();
19826 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
19827 wxPyEndAllowThreads(__tstate);
19828 if (PyErr_Occurred()) SWIG_fail;
19829 }
19830 resultobj = result;
19831 return resultobj;
19832 fail:
19833 return NULL;
19834 }
19835
19836
19837 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19838 PyObject *resultobj = 0;
19839 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19840 long arg2 ;
19841 PyObject *result = 0 ;
19842 void *argp1 = 0 ;
19843 int res1 = 0 ;
19844 long val2 ;
19845 int ecode2 = 0 ;
19846 PyObject * obj0 = 0 ;
19847 PyObject * obj1 = 0 ;
19848 char * kwnames[] = {
19849 (char *) "self",(char *) "index", NULL
19850 };
19851
19852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19854 if (!SWIG_IsOK(res1)) {
19855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19856 }
19857 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19858 ecode2 = SWIG_AsVal_long(obj1, &val2);
19859 if (!SWIG_IsOK(ecode2)) {
19860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
19861 }
19862 arg2 = static_cast< long >(val2);
19863 {
19864 PyThreadState* __tstate = wxPyBeginAllowThreads();
19865 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
19866 wxPyEndAllowThreads(__tstate);
19867 if (PyErr_Occurred()) SWIG_fail;
19868 }
19869 resultobj = result;
19870 return resultobj;
19871 fail:
19872 return NULL;
19873 }
19874
19875
19876 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19877 PyObject *resultobj = 0;
19878 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19879 bool arg2 = (bool) false ;
19880 size_t result;
19881 void *argp1 = 0 ;
19882 int res1 = 0 ;
19883 bool val2 ;
19884 int ecode2 = 0 ;
19885 PyObject * obj0 = 0 ;
19886 PyObject * obj1 = 0 ;
19887 char * kwnames[] = {
19888 (char *) "self",(char *) "recursive", NULL
19889 };
19890
19891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
19892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19893 if (!SWIG_IsOK(res1)) {
19894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19895 }
19896 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19897 if (obj1) {
19898 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19899 if (!SWIG_IsOK(ecode2)) {
19900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
19901 }
19902 arg2 = static_cast< bool >(val2);
19903 }
19904 {
19905 PyThreadState* __tstate = wxPyBeginAllowThreads();
19906 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
19907 wxPyEndAllowThreads(__tstate);
19908 if (PyErr_Occurred()) SWIG_fail;
19909 }
19910 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19911 return resultobj;
19912 fail:
19913 return NULL;
19914 }
19915
19916
19917 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19918 PyObject *resultobj = 0;
19919 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19920 bool arg2 = (bool) false ;
19921 size_t result;
19922 void *argp1 = 0 ;
19923 int res1 = 0 ;
19924 bool val2 ;
19925 int ecode2 = 0 ;
19926 PyObject * obj0 = 0 ;
19927 PyObject * obj1 = 0 ;
19928 char * kwnames[] = {
19929 (char *) "self",(char *) "recursive", NULL
19930 };
19931
19932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
19933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19934 if (!SWIG_IsOK(res1)) {
19935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19936 }
19937 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19938 if (obj1) {
19939 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19940 if (!SWIG_IsOK(ecode2)) {
19941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
19942 }
19943 arg2 = static_cast< bool >(val2);
19944 }
19945 {
19946 PyThreadState* __tstate = wxPyBeginAllowThreads();
19947 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
19948 wxPyEndAllowThreads(__tstate);
19949 if (PyErr_Occurred()) SWIG_fail;
19950 }
19951 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19952 return resultobj;
19953 fail:
19954 return NULL;
19955 }
19956
19957
19958 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19959 PyObject *resultobj = 0;
19960 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19961 wxString *arg2 = 0 ;
19962 bool result;
19963 void *argp1 = 0 ;
19964 int res1 = 0 ;
19965 bool temp2 = false ;
19966 PyObject * obj0 = 0 ;
19967 PyObject * obj1 = 0 ;
19968 char * kwnames[] = {
19969 (char *) "self",(char *) "name", NULL
19970 };
19971
19972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19974 if (!SWIG_IsOK(res1)) {
19975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19976 }
19977 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19978 {
19979 arg2 = wxString_in_helper(obj1);
19980 if (arg2 == NULL) SWIG_fail;
19981 temp2 = true;
19982 }
19983 {
19984 PyThreadState* __tstate = wxPyBeginAllowThreads();
19985 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
19986 wxPyEndAllowThreads(__tstate);
19987 if (PyErr_Occurred()) SWIG_fail;
19988 }
19989 {
19990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19991 }
19992 {
19993 if (temp2)
19994 delete arg2;
19995 }
19996 return resultobj;
19997 fail:
19998 {
19999 if (temp2)
20000 delete arg2;
20001 }
20002 return NULL;
20003 }
20004
20005
20006 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20007 PyObject *resultobj = 0;
20008 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20009 wxString *arg2 = 0 ;
20010 bool result;
20011 void *argp1 = 0 ;
20012 int res1 = 0 ;
20013 bool temp2 = false ;
20014 PyObject * obj0 = 0 ;
20015 PyObject * obj1 = 0 ;
20016 char * kwnames[] = {
20017 (char *) "self",(char *) "name", NULL
20018 };
20019
20020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20022 if (!SWIG_IsOK(res1)) {
20023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20024 }
20025 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20026 {
20027 arg2 = wxString_in_helper(obj1);
20028 if (arg2 == NULL) SWIG_fail;
20029 temp2 = true;
20030 }
20031 {
20032 PyThreadState* __tstate = wxPyBeginAllowThreads();
20033 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
20034 wxPyEndAllowThreads(__tstate);
20035 if (PyErr_Occurred()) SWIG_fail;
20036 }
20037 {
20038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20039 }
20040 {
20041 if (temp2)
20042 delete arg2;
20043 }
20044 return resultobj;
20045 fail:
20046 {
20047 if (temp2)
20048 delete arg2;
20049 }
20050 return NULL;
20051 }
20052
20053
20054 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20055 PyObject *resultobj = 0;
20056 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20057 wxString *arg2 = 0 ;
20058 bool result;
20059 void *argp1 = 0 ;
20060 int res1 = 0 ;
20061 bool temp2 = false ;
20062 PyObject * obj0 = 0 ;
20063 PyObject * obj1 = 0 ;
20064 char * kwnames[] = {
20065 (char *) "self",(char *) "name", NULL
20066 };
20067
20068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
20069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20070 if (!SWIG_IsOK(res1)) {
20071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20072 }
20073 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20074 {
20075 arg2 = wxString_in_helper(obj1);
20076 if (arg2 == NULL) SWIG_fail;
20077 temp2 = true;
20078 }
20079 {
20080 PyThreadState* __tstate = wxPyBeginAllowThreads();
20081 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
20082 wxPyEndAllowThreads(__tstate);
20083 if (PyErr_Occurred()) SWIG_fail;
20084 }
20085 {
20086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20087 }
20088 {
20089 if (temp2)
20090 delete arg2;
20091 }
20092 return resultobj;
20093 fail:
20094 {
20095 if (temp2)
20096 delete arg2;
20097 }
20098 return NULL;
20099 }
20100
20101
20102 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20103 PyObject *resultobj = 0;
20104 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20105 wxString *arg2 = 0 ;
20106 wxConfigBase::EntryType result;
20107 void *argp1 = 0 ;
20108 int res1 = 0 ;
20109 bool temp2 = false ;
20110 PyObject * obj0 = 0 ;
20111 PyObject * obj1 = 0 ;
20112 char * kwnames[] = {
20113 (char *) "self",(char *) "name", NULL
20114 };
20115
20116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
20117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20118 if (!SWIG_IsOK(res1)) {
20119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20120 }
20121 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20122 {
20123 arg2 = wxString_in_helper(obj1);
20124 if (arg2 == NULL) SWIG_fail;
20125 temp2 = true;
20126 }
20127 {
20128 PyThreadState* __tstate = wxPyBeginAllowThreads();
20129 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
20130 wxPyEndAllowThreads(__tstate);
20131 if (PyErr_Occurred()) SWIG_fail;
20132 }
20133 resultobj = SWIG_From_int(static_cast< int >(result));
20134 {
20135 if (temp2)
20136 delete arg2;
20137 }
20138 return resultobj;
20139 fail:
20140 {
20141 if (temp2)
20142 delete arg2;
20143 }
20144 return NULL;
20145 }
20146
20147
20148 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20149 PyObject *resultobj = 0;
20150 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20151 wxString *arg2 = 0 ;
20152 wxString const &arg3_defvalue = wxPyEmptyString ;
20153 wxString *arg3 = (wxString *) &arg3_defvalue ;
20154 wxString result;
20155 void *argp1 = 0 ;
20156 int res1 = 0 ;
20157 bool temp2 = false ;
20158 bool temp3 = false ;
20159 PyObject * obj0 = 0 ;
20160 PyObject * obj1 = 0 ;
20161 PyObject * obj2 = 0 ;
20162 char * kwnames[] = {
20163 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20164 };
20165
20166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20168 if (!SWIG_IsOK(res1)) {
20169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20170 }
20171 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20172 {
20173 arg2 = wxString_in_helper(obj1);
20174 if (arg2 == NULL) SWIG_fail;
20175 temp2 = true;
20176 }
20177 if (obj2) {
20178 {
20179 arg3 = wxString_in_helper(obj2);
20180 if (arg3 == NULL) SWIG_fail;
20181 temp3 = true;
20182 }
20183 }
20184 {
20185 PyThreadState* __tstate = wxPyBeginAllowThreads();
20186 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
20187 wxPyEndAllowThreads(__tstate);
20188 if (PyErr_Occurred()) SWIG_fail;
20189 }
20190 {
20191 #if wxUSE_UNICODE
20192 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20193 #else
20194 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20195 #endif
20196 }
20197 {
20198 if (temp2)
20199 delete arg2;
20200 }
20201 {
20202 if (temp3)
20203 delete arg3;
20204 }
20205 return resultobj;
20206 fail:
20207 {
20208 if (temp2)
20209 delete arg2;
20210 }
20211 {
20212 if (temp3)
20213 delete arg3;
20214 }
20215 return NULL;
20216 }
20217
20218
20219 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20220 PyObject *resultobj = 0;
20221 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20222 wxString *arg2 = 0 ;
20223 long arg3 = (long) 0 ;
20224 long result;
20225 void *argp1 = 0 ;
20226 int res1 = 0 ;
20227 bool temp2 = false ;
20228 long val3 ;
20229 int ecode3 = 0 ;
20230 PyObject * obj0 = 0 ;
20231 PyObject * obj1 = 0 ;
20232 PyObject * obj2 = 0 ;
20233 char * kwnames[] = {
20234 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20235 };
20236
20237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20239 if (!SWIG_IsOK(res1)) {
20240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20241 }
20242 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20243 {
20244 arg2 = wxString_in_helper(obj1);
20245 if (arg2 == NULL) SWIG_fail;
20246 temp2 = true;
20247 }
20248 if (obj2) {
20249 ecode3 = SWIG_AsVal_long(obj2, &val3);
20250 if (!SWIG_IsOK(ecode3)) {
20251 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
20252 }
20253 arg3 = static_cast< long >(val3);
20254 }
20255 {
20256 PyThreadState* __tstate = wxPyBeginAllowThreads();
20257 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
20258 wxPyEndAllowThreads(__tstate);
20259 if (PyErr_Occurred()) SWIG_fail;
20260 }
20261 resultobj = SWIG_From_long(static_cast< long >(result));
20262 {
20263 if (temp2)
20264 delete arg2;
20265 }
20266 return resultobj;
20267 fail:
20268 {
20269 if (temp2)
20270 delete arg2;
20271 }
20272 return NULL;
20273 }
20274
20275
20276 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20277 PyObject *resultobj = 0;
20278 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20279 wxString *arg2 = 0 ;
20280 double arg3 = (double) 0.0 ;
20281 double result;
20282 void *argp1 = 0 ;
20283 int res1 = 0 ;
20284 bool temp2 = false ;
20285 double val3 ;
20286 int ecode3 = 0 ;
20287 PyObject * obj0 = 0 ;
20288 PyObject * obj1 = 0 ;
20289 PyObject * obj2 = 0 ;
20290 char * kwnames[] = {
20291 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20292 };
20293
20294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20296 if (!SWIG_IsOK(res1)) {
20297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20298 }
20299 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20300 {
20301 arg2 = wxString_in_helper(obj1);
20302 if (arg2 == NULL) SWIG_fail;
20303 temp2 = true;
20304 }
20305 if (obj2) {
20306 ecode3 = SWIG_AsVal_double(obj2, &val3);
20307 if (!SWIG_IsOK(ecode3)) {
20308 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
20309 }
20310 arg3 = static_cast< double >(val3);
20311 }
20312 {
20313 PyThreadState* __tstate = wxPyBeginAllowThreads();
20314 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
20315 wxPyEndAllowThreads(__tstate);
20316 if (PyErr_Occurred()) SWIG_fail;
20317 }
20318 resultobj = SWIG_From_double(static_cast< double >(result));
20319 {
20320 if (temp2)
20321 delete arg2;
20322 }
20323 return resultobj;
20324 fail:
20325 {
20326 if (temp2)
20327 delete arg2;
20328 }
20329 return NULL;
20330 }
20331
20332
20333 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20334 PyObject *resultobj = 0;
20335 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20336 wxString *arg2 = 0 ;
20337 bool arg3 = (bool) false ;
20338 bool result;
20339 void *argp1 = 0 ;
20340 int res1 = 0 ;
20341 bool temp2 = false ;
20342 bool val3 ;
20343 int ecode3 = 0 ;
20344 PyObject * obj0 = 0 ;
20345 PyObject * obj1 = 0 ;
20346 PyObject * obj2 = 0 ;
20347 char * kwnames[] = {
20348 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20349 };
20350
20351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20353 if (!SWIG_IsOK(res1)) {
20354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20355 }
20356 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20357 {
20358 arg2 = wxString_in_helper(obj1);
20359 if (arg2 == NULL) SWIG_fail;
20360 temp2 = true;
20361 }
20362 if (obj2) {
20363 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20364 if (!SWIG_IsOK(ecode3)) {
20365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
20366 }
20367 arg3 = static_cast< bool >(val3);
20368 }
20369 {
20370 PyThreadState* __tstate = wxPyBeginAllowThreads();
20371 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
20372 wxPyEndAllowThreads(__tstate);
20373 if (PyErr_Occurred()) SWIG_fail;
20374 }
20375 {
20376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20377 }
20378 {
20379 if (temp2)
20380 delete arg2;
20381 }
20382 return resultobj;
20383 fail:
20384 {
20385 if (temp2)
20386 delete arg2;
20387 }
20388 return NULL;
20389 }
20390
20391
20392 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20393 PyObject *resultobj = 0;
20394 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20395 wxString *arg2 = 0 ;
20396 wxString *arg3 = 0 ;
20397 bool result;
20398 void *argp1 = 0 ;
20399 int res1 = 0 ;
20400 bool temp2 = false ;
20401 bool temp3 = false ;
20402 PyObject * obj0 = 0 ;
20403 PyObject * obj1 = 0 ;
20404 PyObject * obj2 = 0 ;
20405 char * kwnames[] = {
20406 (char *) "self",(char *) "key",(char *) "value", NULL
20407 };
20408
20409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20411 if (!SWIG_IsOK(res1)) {
20412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20413 }
20414 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20415 {
20416 arg2 = wxString_in_helper(obj1);
20417 if (arg2 == NULL) SWIG_fail;
20418 temp2 = true;
20419 }
20420 {
20421 arg3 = wxString_in_helper(obj2);
20422 if (arg3 == NULL) SWIG_fail;
20423 temp3 = true;
20424 }
20425 {
20426 PyThreadState* __tstate = wxPyBeginAllowThreads();
20427 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
20428 wxPyEndAllowThreads(__tstate);
20429 if (PyErr_Occurred()) SWIG_fail;
20430 }
20431 {
20432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20433 }
20434 {
20435 if (temp2)
20436 delete arg2;
20437 }
20438 {
20439 if (temp3)
20440 delete arg3;
20441 }
20442 return resultobj;
20443 fail:
20444 {
20445 if (temp2)
20446 delete arg2;
20447 }
20448 {
20449 if (temp3)
20450 delete arg3;
20451 }
20452 return NULL;
20453 }
20454
20455
20456 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20457 PyObject *resultobj = 0;
20458 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20459 wxString *arg2 = 0 ;
20460 long arg3 ;
20461 bool result;
20462 void *argp1 = 0 ;
20463 int res1 = 0 ;
20464 bool temp2 = false ;
20465 long val3 ;
20466 int ecode3 = 0 ;
20467 PyObject * obj0 = 0 ;
20468 PyObject * obj1 = 0 ;
20469 PyObject * obj2 = 0 ;
20470 char * kwnames[] = {
20471 (char *) "self",(char *) "key",(char *) "value", NULL
20472 };
20473
20474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20476 if (!SWIG_IsOK(res1)) {
20477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20478 }
20479 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20480 {
20481 arg2 = wxString_in_helper(obj1);
20482 if (arg2 == NULL) SWIG_fail;
20483 temp2 = true;
20484 }
20485 ecode3 = SWIG_AsVal_long(obj2, &val3);
20486 if (!SWIG_IsOK(ecode3)) {
20487 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
20488 }
20489 arg3 = static_cast< long >(val3);
20490 {
20491 PyThreadState* __tstate = wxPyBeginAllowThreads();
20492 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20493 wxPyEndAllowThreads(__tstate);
20494 if (PyErr_Occurred()) SWIG_fail;
20495 }
20496 {
20497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20498 }
20499 {
20500 if (temp2)
20501 delete arg2;
20502 }
20503 return resultobj;
20504 fail:
20505 {
20506 if (temp2)
20507 delete arg2;
20508 }
20509 return NULL;
20510 }
20511
20512
20513 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20514 PyObject *resultobj = 0;
20515 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20516 wxString *arg2 = 0 ;
20517 double arg3 ;
20518 bool result;
20519 void *argp1 = 0 ;
20520 int res1 = 0 ;
20521 bool temp2 = false ;
20522 double val3 ;
20523 int ecode3 = 0 ;
20524 PyObject * obj0 = 0 ;
20525 PyObject * obj1 = 0 ;
20526 PyObject * obj2 = 0 ;
20527 char * kwnames[] = {
20528 (char *) "self",(char *) "key",(char *) "value", NULL
20529 };
20530
20531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20533 if (!SWIG_IsOK(res1)) {
20534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20535 }
20536 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20537 {
20538 arg2 = wxString_in_helper(obj1);
20539 if (arg2 == NULL) SWIG_fail;
20540 temp2 = true;
20541 }
20542 ecode3 = SWIG_AsVal_double(obj2, &val3);
20543 if (!SWIG_IsOK(ecode3)) {
20544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
20545 }
20546 arg3 = static_cast< double >(val3);
20547 {
20548 PyThreadState* __tstate = wxPyBeginAllowThreads();
20549 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20550 wxPyEndAllowThreads(__tstate);
20551 if (PyErr_Occurred()) SWIG_fail;
20552 }
20553 {
20554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20555 }
20556 {
20557 if (temp2)
20558 delete arg2;
20559 }
20560 return resultobj;
20561 fail:
20562 {
20563 if (temp2)
20564 delete arg2;
20565 }
20566 return NULL;
20567 }
20568
20569
20570 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20571 PyObject *resultobj = 0;
20572 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20573 wxString *arg2 = 0 ;
20574 bool arg3 ;
20575 bool result;
20576 void *argp1 = 0 ;
20577 int res1 = 0 ;
20578 bool temp2 = false ;
20579 bool val3 ;
20580 int ecode3 = 0 ;
20581 PyObject * obj0 = 0 ;
20582 PyObject * obj1 = 0 ;
20583 PyObject * obj2 = 0 ;
20584 char * kwnames[] = {
20585 (char *) "self",(char *) "key",(char *) "value", NULL
20586 };
20587
20588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20590 if (!SWIG_IsOK(res1)) {
20591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20592 }
20593 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20594 {
20595 arg2 = wxString_in_helper(obj1);
20596 if (arg2 == NULL) SWIG_fail;
20597 temp2 = true;
20598 }
20599 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20600 if (!SWIG_IsOK(ecode3)) {
20601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
20602 }
20603 arg3 = static_cast< bool >(val3);
20604 {
20605 PyThreadState* __tstate = wxPyBeginAllowThreads();
20606 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20607 wxPyEndAllowThreads(__tstate);
20608 if (PyErr_Occurred()) SWIG_fail;
20609 }
20610 {
20611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20612 }
20613 {
20614 if (temp2)
20615 delete arg2;
20616 }
20617 return resultobj;
20618 fail:
20619 {
20620 if (temp2)
20621 delete arg2;
20622 }
20623 return NULL;
20624 }
20625
20626
20627 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20628 PyObject *resultobj = 0;
20629 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20630 bool arg2 = (bool) false ;
20631 bool result;
20632 void *argp1 = 0 ;
20633 int res1 = 0 ;
20634 bool val2 ;
20635 int ecode2 = 0 ;
20636 PyObject * obj0 = 0 ;
20637 PyObject * obj1 = 0 ;
20638 char * kwnames[] = {
20639 (char *) "self",(char *) "currentOnly", NULL
20640 };
20641
20642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
20643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20644 if (!SWIG_IsOK(res1)) {
20645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20646 }
20647 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20648 if (obj1) {
20649 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20650 if (!SWIG_IsOK(ecode2)) {
20651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
20652 }
20653 arg2 = static_cast< bool >(val2);
20654 }
20655 {
20656 PyThreadState* __tstate = wxPyBeginAllowThreads();
20657 result = (bool)(arg1)->Flush(arg2);
20658 wxPyEndAllowThreads(__tstate);
20659 if (PyErr_Occurred()) SWIG_fail;
20660 }
20661 {
20662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20663 }
20664 return resultobj;
20665 fail:
20666 return NULL;
20667 }
20668
20669
20670 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20671 PyObject *resultobj = 0;
20672 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20673 wxString *arg2 = 0 ;
20674 wxString *arg3 = 0 ;
20675 bool result;
20676 void *argp1 = 0 ;
20677 int res1 = 0 ;
20678 bool temp2 = false ;
20679 bool temp3 = false ;
20680 PyObject * obj0 = 0 ;
20681 PyObject * obj1 = 0 ;
20682 PyObject * obj2 = 0 ;
20683 char * kwnames[] = {
20684 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20685 };
20686
20687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20689 if (!SWIG_IsOK(res1)) {
20690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20691 }
20692 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20693 {
20694 arg2 = wxString_in_helper(obj1);
20695 if (arg2 == NULL) SWIG_fail;
20696 temp2 = true;
20697 }
20698 {
20699 arg3 = wxString_in_helper(obj2);
20700 if (arg3 == NULL) SWIG_fail;
20701 temp3 = true;
20702 }
20703 {
20704 PyThreadState* __tstate = wxPyBeginAllowThreads();
20705 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
20706 wxPyEndAllowThreads(__tstate);
20707 if (PyErr_Occurred()) SWIG_fail;
20708 }
20709 {
20710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20711 }
20712 {
20713 if (temp2)
20714 delete arg2;
20715 }
20716 {
20717 if (temp3)
20718 delete arg3;
20719 }
20720 return resultobj;
20721 fail:
20722 {
20723 if (temp2)
20724 delete arg2;
20725 }
20726 {
20727 if (temp3)
20728 delete arg3;
20729 }
20730 return NULL;
20731 }
20732
20733
20734 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20735 PyObject *resultobj = 0;
20736 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20737 wxString *arg2 = 0 ;
20738 wxString *arg3 = 0 ;
20739 bool result;
20740 void *argp1 = 0 ;
20741 int res1 = 0 ;
20742 bool temp2 = false ;
20743 bool temp3 = false ;
20744 PyObject * obj0 = 0 ;
20745 PyObject * obj1 = 0 ;
20746 PyObject * obj2 = 0 ;
20747 char * kwnames[] = {
20748 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20749 };
20750
20751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20753 if (!SWIG_IsOK(res1)) {
20754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20755 }
20756 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20757 {
20758 arg2 = wxString_in_helper(obj1);
20759 if (arg2 == NULL) SWIG_fail;
20760 temp2 = true;
20761 }
20762 {
20763 arg3 = wxString_in_helper(obj2);
20764 if (arg3 == NULL) SWIG_fail;
20765 temp3 = true;
20766 }
20767 {
20768 PyThreadState* __tstate = wxPyBeginAllowThreads();
20769 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
20770 wxPyEndAllowThreads(__tstate);
20771 if (PyErr_Occurred()) SWIG_fail;
20772 }
20773 {
20774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20775 }
20776 {
20777 if (temp2)
20778 delete arg2;
20779 }
20780 {
20781 if (temp3)
20782 delete arg3;
20783 }
20784 return resultobj;
20785 fail:
20786 {
20787 if (temp2)
20788 delete arg2;
20789 }
20790 {
20791 if (temp3)
20792 delete arg3;
20793 }
20794 return NULL;
20795 }
20796
20797
20798 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20799 PyObject *resultobj = 0;
20800 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20801 wxString *arg2 = 0 ;
20802 bool arg3 = (bool) true ;
20803 bool result;
20804 void *argp1 = 0 ;
20805 int res1 = 0 ;
20806 bool temp2 = false ;
20807 bool val3 ;
20808 int ecode3 = 0 ;
20809 PyObject * obj0 = 0 ;
20810 PyObject * obj1 = 0 ;
20811 PyObject * obj2 = 0 ;
20812 char * kwnames[] = {
20813 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
20814 };
20815
20816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20818 if (!SWIG_IsOK(res1)) {
20819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20820 }
20821 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20822 {
20823 arg2 = wxString_in_helper(obj1);
20824 if (arg2 == NULL) SWIG_fail;
20825 temp2 = true;
20826 }
20827 if (obj2) {
20828 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20829 if (!SWIG_IsOK(ecode3)) {
20830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
20831 }
20832 arg3 = static_cast< bool >(val3);
20833 }
20834 {
20835 PyThreadState* __tstate = wxPyBeginAllowThreads();
20836 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
20837 wxPyEndAllowThreads(__tstate);
20838 if (PyErr_Occurred()) SWIG_fail;
20839 }
20840 {
20841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20842 }
20843 {
20844 if (temp2)
20845 delete arg2;
20846 }
20847 return resultobj;
20848 fail:
20849 {
20850 if (temp2)
20851 delete arg2;
20852 }
20853 return NULL;
20854 }
20855
20856
20857 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20858 PyObject *resultobj = 0;
20859 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20860 wxString *arg2 = 0 ;
20861 bool result;
20862 void *argp1 = 0 ;
20863 int res1 = 0 ;
20864 bool temp2 = false ;
20865 PyObject * obj0 = 0 ;
20866 PyObject * obj1 = 0 ;
20867 char * kwnames[] = {
20868 (char *) "self",(char *) "key", NULL
20869 };
20870
20871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20873 if (!SWIG_IsOK(res1)) {
20874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20875 }
20876 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20877 {
20878 arg2 = wxString_in_helper(obj1);
20879 if (arg2 == NULL) SWIG_fail;
20880 temp2 = true;
20881 }
20882 {
20883 PyThreadState* __tstate = wxPyBeginAllowThreads();
20884 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
20885 wxPyEndAllowThreads(__tstate);
20886 if (PyErr_Occurred()) SWIG_fail;
20887 }
20888 {
20889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20890 }
20891 {
20892 if (temp2)
20893 delete arg2;
20894 }
20895 return resultobj;
20896 fail:
20897 {
20898 if (temp2)
20899 delete arg2;
20900 }
20901 return NULL;
20902 }
20903
20904
20905 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20906 PyObject *resultobj = 0;
20907 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20908 bool result;
20909 void *argp1 = 0 ;
20910 int res1 = 0 ;
20911 PyObject *swig_obj[1] ;
20912
20913 if (!args) SWIG_fail;
20914 swig_obj[0] = args;
20915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20916 if (!SWIG_IsOK(res1)) {
20917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20918 }
20919 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20920 {
20921 PyThreadState* __tstate = wxPyBeginAllowThreads();
20922 result = (bool)(arg1)->DeleteAll();
20923 wxPyEndAllowThreads(__tstate);
20924 if (PyErr_Occurred()) SWIG_fail;
20925 }
20926 {
20927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20928 }
20929 return resultobj;
20930 fail:
20931 return NULL;
20932 }
20933
20934
20935 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20936 PyObject *resultobj = 0;
20937 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20938 bool arg2 = (bool) true ;
20939 void *argp1 = 0 ;
20940 int res1 = 0 ;
20941 bool val2 ;
20942 int ecode2 = 0 ;
20943 PyObject * obj0 = 0 ;
20944 PyObject * obj1 = 0 ;
20945 char * kwnames[] = {
20946 (char *) "self",(char *) "doIt", NULL
20947 };
20948
20949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
20950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20951 if (!SWIG_IsOK(res1)) {
20952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20953 }
20954 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20955 if (obj1) {
20956 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20957 if (!SWIG_IsOK(ecode2)) {
20958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
20959 }
20960 arg2 = static_cast< bool >(val2);
20961 }
20962 {
20963 PyThreadState* __tstate = wxPyBeginAllowThreads();
20964 (arg1)->SetExpandEnvVars(arg2);
20965 wxPyEndAllowThreads(__tstate);
20966 if (PyErr_Occurred()) SWIG_fail;
20967 }
20968 resultobj = SWIG_Py_Void();
20969 return resultobj;
20970 fail:
20971 return NULL;
20972 }
20973
20974
20975 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20976 PyObject *resultobj = 0;
20977 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20978 bool result;
20979 void *argp1 = 0 ;
20980 int res1 = 0 ;
20981 PyObject *swig_obj[1] ;
20982
20983 if (!args) SWIG_fail;
20984 swig_obj[0] = args;
20985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20986 if (!SWIG_IsOK(res1)) {
20987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20988 }
20989 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20990 {
20991 PyThreadState* __tstate = wxPyBeginAllowThreads();
20992 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
20993 wxPyEndAllowThreads(__tstate);
20994 if (PyErr_Occurred()) SWIG_fail;
20995 }
20996 {
20997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20998 }
20999 return resultobj;
21000 fail:
21001 return NULL;
21002 }
21003
21004
21005 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21006 PyObject *resultobj = 0;
21007 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21008 bool arg2 = (bool) true ;
21009 void *argp1 = 0 ;
21010 int res1 = 0 ;
21011 bool val2 ;
21012 int ecode2 = 0 ;
21013 PyObject * obj0 = 0 ;
21014 PyObject * obj1 = 0 ;
21015 char * kwnames[] = {
21016 (char *) "self",(char *) "doIt", NULL
21017 };
21018
21019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
21020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21021 if (!SWIG_IsOK(res1)) {
21022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21023 }
21024 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21025 if (obj1) {
21026 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21027 if (!SWIG_IsOK(ecode2)) {
21028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
21029 }
21030 arg2 = static_cast< bool >(val2);
21031 }
21032 {
21033 PyThreadState* __tstate = wxPyBeginAllowThreads();
21034 (arg1)->SetRecordDefaults(arg2);
21035 wxPyEndAllowThreads(__tstate);
21036 if (PyErr_Occurred()) SWIG_fail;
21037 }
21038 resultobj = SWIG_Py_Void();
21039 return resultobj;
21040 fail:
21041 return NULL;
21042 }
21043
21044
21045 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21046 PyObject *resultobj = 0;
21047 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21048 bool result;
21049 void *argp1 = 0 ;
21050 int res1 = 0 ;
21051 PyObject *swig_obj[1] ;
21052
21053 if (!args) SWIG_fail;
21054 swig_obj[0] = args;
21055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21056 if (!SWIG_IsOK(res1)) {
21057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21058 }
21059 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21060 {
21061 PyThreadState* __tstate = wxPyBeginAllowThreads();
21062 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
21063 wxPyEndAllowThreads(__tstate);
21064 if (PyErr_Occurred()) SWIG_fail;
21065 }
21066 {
21067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21068 }
21069 return resultobj;
21070 fail:
21071 return NULL;
21072 }
21073
21074
21075 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21076 PyObject *resultobj = 0;
21077 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21078 wxString *arg2 = 0 ;
21079 wxString result;
21080 void *argp1 = 0 ;
21081 int res1 = 0 ;
21082 bool temp2 = false ;
21083 PyObject * obj0 = 0 ;
21084 PyObject * obj1 = 0 ;
21085 char * kwnames[] = {
21086 (char *) "self",(char *) "str", NULL
21087 };
21088
21089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21091 if (!SWIG_IsOK(res1)) {
21092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21093 }
21094 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21095 {
21096 arg2 = wxString_in_helper(obj1);
21097 if (arg2 == NULL) SWIG_fail;
21098 temp2 = true;
21099 }
21100 {
21101 PyThreadState* __tstate = wxPyBeginAllowThreads();
21102 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
21103 wxPyEndAllowThreads(__tstate);
21104 if (PyErr_Occurred()) SWIG_fail;
21105 }
21106 {
21107 #if wxUSE_UNICODE
21108 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21109 #else
21110 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21111 #endif
21112 }
21113 {
21114 if (temp2)
21115 delete arg2;
21116 }
21117 return resultobj;
21118 fail:
21119 {
21120 if (temp2)
21121 delete arg2;
21122 }
21123 return NULL;
21124 }
21125
21126
21127 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21128 PyObject *resultobj = 0;
21129 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21130 wxString result;
21131 void *argp1 = 0 ;
21132 int res1 = 0 ;
21133 PyObject *swig_obj[1] ;
21134
21135 if (!args) SWIG_fail;
21136 swig_obj[0] = args;
21137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21138 if (!SWIG_IsOK(res1)) {
21139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21140 }
21141 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21142 {
21143 PyThreadState* __tstate = wxPyBeginAllowThreads();
21144 result = ((wxConfigBase const *)arg1)->GetAppName();
21145 wxPyEndAllowThreads(__tstate);
21146 if (PyErr_Occurred()) SWIG_fail;
21147 }
21148 {
21149 #if wxUSE_UNICODE
21150 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21151 #else
21152 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21153 #endif
21154 }
21155 return resultobj;
21156 fail:
21157 return NULL;
21158 }
21159
21160
21161 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21162 PyObject *resultobj = 0;
21163 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21164 wxString result;
21165 void *argp1 = 0 ;
21166 int res1 = 0 ;
21167 PyObject *swig_obj[1] ;
21168
21169 if (!args) SWIG_fail;
21170 swig_obj[0] = args;
21171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21172 if (!SWIG_IsOK(res1)) {
21173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21174 }
21175 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21176 {
21177 PyThreadState* __tstate = wxPyBeginAllowThreads();
21178 result = ((wxConfigBase const *)arg1)->GetVendorName();
21179 wxPyEndAllowThreads(__tstate);
21180 if (PyErr_Occurred()) SWIG_fail;
21181 }
21182 {
21183 #if wxUSE_UNICODE
21184 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21185 #else
21186 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21187 #endif
21188 }
21189 return resultobj;
21190 fail:
21191 return NULL;
21192 }
21193
21194
21195 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21196 PyObject *resultobj = 0;
21197 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21198 wxString *arg2 = 0 ;
21199 void *argp1 = 0 ;
21200 int res1 = 0 ;
21201 bool temp2 = false ;
21202 PyObject * obj0 = 0 ;
21203 PyObject * obj1 = 0 ;
21204 char * kwnames[] = {
21205 (char *) "self",(char *) "appName", NULL
21206 };
21207
21208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
21209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21210 if (!SWIG_IsOK(res1)) {
21211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21212 }
21213 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21214 {
21215 arg2 = wxString_in_helper(obj1);
21216 if (arg2 == NULL) SWIG_fail;
21217 temp2 = true;
21218 }
21219 {
21220 PyThreadState* __tstate = wxPyBeginAllowThreads();
21221 (arg1)->SetAppName((wxString const &)*arg2);
21222 wxPyEndAllowThreads(__tstate);
21223 if (PyErr_Occurred()) SWIG_fail;
21224 }
21225 resultobj = SWIG_Py_Void();
21226 {
21227 if (temp2)
21228 delete arg2;
21229 }
21230 return resultobj;
21231 fail:
21232 {
21233 if (temp2)
21234 delete arg2;
21235 }
21236 return NULL;
21237 }
21238
21239
21240 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21241 PyObject *resultobj = 0;
21242 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21243 wxString *arg2 = 0 ;
21244 void *argp1 = 0 ;
21245 int res1 = 0 ;
21246 bool temp2 = false ;
21247 PyObject * obj0 = 0 ;
21248 PyObject * obj1 = 0 ;
21249 char * kwnames[] = {
21250 (char *) "self",(char *) "vendorName", NULL
21251 };
21252
21253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
21254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21255 if (!SWIG_IsOK(res1)) {
21256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21257 }
21258 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21259 {
21260 arg2 = wxString_in_helper(obj1);
21261 if (arg2 == NULL) SWIG_fail;
21262 temp2 = true;
21263 }
21264 {
21265 PyThreadState* __tstate = wxPyBeginAllowThreads();
21266 (arg1)->SetVendorName((wxString const &)*arg2);
21267 wxPyEndAllowThreads(__tstate);
21268 if (PyErr_Occurred()) SWIG_fail;
21269 }
21270 resultobj = SWIG_Py_Void();
21271 {
21272 if (temp2)
21273 delete arg2;
21274 }
21275 return resultobj;
21276 fail:
21277 {
21278 if (temp2)
21279 delete arg2;
21280 }
21281 return NULL;
21282 }
21283
21284
21285 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21286 PyObject *resultobj = 0;
21287 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21288 long arg2 ;
21289 void *argp1 = 0 ;
21290 int res1 = 0 ;
21291 long val2 ;
21292 int ecode2 = 0 ;
21293 PyObject * obj0 = 0 ;
21294 PyObject * obj1 = 0 ;
21295 char * kwnames[] = {
21296 (char *) "self",(char *) "style", NULL
21297 };
21298
21299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
21300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21301 if (!SWIG_IsOK(res1)) {
21302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21303 }
21304 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21305 ecode2 = SWIG_AsVal_long(obj1, &val2);
21306 if (!SWIG_IsOK(ecode2)) {
21307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
21308 }
21309 arg2 = static_cast< long >(val2);
21310 {
21311 PyThreadState* __tstate = wxPyBeginAllowThreads();
21312 (arg1)->SetStyle(arg2);
21313 wxPyEndAllowThreads(__tstate);
21314 if (PyErr_Occurred()) SWIG_fail;
21315 }
21316 resultobj = SWIG_Py_Void();
21317 return resultobj;
21318 fail:
21319 return NULL;
21320 }
21321
21322
21323 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21324 PyObject *resultobj = 0;
21325 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21326 long result;
21327 void *argp1 = 0 ;
21328 int res1 = 0 ;
21329 PyObject *swig_obj[1] ;
21330
21331 if (!args) SWIG_fail;
21332 swig_obj[0] = args;
21333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21334 if (!SWIG_IsOK(res1)) {
21335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21336 }
21337 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21338 {
21339 PyThreadState* __tstate = wxPyBeginAllowThreads();
21340 result = (long)((wxConfigBase const *)arg1)->GetStyle();
21341 wxPyEndAllowThreads(__tstate);
21342 if (PyErr_Occurred()) SWIG_fail;
21343 }
21344 resultobj = SWIG_From_long(static_cast< long >(result));
21345 return resultobj;
21346 fail:
21347 return NULL;
21348 }
21349
21350
21351 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21352 PyObject *obj;
21353 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21354 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
21355 return SWIG_Py_Void();
21356 }
21357
21358 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21359 PyObject *resultobj = 0;
21360 wxString const &arg1_defvalue = wxPyEmptyString ;
21361 wxString *arg1 = (wxString *) &arg1_defvalue ;
21362 wxString const &arg2_defvalue = wxPyEmptyString ;
21363 wxString *arg2 = (wxString *) &arg2_defvalue ;
21364 wxString const &arg3_defvalue = wxPyEmptyString ;
21365 wxString *arg3 = (wxString *) &arg3_defvalue ;
21366 wxString const &arg4_defvalue = wxPyEmptyString ;
21367 wxString *arg4 = (wxString *) &arg4_defvalue ;
21368 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21369 wxConfig *result = 0 ;
21370 bool temp1 = false ;
21371 bool temp2 = false ;
21372 bool temp3 = false ;
21373 bool temp4 = false ;
21374 long val5 ;
21375 int ecode5 = 0 ;
21376 PyObject * obj0 = 0 ;
21377 PyObject * obj1 = 0 ;
21378 PyObject * obj2 = 0 ;
21379 PyObject * obj3 = 0 ;
21380 PyObject * obj4 = 0 ;
21381 char * kwnames[] = {
21382 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21383 };
21384
21385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21386 if (obj0) {
21387 {
21388 arg1 = wxString_in_helper(obj0);
21389 if (arg1 == NULL) SWIG_fail;
21390 temp1 = true;
21391 }
21392 }
21393 if (obj1) {
21394 {
21395 arg2 = wxString_in_helper(obj1);
21396 if (arg2 == NULL) SWIG_fail;
21397 temp2 = true;
21398 }
21399 }
21400 if (obj2) {
21401 {
21402 arg3 = wxString_in_helper(obj2);
21403 if (arg3 == NULL) SWIG_fail;
21404 temp3 = true;
21405 }
21406 }
21407 if (obj3) {
21408 {
21409 arg4 = wxString_in_helper(obj3);
21410 if (arg4 == NULL) SWIG_fail;
21411 temp4 = true;
21412 }
21413 }
21414 if (obj4) {
21415 ecode5 = SWIG_AsVal_long(obj4, &val5);
21416 if (!SWIG_IsOK(ecode5)) {
21417 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
21418 }
21419 arg5 = static_cast< long >(val5);
21420 }
21421 {
21422 PyThreadState* __tstate = wxPyBeginAllowThreads();
21423 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21424 wxPyEndAllowThreads(__tstate);
21425 if (PyErr_Occurred()) SWIG_fail;
21426 }
21427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
21428 {
21429 if (temp1)
21430 delete arg1;
21431 }
21432 {
21433 if (temp2)
21434 delete arg2;
21435 }
21436 {
21437 if (temp3)
21438 delete arg3;
21439 }
21440 {
21441 if (temp4)
21442 delete arg4;
21443 }
21444 return resultobj;
21445 fail:
21446 {
21447 if (temp1)
21448 delete arg1;
21449 }
21450 {
21451 if (temp2)
21452 delete arg2;
21453 }
21454 {
21455 if (temp3)
21456 delete arg3;
21457 }
21458 {
21459 if (temp4)
21460 delete arg4;
21461 }
21462 return NULL;
21463 }
21464
21465
21466 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21467 PyObject *resultobj = 0;
21468 wxConfig *arg1 = (wxConfig *) 0 ;
21469 void *argp1 = 0 ;
21470 int res1 = 0 ;
21471 PyObject *swig_obj[1] ;
21472
21473 if (!args) SWIG_fail;
21474 swig_obj[0] = args;
21475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
21476 if (!SWIG_IsOK(res1)) {
21477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
21478 }
21479 arg1 = reinterpret_cast< wxConfig * >(argp1);
21480 {
21481 PyThreadState* __tstate = wxPyBeginAllowThreads();
21482 delete arg1;
21483
21484 wxPyEndAllowThreads(__tstate);
21485 if (PyErr_Occurred()) SWIG_fail;
21486 }
21487 resultobj = SWIG_Py_Void();
21488 return resultobj;
21489 fail:
21490 return NULL;
21491 }
21492
21493
21494 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21495 PyObject *obj;
21496 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21497 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
21498 return SWIG_Py_Void();
21499 }
21500
21501 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21502 return SWIG_Python_InitShadowInstance(args);
21503 }
21504
21505 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21506 PyObject *resultobj = 0;
21507 wxString const &arg1_defvalue = wxPyEmptyString ;
21508 wxString *arg1 = (wxString *) &arg1_defvalue ;
21509 wxString const &arg2_defvalue = wxPyEmptyString ;
21510 wxString *arg2 = (wxString *) &arg2_defvalue ;
21511 wxString const &arg3_defvalue = wxPyEmptyString ;
21512 wxString *arg3 = (wxString *) &arg3_defvalue ;
21513 wxString const &arg4_defvalue = wxPyEmptyString ;
21514 wxString *arg4 = (wxString *) &arg4_defvalue ;
21515 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21516 wxFileConfig *result = 0 ;
21517 bool temp1 = false ;
21518 bool temp2 = false ;
21519 bool temp3 = false ;
21520 bool temp4 = false ;
21521 long val5 ;
21522 int ecode5 = 0 ;
21523 PyObject * obj0 = 0 ;
21524 PyObject * obj1 = 0 ;
21525 PyObject * obj2 = 0 ;
21526 PyObject * obj3 = 0 ;
21527 PyObject * obj4 = 0 ;
21528 char * kwnames[] = {
21529 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21530 };
21531
21532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21533 if (obj0) {
21534 {
21535 arg1 = wxString_in_helper(obj0);
21536 if (arg1 == NULL) SWIG_fail;
21537 temp1 = true;
21538 }
21539 }
21540 if (obj1) {
21541 {
21542 arg2 = wxString_in_helper(obj1);
21543 if (arg2 == NULL) SWIG_fail;
21544 temp2 = true;
21545 }
21546 }
21547 if (obj2) {
21548 {
21549 arg3 = wxString_in_helper(obj2);
21550 if (arg3 == NULL) SWIG_fail;
21551 temp3 = true;
21552 }
21553 }
21554 if (obj3) {
21555 {
21556 arg4 = wxString_in_helper(obj3);
21557 if (arg4 == NULL) SWIG_fail;
21558 temp4 = true;
21559 }
21560 }
21561 if (obj4) {
21562 ecode5 = SWIG_AsVal_long(obj4, &val5);
21563 if (!SWIG_IsOK(ecode5)) {
21564 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
21565 }
21566 arg5 = static_cast< long >(val5);
21567 }
21568 {
21569 PyThreadState* __tstate = wxPyBeginAllowThreads();
21570 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21571 wxPyEndAllowThreads(__tstate);
21572 if (PyErr_Occurred()) SWIG_fail;
21573 }
21574 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
21575 {
21576 if (temp1)
21577 delete arg1;
21578 }
21579 {
21580 if (temp2)
21581 delete arg2;
21582 }
21583 {
21584 if (temp3)
21585 delete arg3;
21586 }
21587 {
21588 if (temp4)
21589 delete arg4;
21590 }
21591 return resultobj;
21592 fail:
21593 {
21594 if (temp1)
21595 delete arg1;
21596 }
21597 {
21598 if (temp2)
21599 delete arg2;
21600 }
21601 {
21602 if (temp3)
21603 delete arg3;
21604 }
21605 {
21606 if (temp4)
21607 delete arg4;
21608 }
21609 return NULL;
21610 }
21611
21612
21613 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21614 PyObject *resultobj = 0;
21615 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
21616 void *argp1 = 0 ;
21617 int res1 = 0 ;
21618 PyObject *swig_obj[1] ;
21619
21620 if (!args) SWIG_fail;
21621 swig_obj[0] = args;
21622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
21623 if (!SWIG_IsOK(res1)) {
21624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
21625 }
21626 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
21627 {
21628 PyThreadState* __tstate = wxPyBeginAllowThreads();
21629 delete arg1;
21630
21631 wxPyEndAllowThreads(__tstate);
21632 if (PyErr_Occurred()) SWIG_fail;
21633 }
21634 resultobj = SWIG_Py_Void();
21635 return resultobj;
21636 fail:
21637 return NULL;
21638 }
21639
21640
21641 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21642 PyObject *obj;
21643 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21644 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
21645 return SWIG_Py_Void();
21646 }
21647
21648 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21649 return SWIG_Python_InitShadowInstance(args);
21650 }
21651
21652 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21653 PyObject *resultobj = 0;
21654 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21655 wxString *arg2 = 0 ;
21656 wxConfigPathChanger *result = 0 ;
21657 void *argp1 = 0 ;
21658 int res1 = 0 ;
21659 bool temp2 = false ;
21660 PyObject * obj0 = 0 ;
21661 PyObject * obj1 = 0 ;
21662 char * kwnames[] = {
21663 (char *) "config",(char *) "entry", NULL
21664 };
21665
21666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
21667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21668 if (!SWIG_IsOK(res1)) {
21669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21670 }
21671 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21672 {
21673 arg2 = wxString_in_helper(obj1);
21674 if (arg2 == NULL) SWIG_fail;
21675 temp2 = true;
21676 }
21677 {
21678 PyThreadState* __tstate = wxPyBeginAllowThreads();
21679 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
21680 wxPyEndAllowThreads(__tstate);
21681 if (PyErr_Occurred()) SWIG_fail;
21682 }
21683 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
21684 {
21685 if (temp2)
21686 delete arg2;
21687 }
21688 return resultobj;
21689 fail:
21690 {
21691 if (temp2)
21692 delete arg2;
21693 }
21694 return NULL;
21695 }
21696
21697
21698 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21699 PyObject *resultobj = 0;
21700 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21701 void *argp1 = 0 ;
21702 int res1 = 0 ;
21703 PyObject *swig_obj[1] ;
21704
21705 if (!args) SWIG_fail;
21706 swig_obj[0] = args;
21707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
21708 if (!SWIG_IsOK(res1)) {
21709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
21710 }
21711 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21712 {
21713 PyThreadState* __tstate = wxPyBeginAllowThreads();
21714 delete arg1;
21715
21716 wxPyEndAllowThreads(__tstate);
21717 if (PyErr_Occurred()) SWIG_fail;
21718 }
21719 resultobj = SWIG_Py_Void();
21720 return resultobj;
21721 fail:
21722 return NULL;
21723 }
21724
21725
21726 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21727 PyObject *resultobj = 0;
21728 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21729 wxString *result = 0 ;
21730 void *argp1 = 0 ;
21731 int res1 = 0 ;
21732 PyObject *swig_obj[1] ;
21733
21734 if (!args) SWIG_fail;
21735 swig_obj[0] = args;
21736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
21737 if (!SWIG_IsOK(res1)) {
21738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
21739 }
21740 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21741 {
21742 PyThreadState* __tstate = wxPyBeginAllowThreads();
21743 {
21744 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
21745 result = (wxString *) &_result_ref;
21746 }
21747 wxPyEndAllowThreads(__tstate);
21748 if (PyErr_Occurred()) SWIG_fail;
21749 }
21750 {
21751 #if wxUSE_UNICODE
21752 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21753 #else
21754 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21755 #endif
21756 }
21757 return resultobj;
21758 fail:
21759 return NULL;
21760 }
21761
21762
21763 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21764 PyObject *obj;
21765 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21766 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
21767 return SWIG_Py_Void();
21768 }
21769
21770 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21771 return SWIG_Python_InitShadowInstance(args);
21772 }
21773
21774 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21775 PyObject *resultobj = 0;
21776 wxString *arg1 = 0 ;
21777 wxString result;
21778 bool temp1 = false ;
21779 PyObject * obj0 = 0 ;
21780 char * kwnames[] = {
21781 (char *) "sz", NULL
21782 };
21783
21784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
21785 {
21786 arg1 = wxString_in_helper(obj0);
21787 if (arg1 == NULL) SWIG_fail;
21788 temp1 = true;
21789 }
21790 {
21791 PyThreadState* __tstate = wxPyBeginAllowThreads();
21792 result = wxExpandEnvVars((wxString const &)*arg1);
21793 wxPyEndAllowThreads(__tstate);
21794 if (PyErr_Occurred()) SWIG_fail;
21795 }
21796 {
21797 #if wxUSE_UNICODE
21798 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21799 #else
21800 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21801 #endif
21802 }
21803 {
21804 if (temp1)
21805 delete arg1;
21806 }
21807 return resultobj;
21808 fail:
21809 {
21810 if (temp1)
21811 delete arg1;
21812 }
21813 return NULL;
21814 }
21815
21816
21817 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
21818 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
21819 return 1;
21820 }
21821
21822
21823 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
21824 PyObject *pyobj = 0;
21825
21826 {
21827 #if wxUSE_UNICODE
21828 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21829 #else
21830 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21831 #endif
21832 }
21833 return pyobj;
21834 }
21835
21836
21837 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
21838 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
21839 return 1;
21840 }
21841
21842
21843 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
21844 PyObject *pyobj = 0;
21845
21846 {
21847 #if wxUSE_UNICODE
21848 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21849 #else
21850 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21851 #endif
21852 }
21853 return pyobj;
21854 }
21855
21856
21857 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21858 PyObject *resultobj = 0;
21859 wxDateTime::Country arg1 ;
21860 int val1 ;
21861 int ecode1 = 0 ;
21862 PyObject * obj0 = 0 ;
21863 char * kwnames[] = {
21864 (char *) "country", NULL
21865 };
21866
21867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
21868 ecode1 = SWIG_AsVal_int(obj0, &val1);
21869 if (!SWIG_IsOK(ecode1)) {
21870 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21871 }
21872 arg1 = static_cast< wxDateTime::Country >(val1);
21873 {
21874 PyThreadState* __tstate = wxPyBeginAllowThreads();
21875 wxDateTime::SetCountry(arg1);
21876 wxPyEndAllowThreads(__tstate);
21877 if (PyErr_Occurred()) SWIG_fail;
21878 }
21879 resultobj = SWIG_Py_Void();
21880 return resultobj;
21881 fail:
21882 return NULL;
21883 }
21884
21885
21886 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21887 PyObject *resultobj = 0;
21888 wxDateTime::Country result;
21889
21890 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
21891 {
21892 PyThreadState* __tstate = wxPyBeginAllowThreads();
21893 result = (wxDateTime::Country)wxDateTime::GetCountry();
21894 wxPyEndAllowThreads(__tstate);
21895 if (PyErr_Occurred()) SWIG_fail;
21896 }
21897 resultobj = SWIG_From_int(static_cast< int >(result));
21898 return resultobj;
21899 fail:
21900 return NULL;
21901 }
21902
21903
21904 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21905 PyObject *resultobj = 0;
21906 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
21907 bool result;
21908 int val1 ;
21909 int ecode1 = 0 ;
21910 PyObject * obj0 = 0 ;
21911 char * kwnames[] = {
21912 (char *) "country", NULL
21913 };
21914
21915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
21916 if (obj0) {
21917 ecode1 = SWIG_AsVal_int(obj0, &val1);
21918 if (!SWIG_IsOK(ecode1)) {
21919 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21920 }
21921 arg1 = static_cast< wxDateTime::Country >(val1);
21922 }
21923 {
21924 PyThreadState* __tstate = wxPyBeginAllowThreads();
21925 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
21926 wxPyEndAllowThreads(__tstate);
21927 if (PyErr_Occurred()) SWIG_fail;
21928 }
21929 {
21930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21931 }
21932 return resultobj;
21933 fail:
21934 return NULL;
21935 }
21936
21937
21938 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21939 PyObject *resultobj = 0;
21940 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21941 int result;
21942 int val1 ;
21943 int ecode1 = 0 ;
21944 PyObject * obj0 = 0 ;
21945 char * kwnames[] = {
21946 (char *) "cal", NULL
21947 };
21948
21949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
21950 if (obj0) {
21951 ecode1 = SWIG_AsVal_int(obj0, &val1);
21952 if (!SWIG_IsOK(ecode1)) {
21953 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21954 }
21955 arg1 = static_cast< wxDateTime::Calendar >(val1);
21956 }
21957 {
21958 PyThreadState* __tstate = wxPyBeginAllowThreads();
21959 result = (int)wxDateTime::GetCurrentYear(arg1);
21960 wxPyEndAllowThreads(__tstate);
21961 if (PyErr_Occurred()) SWIG_fail;
21962 }
21963 resultobj = SWIG_From_int(static_cast< int >(result));
21964 return resultobj;
21965 fail:
21966 return NULL;
21967 }
21968
21969
21970 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21971 PyObject *resultobj = 0;
21972 int arg1 ;
21973 int result;
21974 int val1 ;
21975 int ecode1 = 0 ;
21976 PyObject * obj0 = 0 ;
21977 char * kwnames[] = {
21978 (char *) "year", NULL
21979 };
21980
21981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
21982 ecode1 = SWIG_AsVal_int(obj0, &val1);
21983 if (!SWIG_IsOK(ecode1)) {
21984 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
21985 }
21986 arg1 = static_cast< int >(val1);
21987 {
21988 PyThreadState* __tstate = wxPyBeginAllowThreads();
21989 result = (int)wxDateTime::ConvertYearToBC(arg1);
21990 wxPyEndAllowThreads(__tstate);
21991 if (PyErr_Occurred()) SWIG_fail;
21992 }
21993 resultobj = SWIG_From_int(static_cast< int >(result));
21994 return resultobj;
21995 fail:
21996 return NULL;
21997 }
21998
21999
22000 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22001 PyObject *resultobj = 0;
22002 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22003 wxDateTime::Month result;
22004 int val1 ;
22005 int ecode1 = 0 ;
22006 PyObject * obj0 = 0 ;
22007 char * kwnames[] = {
22008 (char *) "cal", NULL
22009 };
22010
22011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
22012 if (obj0) {
22013 ecode1 = SWIG_AsVal_int(obj0, &val1);
22014 if (!SWIG_IsOK(ecode1)) {
22015 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
22016 }
22017 arg1 = static_cast< wxDateTime::Calendar >(val1);
22018 }
22019 {
22020 PyThreadState* __tstate = wxPyBeginAllowThreads();
22021 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
22022 wxPyEndAllowThreads(__tstate);
22023 if (PyErr_Occurred()) SWIG_fail;
22024 }
22025 resultobj = SWIG_From_int(static_cast< int >(result));
22026 return resultobj;
22027 fail:
22028 return NULL;
22029 }
22030
22031
22032 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22033 PyObject *resultobj = 0;
22034 int arg1 = (int) wxDateTime::Inv_Year ;
22035 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22036 bool result;
22037 int val1 ;
22038 int ecode1 = 0 ;
22039 int val2 ;
22040 int ecode2 = 0 ;
22041 PyObject * obj0 = 0 ;
22042 PyObject * obj1 = 0 ;
22043 char * kwnames[] = {
22044 (char *) "year",(char *) "cal", NULL
22045 };
22046
22047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
22048 if (obj0) {
22049 ecode1 = SWIG_AsVal_int(obj0, &val1);
22050 if (!SWIG_IsOK(ecode1)) {
22051 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
22052 }
22053 arg1 = static_cast< int >(val1);
22054 }
22055 if (obj1) {
22056 ecode2 = SWIG_AsVal_int(obj1, &val2);
22057 if (!SWIG_IsOK(ecode2)) {
22058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22059 }
22060 arg2 = static_cast< wxDateTime::Calendar >(val2);
22061 }
22062 {
22063 PyThreadState* __tstate = wxPyBeginAllowThreads();
22064 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
22065 wxPyEndAllowThreads(__tstate);
22066 if (PyErr_Occurred()) SWIG_fail;
22067 }
22068 {
22069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22070 }
22071 return resultobj;
22072 fail:
22073 return NULL;
22074 }
22075
22076
22077 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22078 PyObject *resultobj = 0;
22079 int arg1 = (int) wxDateTime::Inv_Year ;
22080 int result;
22081 int val1 ;
22082 int ecode1 = 0 ;
22083 PyObject * obj0 = 0 ;
22084 char * kwnames[] = {
22085 (char *) "year", NULL
22086 };
22087
22088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
22089 if (obj0) {
22090 ecode1 = SWIG_AsVal_int(obj0, &val1);
22091 if (!SWIG_IsOK(ecode1)) {
22092 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
22093 }
22094 arg1 = static_cast< int >(val1);
22095 }
22096 {
22097 PyThreadState* __tstate = wxPyBeginAllowThreads();
22098 result = (int)wxDateTime::GetCentury(arg1);
22099 wxPyEndAllowThreads(__tstate);
22100 if (PyErr_Occurred()) SWIG_fail;
22101 }
22102 resultobj = SWIG_From_int(static_cast< int >(result));
22103 return resultobj;
22104 fail:
22105 return NULL;
22106 }
22107
22108
22109 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22110 PyObject *resultobj = 0;
22111 int arg1 ;
22112 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22113 int result;
22114 int val1 ;
22115 int ecode1 = 0 ;
22116 int val2 ;
22117 int ecode2 = 0 ;
22118 PyObject * obj0 = 0 ;
22119 PyObject * obj1 = 0 ;
22120 char * kwnames[] = {
22121 (char *) "year",(char *) "cal", NULL
22122 };
22123
22124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
22125 ecode1 = SWIG_AsVal_int(obj0, &val1);
22126 if (!SWIG_IsOK(ecode1)) {
22127 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
22128 }
22129 arg1 = static_cast< int >(val1);
22130 if (obj1) {
22131 ecode2 = SWIG_AsVal_int(obj1, &val2);
22132 if (!SWIG_IsOK(ecode2)) {
22133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22134 }
22135 arg2 = static_cast< wxDateTime::Calendar >(val2);
22136 }
22137 {
22138 PyThreadState* __tstate = wxPyBeginAllowThreads();
22139 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
22140 wxPyEndAllowThreads(__tstate);
22141 if (PyErr_Occurred()) SWIG_fail;
22142 }
22143 resultobj = SWIG_From_int(static_cast< int >(result));
22144 return resultobj;
22145 fail:
22146 return NULL;
22147 }
22148
22149
22150 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22151 PyObject *resultobj = 0;
22152 wxDateTime::Month arg1 ;
22153 int arg2 = (int) wxDateTime::Inv_Year ;
22154 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22155 int result;
22156 int val1 ;
22157 int ecode1 = 0 ;
22158 int val2 ;
22159 int ecode2 = 0 ;
22160 int val3 ;
22161 int ecode3 = 0 ;
22162 PyObject * obj0 = 0 ;
22163 PyObject * obj1 = 0 ;
22164 PyObject * obj2 = 0 ;
22165 char * kwnames[] = {
22166 (char *) "month",(char *) "year",(char *) "cal", NULL
22167 };
22168
22169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22170 ecode1 = SWIG_AsVal_int(obj0, &val1);
22171 if (!SWIG_IsOK(ecode1)) {
22172 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22173 }
22174 arg1 = static_cast< wxDateTime::Month >(val1);
22175 if (obj1) {
22176 ecode2 = SWIG_AsVal_int(obj1, &val2);
22177 if (!SWIG_IsOK(ecode2)) {
22178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
22179 }
22180 arg2 = static_cast< int >(val2);
22181 }
22182 if (obj2) {
22183 ecode3 = SWIG_AsVal_int(obj2, &val3);
22184 if (!SWIG_IsOK(ecode3)) {
22185 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
22186 }
22187 arg3 = static_cast< wxDateTime::Calendar >(val3);
22188 }
22189 {
22190 PyThreadState* __tstate = wxPyBeginAllowThreads();
22191 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
22192 wxPyEndAllowThreads(__tstate);
22193 if (PyErr_Occurred()) SWIG_fail;
22194 }
22195 resultobj = SWIG_From_int(static_cast< int >(result));
22196 return resultobj;
22197 fail:
22198 return NULL;
22199 }
22200
22201
22202 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22203 PyObject *resultobj = 0;
22204 wxDateTime::Month arg1 ;
22205 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22206 wxString result;
22207 int val1 ;
22208 int ecode1 = 0 ;
22209 int val2 ;
22210 int ecode2 = 0 ;
22211 PyObject * obj0 = 0 ;
22212 PyObject * obj1 = 0 ;
22213 char * kwnames[] = {
22214 (char *) "month",(char *) "flags", NULL
22215 };
22216
22217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
22218 ecode1 = SWIG_AsVal_int(obj0, &val1);
22219 if (!SWIG_IsOK(ecode1)) {
22220 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22221 }
22222 arg1 = static_cast< wxDateTime::Month >(val1);
22223 if (obj1) {
22224 ecode2 = SWIG_AsVal_int(obj1, &val2);
22225 if (!SWIG_IsOK(ecode2)) {
22226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22227 }
22228 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22229 }
22230 {
22231 PyThreadState* __tstate = wxPyBeginAllowThreads();
22232 result = wxDateTime::GetMonthName(arg1,arg2);
22233 wxPyEndAllowThreads(__tstate);
22234 if (PyErr_Occurred()) SWIG_fail;
22235 }
22236 {
22237 #if wxUSE_UNICODE
22238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22239 #else
22240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22241 #endif
22242 }
22243 return resultobj;
22244 fail:
22245 return NULL;
22246 }
22247
22248
22249 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22250 PyObject *resultobj = 0;
22251 wxDateTime::WeekDay arg1 ;
22252 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22253 wxString result;
22254 int val1 ;
22255 int ecode1 = 0 ;
22256 int val2 ;
22257 int ecode2 = 0 ;
22258 PyObject * obj0 = 0 ;
22259 PyObject * obj1 = 0 ;
22260 char * kwnames[] = {
22261 (char *) "weekday",(char *) "flags", NULL
22262 };
22263
22264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
22265 ecode1 = SWIG_AsVal_int(obj0, &val1);
22266 if (!SWIG_IsOK(ecode1)) {
22267 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
22268 }
22269 arg1 = static_cast< wxDateTime::WeekDay >(val1);
22270 if (obj1) {
22271 ecode2 = SWIG_AsVal_int(obj1, &val2);
22272 if (!SWIG_IsOK(ecode2)) {
22273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22274 }
22275 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22276 }
22277 {
22278 PyThreadState* __tstate = wxPyBeginAllowThreads();
22279 result = wxDateTime::GetWeekDayName(arg1,arg2);
22280 wxPyEndAllowThreads(__tstate);
22281 if (PyErr_Occurred()) SWIG_fail;
22282 }
22283 {
22284 #if wxUSE_UNICODE
22285 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22286 #else
22287 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22288 #endif
22289 }
22290 return resultobj;
22291 fail:
22292 return NULL;
22293 }
22294
22295
22296 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22297 PyObject *resultobj = 0;
22298 PyObject *result = 0 ;
22299
22300 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
22301 {
22302 PyThreadState* __tstate = wxPyBeginAllowThreads();
22303 result = (PyObject *)wxDateTime_GetAmPmStrings();
22304 wxPyEndAllowThreads(__tstate);
22305 if (PyErr_Occurred()) SWIG_fail;
22306 }
22307 resultobj = result;
22308 return resultobj;
22309 fail:
22310 return NULL;
22311 }
22312
22313
22314 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22315 PyObject *resultobj = 0;
22316 int arg1 = (int) wxDateTime::Inv_Year ;
22317 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22318 bool result;
22319 int val1 ;
22320 int ecode1 = 0 ;
22321 int val2 ;
22322 int ecode2 = 0 ;
22323 PyObject * obj0 = 0 ;
22324 PyObject * obj1 = 0 ;
22325 char * kwnames[] = {
22326 (char *) "year",(char *) "country", NULL
22327 };
22328
22329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
22330 if (obj0) {
22331 ecode1 = SWIG_AsVal_int(obj0, &val1);
22332 if (!SWIG_IsOK(ecode1)) {
22333 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
22334 }
22335 arg1 = static_cast< int >(val1);
22336 }
22337 if (obj1) {
22338 ecode2 = SWIG_AsVal_int(obj1, &val2);
22339 if (!SWIG_IsOK(ecode2)) {
22340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22341 }
22342 arg2 = static_cast< wxDateTime::Country >(val2);
22343 }
22344 {
22345 PyThreadState* __tstate = wxPyBeginAllowThreads();
22346 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
22347 wxPyEndAllowThreads(__tstate);
22348 if (PyErr_Occurred()) SWIG_fail;
22349 }
22350 {
22351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22352 }
22353 return resultobj;
22354 fail:
22355 return NULL;
22356 }
22357
22358
22359 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22360 PyObject *resultobj = 0;
22361 int arg1 = (int) wxDateTime::Inv_Year ;
22362 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22363 wxDateTime result;
22364 int val1 ;
22365 int ecode1 = 0 ;
22366 int val2 ;
22367 int ecode2 = 0 ;
22368 PyObject * obj0 = 0 ;
22369 PyObject * obj1 = 0 ;
22370 char * kwnames[] = {
22371 (char *) "year",(char *) "country", NULL
22372 };
22373
22374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
22375 if (obj0) {
22376 ecode1 = SWIG_AsVal_int(obj0, &val1);
22377 if (!SWIG_IsOK(ecode1)) {
22378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
22379 }
22380 arg1 = static_cast< int >(val1);
22381 }
22382 if (obj1) {
22383 ecode2 = SWIG_AsVal_int(obj1, &val2);
22384 if (!SWIG_IsOK(ecode2)) {
22385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22386 }
22387 arg2 = static_cast< wxDateTime::Country >(val2);
22388 }
22389 {
22390 PyThreadState* __tstate = wxPyBeginAllowThreads();
22391 result = wxDateTime::GetBeginDST(arg1,arg2);
22392 wxPyEndAllowThreads(__tstate);
22393 if (PyErr_Occurred()) SWIG_fail;
22394 }
22395 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22396 return resultobj;
22397 fail:
22398 return NULL;
22399 }
22400
22401
22402 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22403 PyObject *resultobj = 0;
22404 int arg1 = (int) wxDateTime::Inv_Year ;
22405 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22406 wxDateTime result;
22407 int val1 ;
22408 int ecode1 = 0 ;
22409 int val2 ;
22410 int ecode2 = 0 ;
22411 PyObject * obj0 = 0 ;
22412 PyObject * obj1 = 0 ;
22413 char * kwnames[] = {
22414 (char *) "year",(char *) "country", NULL
22415 };
22416
22417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
22418 if (obj0) {
22419 ecode1 = SWIG_AsVal_int(obj0, &val1);
22420 if (!SWIG_IsOK(ecode1)) {
22421 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
22422 }
22423 arg1 = static_cast< int >(val1);
22424 }
22425 if (obj1) {
22426 ecode2 = SWIG_AsVal_int(obj1, &val2);
22427 if (!SWIG_IsOK(ecode2)) {
22428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22429 }
22430 arg2 = static_cast< wxDateTime::Country >(val2);
22431 }
22432 {
22433 PyThreadState* __tstate = wxPyBeginAllowThreads();
22434 result = wxDateTime::GetEndDST(arg1,arg2);
22435 wxPyEndAllowThreads(__tstate);
22436 if (PyErr_Occurred()) SWIG_fail;
22437 }
22438 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22439 return resultobj;
22440 fail:
22441 return NULL;
22442 }
22443
22444
22445 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22446 PyObject *resultobj = 0;
22447 wxDateTime result;
22448
22449 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
22450 {
22451 PyThreadState* __tstate = wxPyBeginAllowThreads();
22452 result = wxDateTime::Now();
22453 wxPyEndAllowThreads(__tstate);
22454 if (PyErr_Occurred()) SWIG_fail;
22455 }
22456 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22457 return resultobj;
22458 fail:
22459 return NULL;
22460 }
22461
22462
22463 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22464 PyObject *resultobj = 0;
22465 wxDateTime result;
22466
22467 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
22468 {
22469 PyThreadState* __tstate = wxPyBeginAllowThreads();
22470 result = wxDateTime::UNow();
22471 wxPyEndAllowThreads(__tstate);
22472 if (PyErr_Occurred()) SWIG_fail;
22473 }
22474 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22475 return resultobj;
22476 fail:
22477 return NULL;
22478 }
22479
22480
22481 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22482 PyObject *resultobj = 0;
22483 wxDateTime result;
22484
22485 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
22486 {
22487 PyThreadState* __tstate = wxPyBeginAllowThreads();
22488 result = wxDateTime::Today();
22489 wxPyEndAllowThreads(__tstate);
22490 if (PyErr_Occurred()) SWIG_fail;
22491 }
22492 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22493 return resultobj;
22494 fail:
22495 return NULL;
22496 }
22497
22498
22499 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22500 PyObject *resultobj = 0;
22501 wxDateTime *result = 0 ;
22502
22503 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
22504 {
22505 PyThreadState* __tstate = wxPyBeginAllowThreads();
22506 result = (wxDateTime *)new wxDateTime();
22507 wxPyEndAllowThreads(__tstate);
22508 if (PyErr_Occurred()) SWIG_fail;
22509 }
22510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
22511 return resultobj;
22512 fail:
22513 return NULL;
22514 }
22515
22516
22517 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22518 PyObject *resultobj = 0;
22519 time_t arg1 ;
22520 wxDateTime *result = 0 ;
22521 unsigned int val1 ;
22522 int ecode1 = 0 ;
22523 PyObject * obj0 = 0 ;
22524 char * kwnames[] = {
22525 (char *) "timet", NULL
22526 };
22527
22528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
22529 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
22530 if (!SWIG_IsOK(ecode1)) {
22531 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
22532 }
22533 arg1 = static_cast< time_t >(val1);
22534 {
22535 PyThreadState* __tstate = wxPyBeginAllowThreads();
22536 result = (wxDateTime *)new wxDateTime(arg1);
22537 wxPyEndAllowThreads(__tstate);
22538 if (PyErr_Occurred()) SWIG_fail;
22539 }
22540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22541 return resultobj;
22542 fail:
22543 return NULL;
22544 }
22545
22546
22547 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22548 PyObject *resultobj = 0;
22549 double arg1 ;
22550 wxDateTime *result = 0 ;
22551 double val1 ;
22552 int ecode1 = 0 ;
22553 PyObject * obj0 = 0 ;
22554 char * kwnames[] = {
22555 (char *) "jdn", NULL
22556 };
22557
22558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
22559 ecode1 = SWIG_AsVal_double(obj0, &val1);
22560 if (!SWIG_IsOK(ecode1)) {
22561 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
22562 }
22563 arg1 = static_cast< double >(val1);
22564 {
22565 PyThreadState* __tstate = wxPyBeginAllowThreads();
22566 result = (wxDateTime *)new wxDateTime(arg1);
22567 wxPyEndAllowThreads(__tstate);
22568 if (PyErr_Occurred()) SWIG_fail;
22569 }
22570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22571 return resultobj;
22572 fail:
22573 return NULL;
22574 }
22575
22576
22577 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22578 PyObject *resultobj = 0;
22579 int arg1 ;
22580 int arg2 = (int) 0 ;
22581 int arg3 = (int) 0 ;
22582 int arg4 = (int) 0 ;
22583 wxDateTime *result = 0 ;
22584 int val1 ;
22585 int ecode1 = 0 ;
22586 int val2 ;
22587 int ecode2 = 0 ;
22588 int val3 ;
22589 int ecode3 = 0 ;
22590 int val4 ;
22591 int ecode4 = 0 ;
22592 PyObject * obj0 = 0 ;
22593 PyObject * obj1 = 0 ;
22594 PyObject * obj2 = 0 ;
22595 PyObject * obj3 = 0 ;
22596 char * kwnames[] = {
22597 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22598 };
22599
22600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22601 ecode1 = SWIG_AsVal_int(obj0, &val1);
22602 if (!SWIG_IsOK(ecode1)) {
22603 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
22604 }
22605 arg1 = static_cast< int >(val1);
22606 if (obj1) {
22607 ecode2 = SWIG_AsVal_int(obj1, &val2);
22608 if (!SWIG_IsOK(ecode2)) {
22609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
22610 }
22611 arg2 = static_cast< int >(val2);
22612 }
22613 if (obj2) {
22614 ecode3 = SWIG_AsVal_int(obj2, &val3);
22615 if (!SWIG_IsOK(ecode3)) {
22616 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
22617 }
22618 arg3 = static_cast< int >(val3);
22619 }
22620 if (obj3) {
22621 ecode4 = SWIG_AsVal_int(obj3, &val4);
22622 if (!SWIG_IsOK(ecode4)) {
22623 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
22624 }
22625 arg4 = static_cast< int >(val4);
22626 }
22627 {
22628 PyThreadState* __tstate = wxPyBeginAllowThreads();
22629 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
22630 wxPyEndAllowThreads(__tstate);
22631 if (PyErr_Occurred()) SWIG_fail;
22632 }
22633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22634 return resultobj;
22635 fail:
22636 return NULL;
22637 }
22638
22639
22640 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22641 PyObject *resultobj = 0;
22642 int arg1 ;
22643 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22644 int arg3 = (int) wxDateTime::Inv_Year ;
22645 int arg4 = (int) 0 ;
22646 int arg5 = (int) 0 ;
22647 int arg6 = (int) 0 ;
22648 int arg7 = (int) 0 ;
22649 wxDateTime *result = 0 ;
22650 int val1 ;
22651 int ecode1 = 0 ;
22652 int val2 ;
22653 int ecode2 = 0 ;
22654 int val3 ;
22655 int ecode3 = 0 ;
22656 int val4 ;
22657 int ecode4 = 0 ;
22658 int val5 ;
22659 int ecode5 = 0 ;
22660 int val6 ;
22661 int ecode6 = 0 ;
22662 int val7 ;
22663 int ecode7 = 0 ;
22664 PyObject * obj0 = 0 ;
22665 PyObject * obj1 = 0 ;
22666 PyObject * obj2 = 0 ;
22667 PyObject * obj3 = 0 ;
22668 PyObject * obj4 = 0 ;
22669 PyObject * obj5 = 0 ;
22670 PyObject * obj6 = 0 ;
22671 char * kwnames[] = {
22672 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22673 };
22674
22675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22676 ecode1 = SWIG_AsVal_int(obj0, &val1);
22677 if (!SWIG_IsOK(ecode1)) {
22678 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
22679 }
22680 arg1 = static_cast< int >(val1);
22681 if (obj1) {
22682 ecode2 = SWIG_AsVal_int(obj1, &val2);
22683 if (!SWIG_IsOK(ecode2)) {
22684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
22685 }
22686 arg2 = static_cast< wxDateTime::Month >(val2);
22687 }
22688 if (obj2) {
22689 ecode3 = SWIG_AsVal_int(obj2, &val3);
22690 if (!SWIG_IsOK(ecode3)) {
22691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
22692 }
22693 arg3 = static_cast< int >(val3);
22694 }
22695 if (obj3) {
22696 ecode4 = SWIG_AsVal_int(obj3, &val4);
22697 if (!SWIG_IsOK(ecode4)) {
22698 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
22699 }
22700 arg4 = static_cast< int >(val4);
22701 }
22702 if (obj4) {
22703 ecode5 = SWIG_AsVal_int(obj4, &val5);
22704 if (!SWIG_IsOK(ecode5)) {
22705 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
22706 }
22707 arg5 = static_cast< int >(val5);
22708 }
22709 if (obj5) {
22710 ecode6 = SWIG_AsVal_int(obj5, &val6);
22711 if (!SWIG_IsOK(ecode6)) {
22712 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
22713 }
22714 arg6 = static_cast< int >(val6);
22715 }
22716 if (obj6) {
22717 ecode7 = SWIG_AsVal_int(obj6, &val7);
22718 if (!SWIG_IsOK(ecode7)) {
22719 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
22720 }
22721 arg7 = static_cast< int >(val7);
22722 }
22723 {
22724 PyThreadState* __tstate = wxPyBeginAllowThreads();
22725 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
22726 wxPyEndAllowThreads(__tstate);
22727 if (PyErr_Occurred()) SWIG_fail;
22728 }
22729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22730 return resultobj;
22731 fail:
22732 return NULL;
22733 }
22734
22735
22736 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22737 PyObject *resultobj = 0;
22738 wxDateTime *arg1 = 0 ;
22739 wxDateTime *result = 0 ;
22740 void *argp1 = 0 ;
22741 int res1 = 0 ;
22742 PyObject * obj0 = 0 ;
22743 char * kwnames[] = {
22744 (char *) "date", NULL
22745 };
22746
22747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
22748 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
22749 if (!SWIG_IsOK(res1)) {
22750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22751 }
22752 if (!argp1) {
22753 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22754 }
22755 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22756 {
22757 PyThreadState* __tstate = wxPyBeginAllowThreads();
22758 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
22759 wxPyEndAllowThreads(__tstate);
22760 if (PyErr_Occurred()) SWIG_fail;
22761 }
22762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22763 return resultobj;
22764 fail:
22765 return NULL;
22766 }
22767
22768
22769 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22770 PyObject *resultobj = 0;
22771 wxDateTime *arg1 = (wxDateTime *) 0 ;
22772 void *argp1 = 0 ;
22773 int res1 = 0 ;
22774 PyObject *swig_obj[1] ;
22775
22776 if (!args) SWIG_fail;
22777 swig_obj[0] = args;
22778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
22779 if (!SWIG_IsOK(res1)) {
22780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
22781 }
22782 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22783 {
22784 PyThreadState* __tstate = wxPyBeginAllowThreads();
22785 delete arg1;
22786
22787 wxPyEndAllowThreads(__tstate);
22788 if (PyErr_Occurred()) SWIG_fail;
22789 }
22790 resultobj = SWIG_Py_Void();
22791 return resultobj;
22792 fail:
22793 return NULL;
22794 }
22795
22796
22797 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22798 PyObject *resultobj = 0;
22799 wxDateTime *arg1 = (wxDateTime *) 0 ;
22800 wxDateTime *result = 0 ;
22801 void *argp1 = 0 ;
22802 int res1 = 0 ;
22803 PyObject *swig_obj[1] ;
22804
22805 if (!args) SWIG_fail;
22806 swig_obj[0] = args;
22807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22808 if (!SWIG_IsOK(res1)) {
22809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
22810 }
22811 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22812 {
22813 PyThreadState* __tstate = wxPyBeginAllowThreads();
22814 {
22815 wxDateTime &_result_ref = (arg1)->SetToCurrent();
22816 result = (wxDateTime *) &_result_ref;
22817 }
22818 wxPyEndAllowThreads(__tstate);
22819 if (PyErr_Occurred()) SWIG_fail;
22820 }
22821 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22822 return resultobj;
22823 fail:
22824 return NULL;
22825 }
22826
22827
22828 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22829 PyObject *resultobj = 0;
22830 wxDateTime *arg1 = (wxDateTime *) 0 ;
22831 time_t arg2 ;
22832 wxDateTime *result = 0 ;
22833 void *argp1 = 0 ;
22834 int res1 = 0 ;
22835 unsigned int val2 ;
22836 int ecode2 = 0 ;
22837 PyObject * obj0 = 0 ;
22838 PyObject * obj1 = 0 ;
22839 char * kwnames[] = {
22840 (char *) "self",(char *) "timet", NULL
22841 };
22842
22843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
22844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22845 if (!SWIG_IsOK(res1)) {
22846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
22847 }
22848 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22849 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22850 if (!SWIG_IsOK(ecode2)) {
22851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
22852 }
22853 arg2 = static_cast< time_t >(val2);
22854 {
22855 PyThreadState* __tstate = wxPyBeginAllowThreads();
22856 {
22857 wxDateTime &_result_ref = (arg1)->Set(arg2);
22858 result = (wxDateTime *) &_result_ref;
22859 }
22860 wxPyEndAllowThreads(__tstate);
22861 if (PyErr_Occurred()) SWIG_fail;
22862 }
22863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22864 return resultobj;
22865 fail:
22866 return NULL;
22867 }
22868
22869
22870 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22871 PyObject *resultobj = 0;
22872 wxDateTime *arg1 = (wxDateTime *) 0 ;
22873 double arg2 ;
22874 wxDateTime *result = 0 ;
22875 void *argp1 = 0 ;
22876 int res1 = 0 ;
22877 double val2 ;
22878 int ecode2 = 0 ;
22879 PyObject * obj0 = 0 ;
22880 PyObject * obj1 = 0 ;
22881 char * kwnames[] = {
22882 (char *) "self",(char *) "jdn", NULL
22883 };
22884
22885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
22886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22887 if (!SWIG_IsOK(res1)) {
22888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
22889 }
22890 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22891 ecode2 = SWIG_AsVal_double(obj1, &val2);
22892 if (!SWIG_IsOK(ecode2)) {
22893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
22894 }
22895 arg2 = static_cast< double >(val2);
22896 {
22897 PyThreadState* __tstate = wxPyBeginAllowThreads();
22898 {
22899 wxDateTime &_result_ref = (arg1)->Set(arg2);
22900 result = (wxDateTime *) &_result_ref;
22901 }
22902 wxPyEndAllowThreads(__tstate);
22903 if (PyErr_Occurred()) SWIG_fail;
22904 }
22905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22906 return resultobj;
22907 fail:
22908 return NULL;
22909 }
22910
22911
22912 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22913 PyObject *resultobj = 0;
22914 wxDateTime *arg1 = (wxDateTime *) 0 ;
22915 int arg2 ;
22916 int arg3 = (int) 0 ;
22917 int arg4 = (int) 0 ;
22918 int arg5 = (int) 0 ;
22919 wxDateTime *result = 0 ;
22920 void *argp1 = 0 ;
22921 int res1 = 0 ;
22922 int val2 ;
22923 int ecode2 = 0 ;
22924 int val3 ;
22925 int ecode3 = 0 ;
22926 int val4 ;
22927 int ecode4 = 0 ;
22928 int val5 ;
22929 int ecode5 = 0 ;
22930 PyObject * obj0 = 0 ;
22931 PyObject * obj1 = 0 ;
22932 PyObject * obj2 = 0 ;
22933 PyObject * obj3 = 0 ;
22934 PyObject * obj4 = 0 ;
22935 char * kwnames[] = {
22936 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22937 };
22938
22939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22941 if (!SWIG_IsOK(res1)) {
22942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
22943 }
22944 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22945 ecode2 = SWIG_AsVal_int(obj1, &val2);
22946 if (!SWIG_IsOK(ecode2)) {
22947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
22948 }
22949 arg2 = static_cast< int >(val2);
22950 if (obj2) {
22951 ecode3 = SWIG_AsVal_int(obj2, &val3);
22952 if (!SWIG_IsOK(ecode3)) {
22953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
22954 }
22955 arg3 = static_cast< int >(val3);
22956 }
22957 if (obj3) {
22958 ecode4 = SWIG_AsVal_int(obj3, &val4);
22959 if (!SWIG_IsOK(ecode4)) {
22960 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
22961 }
22962 arg4 = static_cast< int >(val4);
22963 }
22964 if (obj4) {
22965 ecode5 = SWIG_AsVal_int(obj4, &val5);
22966 if (!SWIG_IsOK(ecode5)) {
22967 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
22968 }
22969 arg5 = static_cast< int >(val5);
22970 }
22971 {
22972 PyThreadState* __tstate = wxPyBeginAllowThreads();
22973 {
22974 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
22975 result = (wxDateTime *) &_result_ref;
22976 }
22977 wxPyEndAllowThreads(__tstate);
22978 if (PyErr_Occurred()) SWIG_fail;
22979 }
22980 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22981 return resultobj;
22982 fail:
22983 return NULL;
22984 }
22985
22986
22987 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22988 PyObject *resultobj = 0;
22989 wxDateTime *arg1 = (wxDateTime *) 0 ;
22990 int arg2 ;
22991 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22992 int arg4 = (int) wxDateTime::Inv_Year ;
22993 int arg5 = (int) 0 ;
22994 int arg6 = (int) 0 ;
22995 int arg7 = (int) 0 ;
22996 int arg8 = (int) 0 ;
22997 wxDateTime *result = 0 ;
22998 void *argp1 = 0 ;
22999 int res1 = 0 ;
23000 int val2 ;
23001 int ecode2 = 0 ;
23002 int val3 ;
23003 int ecode3 = 0 ;
23004 int val4 ;
23005 int ecode4 = 0 ;
23006 int val5 ;
23007 int ecode5 = 0 ;
23008 int val6 ;
23009 int ecode6 = 0 ;
23010 int val7 ;
23011 int ecode7 = 0 ;
23012 int val8 ;
23013 int ecode8 = 0 ;
23014 PyObject * obj0 = 0 ;
23015 PyObject * obj1 = 0 ;
23016 PyObject * obj2 = 0 ;
23017 PyObject * obj3 = 0 ;
23018 PyObject * obj4 = 0 ;
23019 PyObject * obj5 = 0 ;
23020 PyObject * obj6 = 0 ;
23021 PyObject * obj7 = 0 ;
23022 char * kwnames[] = {
23023 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23024 };
23025
23026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
23027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23028 if (!SWIG_IsOK(res1)) {
23029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
23030 }
23031 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23032 ecode2 = SWIG_AsVal_int(obj1, &val2);
23033 if (!SWIG_IsOK(ecode2)) {
23034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
23035 }
23036 arg2 = static_cast< int >(val2);
23037 if (obj2) {
23038 ecode3 = SWIG_AsVal_int(obj2, &val3);
23039 if (!SWIG_IsOK(ecode3)) {
23040 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23041 }
23042 arg3 = static_cast< wxDateTime::Month >(val3);
23043 }
23044 if (obj3) {
23045 ecode4 = SWIG_AsVal_int(obj3, &val4);
23046 if (!SWIG_IsOK(ecode4)) {
23047 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
23048 }
23049 arg4 = static_cast< int >(val4);
23050 }
23051 if (obj4) {
23052 ecode5 = SWIG_AsVal_int(obj4, &val5);
23053 if (!SWIG_IsOK(ecode5)) {
23054 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
23055 }
23056 arg5 = static_cast< int >(val5);
23057 }
23058 if (obj5) {
23059 ecode6 = SWIG_AsVal_int(obj5, &val6);
23060 if (!SWIG_IsOK(ecode6)) {
23061 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
23062 }
23063 arg6 = static_cast< int >(val6);
23064 }
23065 if (obj6) {
23066 ecode7 = SWIG_AsVal_int(obj6, &val7);
23067 if (!SWIG_IsOK(ecode7)) {
23068 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
23069 }
23070 arg7 = static_cast< int >(val7);
23071 }
23072 if (obj7) {
23073 ecode8 = SWIG_AsVal_int(obj7, &val8);
23074 if (!SWIG_IsOK(ecode8)) {
23075 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
23076 }
23077 arg8 = static_cast< int >(val8);
23078 }
23079 {
23080 PyThreadState* __tstate = wxPyBeginAllowThreads();
23081 {
23082 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
23083 result = (wxDateTime *) &_result_ref;
23084 }
23085 wxPyEndAllowThreads(__tstate);
23086 if (PyErr_Occurred()) SWIG_fail;
23087 }
23088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23089 return resultobj;
23090 fail:
23091 return NULL;
23092 }
23093
23094
23095 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23096 PyObject *resultobj = 0;
23097 wxDateTime *arg1 = (wxDateTime *) 0 ;
23098 wxDateTime *result = 0 ;
23099 void *argp1 = 0 ;
23100 int res1 = 0 ;
23101 PyObject *swig_obj[1] ;
23102
23103 if (!args) SWIG_fail;
23104 swig_obj[0] = args;
23105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23106 if (!SWIG_IsOK(res1)) {
23107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23108 }
23109 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23110 {
23111 PyThreadState* __tstate = wxPyBeginAllowThreads();
23112 {
23113 wxDateTime &_result_ref = (arg1)->ResetTime();
23114 result = (wxDateTime *) &_result_ref;
23115 }
23116 wxPyEndAllowThreads(__tstate);
23117 if (PyErr_Occurred()) SWIG_fail;
23118 }
23119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23120 return resultobj;
23121 fail:
23122 return NULL;
23123 }
23124
23125
23126 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23127 PyObject *resultobj = 0;
23128 wxDateTime *arg1 = (wxDateTime *) 0 ;
23129 int arg2 ;
23130 wxDateTime *result = 0 ;
23131 void *argp1 = 0 ;
23132 int res1 = 0 ;
23133 int val2 ;
23134 int ecode2 = 0 ;
23135 PyObject * obj0 = 0 ;
23136 PyObject * obj1 = 0 ;
23137 char * kwnames[] = {
23138 (char *) "self",(char *) "year", NULL
23139 };
23140
23141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
23142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23143 if (!SWIG_IsOK(res1)) {
23144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
23145 }
23146 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23147 ecode2 = SWIG_AsVal_int(obj1, &val2);
23148 if (!SWIG_IsOK(ecode2)) {
23149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
23150 }
23151 arg2 = static_cast< int >(val2);
23152 {
23153 PyThreadState* __tstate = wxPyBeginAllowThreads();
23154 {
23155 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
23156 result = (wxDateTime *) &_result_ref;
23157 }
23158 wxPyEndAllowThreads(__tstate);
23159 if (PyErr_Occurred()) SWIG_fail;
23160 }
23161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23162 return resultobj;
23163 fail:
23164 return NULL;
23165 }
23166
23167
23168 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23169 PyObject *resultobj = 0;
23170 wxDateTime *arg1 = (wxDateTime *) 0 ;
23171 wxDateTime::Month arg2 ;
23172 wxDateTime *result = 0 ;
23173 void *argp1 = 0 ;
23174 int res1 = 0 ;
23175 int val2 ;
23176 int ecode2 = 0 ;
23177 PyObject * obj0 = 0 ;
23178 PyObject * obj1 = 0 ;
23179 char * kwnames[] = {
23180 (char *) "self",(char *) "month", NULL
23181 };
23182
23183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
23184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23185 if (!SWIG_IsOK(res1)) {
23186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
23187 }
23188 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23189 ecode2 = SWIG_AsVal_int(obj1, &val2);
23190 if (!SWIG_IsOK(ecode2)) {
23191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23192 }
23193 arg2 = static_cast< wxDateTime::Month >(val2);
23194 {
23195 PyThreadState* __tstate = wxPyBeginAllowThreads();
23196 {
23197 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
23198 result = (wxDateTime *) &_result_ref;
23199 }
23200 wxPyEndAllowThreads(__tstate);
23201 if (PyErr_Occurred()) SWIG_fail;
23202 }
23203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23204 return resultobj;
23205 fail:
23206 return NULL;
23207 }
23208
23209
23210 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23211 PyObject *resultobj = 0;
23212 wxDateTime *arg1 = (wxDateTime *) 0 ;
23213 int arg2 ;
23214 wxDateTime *result = 0 ;
23215 void *argp1 = 0 ;
23216 int res1 = 0 ;
23217 int val2 ;
23218 int ecode2 = 0 ;
23219 PyObject * obj0 = 0 ;
23220 PyObject * obj1 = 0 ;
23221 char * kwnames[] = {
23222 (char *) "self",(char *) "day", NULL
23223 };
23224
23225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
23226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23227 if (!SWIG_IsOK(res1)) {
23228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23229 }
23230 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23231 ecode2 = SWIG_AsVal_int(obj1, &val2);
23232 if (!SWIG_IsOK(ecode2)) {
23233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
23234 }
23235 arg2 = static_cast< int >(val2);
23236 {
23237 PyThreadState* __tstate = wxPyBeginAllowThreads();
23238 {
23239 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
23240 result = (wxDateTime *) &_result_ref;
23241 }
23242 wxPyEndAllowThreads(__tstate);
23243 if (PyErr_Occurred()) SWIG_fail;
23244 }
23245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23246 return resultobj;
23247 fail:
23248 return NULL;
23249 }
23250
23251
23252 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23253 PyObject *resultobj = 0;
23254 wxDateTime *arg1 = (wxDateTime *) 0 ;
23255 int arg2 ;
23256 wxDateTime *result = 0 ;
23257 void *argp1 = 0 ;
23258 int res1 = 0 ;
23259 int val2 ;
23260 int ecode2 = 0 ;
23261 PyObject * obj0 = 0 ;
23262 PyObject * obj1 = 0 ;
23263 char * kwnames[] = {
23264 (char *) "self",(char *) "hour", NULL
23265 };
23266
23267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
23268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23269 if (!SWIG_IsOK(res1)) {
23270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
23271 }
23272 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23273 ecode2 = SWIG_AsVal_int(obj1, &val2);
23274 if (!SWIG_IsOK(ecode2)) {
23275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
23276 }
23277 arg2 = static_cast< int >(val2);
23278 {
23279 PyThreadState* __tstate = wxPyBeginAllowThreads();
23280 {
23281 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
23282 result = (wxDateTime *) &_result_ref;
23283 }
23284 wxPyEndAllowThreads(__tstate);
23285 if (PyErr_Occurred()) SWIG_fail;
23286 }
23287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23288 return resultobj;
23289 fail:
23290 return NULL;
23291 }
23292
23293
23294 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23295 PyObject *resultobj = 0;
23296 wxDateTime *arg1 = (wxDateTime *) 0 ;
23297 int arg2 ;
23298 wxDateTime *result = 0 ;
23299 void *argp1 = 0 ;
23300 int res1 = 0 ;
23301 int val2 ;
23302 int ecode2 = 0 ;
23303 PyObject * obj0 = 0 ;
23304 PyObject * obj1 = 0 ;
23305 char * kwnames[] = {
23306 (char *) "self",(char *) "minute", NULL
23307 };
23308
23309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
23310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23311 if (!SWIG_IsOK(res1)) {
23312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
23313 }
23314 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23315 ecode2 = SWIG_AsVal_int(obj1, &val2);
23316 if (!SWIG_IsOK(ecode2)) {
23317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
23318 }
23319 arg2 = static_cast< int >(val2);
23320 {
23321 PyThreadState* __tstate = wxPyBeginAllowThreads();
23322 {
23323 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
23324 result = (wxDateTime *) &_result_ref;
23325 }
23326 wxPyEndAllowThreads(__tstate);
23327 if (PyErr_Occurred()) SWIG_fail;
23328 }
23329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23330 return resultobj;
23331 fail:
23332 return NULL;
23333 }
23334
23335
23336 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23337 PyObject *resultobj = 0;
23338 wxDateTime *arg1 = (wxDateTime *) 0 ;
23339 int arg2 ;
23340 wxDateTime *result = 0 ;
23341 void *argp1 = 0 ;
23342 int res1 = 0 ;
23343 int val2 ;
23344 int ecode2 = 0 ;
23345 PyObject * obj0 = 0 ;
23346 PyObject * obj1 = 0 ;
23347 char * kwnames[] = {
23348 (char *) "self",(char *) "second", NULL
23349 };
23350
23351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
23352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23353 if (!SWIG_IsOK(res1)) {
23354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23355 }
23356 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23357 ecode2 = SWIG_AsVal_int(obj1, &val2);
23358 if (!SWIG_IsOK(ecode2)) {
23359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
23360 }
23361 arg2 = static_cast< int >(val2);
23362 {
23363 PyThreadState* __tstate = wxPyBeginAllowThreads();
23364 {
23365 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
23366 result = (wxDateTime *) &_result_ref;
23367 }
23368 wxPyEndAllowThreads(__tstate);
23369 if (PyErr_Occurred()) SWIG_fail;
23370 }
23371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23372 return resultobj;
23373 fail:
23374 return NULL;
23375 }
23376
23377
23378 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23379 PyObject *resultobj = 0;
23380 wxDateTime *arg1 = (wxDateTime *) 0 ;
23381 int arg2 ;
23382 wxDateTime *result = 0 ;
23383 void *argp1 = 0 ;
23384 int res1 = 0 ;
23385 int val2 ;
23386 int ecode2 = 0 ;
23387 PyObject * obj0 = 0 ;
23388 PyObject * obj1 = 0 ;
23389 char * kwnames[] = {
23390 (char *) "self",(char *) "millisecond", NULL
23391 };
23392
23393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
23394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23395 if (!SWIG_IsOK(res1)) {
23396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23397 }
23398 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23399 ecode2 = SWIG_AsVal_int(obj1, &val2);
23400 if (!SWIG_IsOK(ecode2)) {
23401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
23402 }
23403 arg2 = static_cast< int >(val2);
23404 {
23405 PyThreadState* __tstate = wxPyBeginAllowThreads();
23406 {
23407 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
23408 result = (wxDateTime *) &_result_ref;
23409 }
23410 wxPyEndAllowThreads(__tstate);
23411 if (PyErr_Occurred()) SWIG_fail;
23412 }
23413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23414 return resultobj;
23415 fail:
23416 return NULL;
23417 }
23418
23419
23420 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23421 PyObject *resultobj = 0;
23422 wxDateTime *arg1 = (wxDateTime *) 0 ;
23423 wxDateTime::WeekDay arg2 ;
23424 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23425 wxDateTime *result = 0 ;
23426 void *argp1 = 0 ;
23427 int res1 = 0 ;
23428 int val2 ;
23429 int ecode2 = 0 ;
23430 int val3 ;
23431 int ecode3 = 0 ;
23432 PyObject * obj0 = 0 ;
23433 PyObject * obj1 = 0 ;
23434 PyObject * obj2 = 0 ;
23435 char * kwnames[] = {
23436 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23437 };
23438
23439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23441 if (!SWIG_IsOK(res1)) {
23442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23443 }
23444 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23445 ecode2 = SWIG_AsVal_int(obj1, &val2);
23446 if (!SWIG_IsOK(ecode2)) {
23447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23448 }
23449 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23450 if (obj2) {
23451 ecode3 = SWIG_AsVal_int(obj2, &val3);
23452 if (!SWIG_IsOK(ecode3)) {
23453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23454 }
23455 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23456 }
23457 {
23458 PyThreadState* __tstate = wxPyBeginAllowThreads();
23459 {
23460 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
23461 result = (wxDateTime *) &_result_ref;
23462 }
23463 wxPyEndAllowThreads(__tstate);
23464 if (PyErr_Occurred()) SWIG_fail;
23465 }
23466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23467 return resultobj;
23468 fail:
23469 return NULL;
23470 }
23471
23472
23473 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23474 PyObject *resultobj = 0;
23475 wxDateTime *arg1 = (wxDateTime *) 0 ;
23476 wxDateTime::WeekDay arg2 ;
23477 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23478 wxDateTime result;
23479 void *argp1 = 0 ;
23480 int res1 = 0 ;
23481 int val2 ;
23482 int ecode2 = 0 ;
23483 int val3 ;
23484 int ecode3 = 0 ;
23485 PyObject * obj0 = 0 ;
23486 PyObject * obj1 = 0 ;
23487 PyObject * obj2 = 0 ;
23488 char * kwnames[] = {
23489 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23490 };
23491
23492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23494 if (!SWIG_IsOK(res1)) {
23495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23496 }
23497 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23498 ecode2 = SWIG_AsVal_int(obj1, &val2);
23499 if (!SWIG_IsOK(ecode2)) {
23500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23501 }
23502 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23503 if (obj2) {
23504 ecode3 = SWIG_AsVal_int(obj2, &val3);
23505 if (!SWIG_IsOK(ecode3)) {
23506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23507 }
23508 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23509 }
23510 {
23511 PyThreadState* __tstate = wxPyBeginAllowThreads();
23512 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
23513 wxPyEndAllowThreads(__tstate);
23514 if (PyErr_Occurred()) SWIG_fail;
23515 }
23516 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23517 return resultobj;
23518 fail:
23519 return NULL;
23520 }
23521
23522
23523 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23524 PyObject *resultobj = 0;
23525 wxDateTime *arg1 = (wxDateTime *) 0 ;
23526 wxDateTime::WeekDay arg2 ;
23527 wxDateTime *result = 0 ;
23528 void *argp1 = 0 ;
23529 int res1 = 0 ;
23530 int val2 ;
23531 int ecode2 = 0 ;
23532 PyObject * obj0 = 0 ;
23533 PyObject * obj1 = 0 ;
23534 char * kwnames[] = {
23535 (char *) "self",(char *) "weekday", NULL
23536 };
23537
23538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23540 if (!SWIG_IsOK(res1)) {
23541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23542 }
23543 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23544 ecode2 = SWIG_AsVal_int(obj1, &val2);
23545 if (!SWIG_IsOK(ecode2)) {
23546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23547 }
23548 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23549 {
23550 PyThreadState* __tstate = wxPyBeginAllowThreads();
23551 {
23552 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
23553 result = (wxDateTime *) &_result_ref;
23554 }
23555 wxPyEndAllowThreads(__tstate);
23556 if (PyErr_Occurred()) SWIG_fail;
23557 }
23558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23559 return resultobj;
23560 fail:
23561 return NULL;
23562 }
23563
23564
23565 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23566 PyObject *resultobj = 0;
23567 wxDateTime *arg1 = (wxDateTime *) 0 ;
23568 wxDateTime::WeekDay arg2 ;
23569 wxDateTime result;
23570 void *argp1 = 0 ;
23571 int res1 = 0 ;
23572 int val2 ;
23573 int ecode2 = 0 ;
23574 PyObject * obj0 = 0 ;
23575 PyObject * obj1 = 0 ;
23576 char * kwnames[] = {
23577 (char *) "self",(char *) "weekday", NULL
23578 };
23579
23580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23582 if (!SWIG_IsOK(res1)) {
23583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23584 }
23585 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23586 ecode2 = SWIG_AsVal_int(obj1, &val2);
23587 if (!SWIG_IsOK(ecode2)) {
23588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23589 }
23590 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23591 {
23592 PyThreadState* __tstate = wxPyBeginAllowThreads();
23593 result = (arg1)->GetNextWeekDay(arg2);
23594 wxPyEndAllowThreads(__tstate);
23595 if (PyErr_Occurred()) SWIG_fail;
23596 }
23597 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23598 return resultobj;
23599 fail:
23600 return NULL;
23601 }
23602
23603
23604 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23605 PyObject *resultobj = 0;
23606 wxDateTime *arg1 = (wxDateTime *) 0 ;
23607 wxDateTime::WeekDay arg2 ;
23608 wxDateTime *result = 0 ;
23609 void *argp1 = 0 ;
23610 int res1 = 0 ;
23611 int val2 ;
23612 int ecode2 = 0 ;
23613 PyObject * obj0 = 0 ;
23614 PyObject * obj1 = 0 ;
23615 char * kwnames[] = {
23616 (char *) "self",(char *) "weekday", NULL
23617 };
23618
23619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23621 if (!SWIG_IsOK(res1)) {
23622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23623 }
23624 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23625 ecode2 = SWIG_AsVal_int(obj1, &val2);
23626 if (!SWIG_IsOK(ecode2)) {
23627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23628 }
23629 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23630 {
23631 PyThreadState* __tstate = wxPyBeginAllowThreads();
23632 {
23633 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
23634 result = (wxDateTime *) &_result_ref;
23635 }
23636 wxPyEndAllowThreads(__tstate);
23637 if (PyErr_Occurred()) SWIG_fail;
23638 }
23639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23640 return resultobj;
23641 fail:
23642 return NULL;
23643 }
23644
23645
23646 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23647 PyObject *resultobj = 0;
23648 wxDateTime *arg1 = (wxDateTime *) 0 ;
23649 wxDateTime::WeekDay arg2 ;
23650 wxDateTime result;
23651 void *argp1 = 0 ;
23652 int res1 = 0 ;
23653 int val2 ;
23654 int ecode2 = 0 ;
23655 PyObject * obj0 = 0 ;
23656 PyObject * obj1 = 0 ;
23657 char * kwnames[] = {
23658 (char *) "self",(char *) "weekday", NULL
23659 };
23660
23661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23663 if (!SWIG_IsOK(res1)) {
23664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23665 }
23666 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23667 ecode2 = SWIG_AsVal_int(obj1, &val2);
23668 if (!SWIG_IsOK(ecode2)) {
23669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23670 }
23671 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23672 {
23673 PyThreadState* __tstate = wxPyBeginAllowThreads();
23674 result = (arg1)->GetPrevWeekDay(arg2);
23675 wxPyEndAllowThreads(__tstate);
23676 if (PyErr_Occurred()) SWIG_fail;
23677 }
23678 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23679 return resultobj;
23680 fail:
23681 return NULL;
23682 }
23683
23684
23685 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23686 PyObject *resultobj = 0;
23687 wxDateTime *arg1 = (wxDateTime *) 0 ;
23688 wxDateTime::WeekDay arg2 ;
23689 int arg3 = (int) 1 ;
23690 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23691 int arg5 = (int) wxDateTime::Inv_Year ;
23692 bool result;
23693 void *argp1 = 0 ;
23694 int res1 = 0 ;
23695 int val2 ;
23696 int ecode2 = 0 ;
23697 int val3 ;
23698 int ecode3 = 0 ;
23699 int val4 ;
23700 int ecode4 = 0 ;
23701 int val5 ;
23702 int ecode5 = 0 ;
23703 PyObject * obj0 = 0 ;
23704 PyObject * obj1 = 0 ;
23705 PyObject * obj2 = 0 ;
23706 PyObject * obj3 = 0 ;
23707 PyObject * obj4 = 0 ;
23708 char * kwnames[] = {
23709 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
23710 };
23711
23712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23714 if (!SWIG_IsOK(res1)) {
23715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23716 }
23717 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23718 ecode2 = SWIG_AsVal_int(obj1, &val2);
23719 if (!SWIG_IsOK(ecode2)) {
23720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23721 }
23722 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23723 if (obj2) {
23724 ecode3 = SWIG_AsVal_int(obj2, &val3);
23725 if (!SWIG_IsOK(ecode3)) {
23726 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
23727 }
23728 arg3 = static_cast< int >(val3);
23729 }
23730 if (obj3) {
23731 ecode4 = SWIG_AsVal_int(obj3, &val4);
23732 if (!SWIG_IsOK(ecode4)) {
23733 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
23734 }
23735 arg4 = static_cast< wxDateTime::Month >(val4);
23736 }
23737 if (obj4) {
23738 ecode5 = SWIG_AsVal_int(obj4, &val5);
23739 if (!SWIG_IsOK(ecode5)) {
23740 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
23741 }
23742 arg5 = static_cast< int >(val5);
23743 }
23744 {
23745 PyThreadState* __tstate = wxPyBeginAllowThreads();
23746 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
23747 wxPyEndAllowThreads(__tstate);
23748 if (PyErr_Occurred()) SWIG_fail;
23749 }
23750 {
23751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23752 }
23753 return resultobj;
23754 fail:
23755 return NULL;
23756 }
23757
23758
23759 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23760 PyObject *resultobj = 0;
23761 wxDateTime *arg1 = (wxDateTime *) 0 ;
23762 wxDateTime::WeekDay arg2 ;
23763 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23764 int arg4 = (int) wxDateTime::Inv_Year ;
23765 bool result;
23766 void *argp1 = 0 ;
23767 int res1 = 0 ;
23768 int val2 ;
23769 int ecode2 = 0 ;
23770 int val3 ;
23771 int ecode3 = 0 ;
23772 int val4 ;
23773 int ecode4 = 0 ;
23774 PyObject * obj0 = 0 ;
23775 PyObject * obj1 = 0 ;
23776 PyObject * obj2 = 0 ;
23777 PyObject * obj3 = 0 ;
23778 char * kwnames[] = {
23779 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23780 };
23781
23782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23784 if (!SWIG_IsOK(res1)) {
23785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23786 }
23787 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23788 ecode2 = SWIG_AsVal_int(obj1, &val2);
23789 if (!SWIG_IsOK(ecode2)) {
23790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23791 }
23792 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23793 if (obj2) {
23794 ecode3 = SWIG_AsVal_int(obj2, &val3);
23795 if (!SWIG_IsOK(ecode3)) {
23796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23797 }
23798 arg3 = static_cast< wxDateTime::Month >(val3);
23799 }
23800 if (obj3) {
23801 ecode4 = SWIG_AsVal_int(obj3, &val4);
23802 if (!SWIG_IsOK(ecode4)) {
23803 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23804 }
23805 arg4 = static_cast< int >(val4);
23806 }
23807 {
23808 PyThreadState* __tstate = wxPyBeginAllowThreads();
23809 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
23810 wxPyEndAllowThreads(__tstate);
23811 if (PyErr_Occurred()) SWIG_fail;
23812 }
23813 {
23814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23815 }
23816 return resultobj;
23817 fail:
23818 return NULL;
23819 }
23820
23821
23822 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23823 PyObject *resultobj = 0;
23824 wxDateTime *arg1 = (wxDateTime *) 0 ;
23825 wxDateTime::WeekDay arg2 ;
23826 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23827 int arg4 = (int) wxDateTime::Inv_Year ;
23828 wxDateTime result;
23829 void *argp1 = 0 ;
23830 int res1 = 0 ;
23831 int val2 ;
23832 int ecode2 = 0 ;
23833 int val3 ;
23834 int ecode3 = 0 ;
23835 int val4 ;
23836 int ecode4 = 0 ;
23837 PyObject * obj0 = 0 ;
23838 PyObject * obj1 = 0 ;
23839 PyObject * obj2 = 0 ;
23840 PyObject * obj3 = 0 ;
23841 char * kwnames[] = {
23842 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23843 };
23844
23845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23847 if (!SWIG_IsOK(res1)) {
23848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23849 }
23850 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23851 ecode2 = SWIG_AsVal_int(obj1, &val2);
23852 if (!SWIG_IsOK(ecode2)) {
23853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23854 }
23855 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23856 if (obj2) {
23857 ecode3 = SWIG_AsVal_int(obj2, &val3);
23858 if (!SWIG_IsOK(ecode3)) {
23859 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23860 }
23861 arg3 = static_cast< wxDateTime::Month >(val3);
23862 }
23863 if (obj3) {
23864 ecode4 = SWIG_AsVal_int(obj3, &val4);
23865 if (!SWIG_IsOK(ecode4)) {
23866 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23867 }
23868 arg4 = static_cast< int >(val4);
23869 }
23870 {
23871 PyThreadState* __tstate = wxPyBeginAllowThreads();
23872 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
23873 wxPyEndAllowThreads(__tstate);
23874 if (PyErr_Occurred()) SWIG_fail;
23875 }
23876 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23877 return resultobj;
23878 fail:
23879 return NULL;
23880 }
23881
23882
23883 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23884 PyObject *resultobj = 0;
23885 wxDateTime *arg1 = (wxDateTime *) 0 ;
23886 int arg2 ;
23887 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23888 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23889 bool result;
23890 void *argp1 = 0 ;
23891 int res1 = 0 ;
23892 int val2 ;
23893 int ecode2 = 0 ;
23894 int val3 ;
23895 int ecode3 = 0 ;
23896 int val4 ;
23897 int ecode4 = 0 ;
23898 PyObject * obj0 = 0 ;
23899 PyObject * obj1 = 0 ;
23900 PyObject * obj2 = 0 ;
23901 PyObject * obj3 = 0 ;
23902 char * kwnames[] = {
23903 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23904 };
23905
23906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23908 if (!SWIG_IsOK(res1)) {
23909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23910 }
23911 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23912 ecode2 = SWIG_AsVal_int(obj1, &val2);
23913 if (!SWIG_IsOK(ecode2)) {
23914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
23915 }
23916 arg2 = static_cast< int >(val2);
23917 if (obj2) {
23918 ecode3 = SWIG_AsVal_int(obj2, &val3);
23919 if (!SWIG_IsOK(ecode3)) {
23920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23921 }
23922 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23923 }
23924 if (obj3) {
23925 ecode4 = SWIG_AsVal_int(obj3, &val4);
23926 if (!SWIG_IsOK(ecode4)) {
23927 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23928 }
23929 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23930 }
23931 {
23932 PyThreadState* __tstate = wxPyBeginAllowThreads();
23933 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
23934 wxPyEndAllowThreads(__tstate);
23935 if (PyErr_Occurred()) SWIG_fail;
23936 }
23937 {
23938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23939 }
23940 return resultobj;
23941 fail:
23942 return NULL;
23943 }
23944
23945
23946 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23947 PyObject *resultobj = 0;
23948 wxDateTime *arg1 = (wxDateTime *) 0 ;
23949 int arg2 ;
23950 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23951 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23952 wxDateTime result;
23953 void *argp1 = 0 ;
23954 int res1 = 0 ;
23955 int val2 ;
23956 int ecode2 = 0 ;
23957 int val3 ;
23958 int ecode3 = 0 ;
23959 int val4 ;
23960 int ecode4 = 0 ;
23961 PyObject * obj0 = 0 ;
23962 PyObject * obj1 = 0 ;
23963 PyObject * obj2 = 0 ;
23964 PyObject * obj3 = 0 ;
23965 char * kwnames[] = {
23966 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23967 };
23968
23969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23971 if (!SWIG_IsOK(res1)) {
23972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23973 }
23974 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23975 ecode2 = SWIG_AsVal_int(obj1, &val2);
23976 if (!SWIG_IsOK(ecode2)) {
23977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
23978 }
23979 arg2 = static_cast< int >(val2);
23980 if (obj2) {
23981 ecode3 = SWIG_AsVal_int(obj2, &val3);
23982 if (!SWIG_IsOK(ecode3)) {
23983 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23984 }
23985 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23986 }
23987 if (obj3) {
23988 ecode4 = SWIG_AsVal_int(obj3, &val4);
23989 if (!SWIG_IsOK(ecode4)) {
23990 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23991 }
23992 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23993 }
23994 {
23995 PyThreadState* __tstate = wxPyBeginAllowThreads();
23996 result = (arg1)->GetWeek(arg2,arg3,arg4);
23997 wxPyEndAllowThreads(__tstate);
23998 if (PyErr_Occurred()) SWIG_fail;
23999 }
24000 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24001 return resultobj;
24002 fail:
24003 return NULL;
24004 }
24005
24006
24007 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24008 PyObject *resultobj = 0;
24009 int arg1 ;
24010 int arg2 ;
24011 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24012 wxDateTime result;
24013 int val1 ;
24014 int ecode1 = 0 ;
24015 int val2 ;
24016 int ecode2 = 0 ;
24017 int val3 ;
24018 int ecode3 = 0 ;
24019 PyObject * obj0 = 0 ;
24020 PyObject * obj1 = 0 ;
24021 PyObject * obj2 = 0 ;
24022 char * kwnames[] = {
24023 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
24024 };
24025
24026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24027 ecode1 = SWIG_AsVal_int(obj0, &val1);
24028 if (!SWIG_IsOK(ecode1)) {
24029 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
24030 }
24031 arg1 = static_cast< int >(val1);
24032 ecode2 = SWIG_AsVal_int(obj1, &val2);
24033 if (!SWIG_IsOK(ecode2)) {
24034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
24035 }
24036 arg2 = static_cast< int >(val2);
24037 if (obj2) {
24038 ecode3 = SWIG_AsVal_int(obj2, &val3);
24039 if (!SWIG_IsOK(ecode3)) {
24040 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24041 }
24042 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24043 }
24044 {
24045 PyThreadState* __tstate = wxPyBeginAllowThreads();
24046 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
24047 wxPyEndAllowThreads(__tstate);
24048 if (PyErr_Occurred()) SWIG_fail;
24049 }
24050 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24051 return resultobj;
24052 fail:
24053 return NULL;
24054 }
24055
24056
24057 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24058 PyObject *resultobj = 0;
24059 wxDateTime *arg1 = (wxDateTime *) 0 ;
24060 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24061 int arg3 = (int) wxDateTime::Inv_Year ;
24062 wxDateTime *result = 0 ;
24063 void *argp1 = 0 ;
24064 int res1 = 0 ;
24065 int val2 ;
24066 int ecode2 = 0 ;
24067 int val3 ;
24068 int ecode3 = 0 ;
24069 PyObject * obj0 = 0 ;
24070 PyObject * obj1 = 0 ;
24071 PyObject * obj2 = 0 ;
24072 char * kwnames[] = {
24073 (char *) "self",(char *) "month",(char *) "year", NULL
24074 };
24075
24076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24078 if (!SWIG_IsOK(res1)) {
24079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24080 }
24081 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24082 if (obj1) {
24083 ecode2 = SWIG_AsVal_int(obj1, &val2);
24084 if (!SWIG_IsOK(ecode2)) {
24085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24086 }
24087 arg2 = static_cast< wxDateTime::Month >(val2);
24088 }
24089 if (obj2) {
24090 ecode3 = SWIG_AsVal_int(obj2, &val3);
24091 if (!SWIG_IsOK(ecode3)) {
24092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24093 }
24094 arg3 = static_cast< int >(val3);
24095 }
24096 {
24097 PyThreadState* __tstate = wxPyBeginAllowThreads();
24098 {
24099 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
24100 result = (wxDateTime *) &_result_ref;
24101 }
24102 wxPyEndAllowThreads(__tstate);
24103 if (PyErr_Occurred()) SWIG_fail;
24104 }
24105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24106 return resultobj;
24107 fail:
24108 return NULL;
24109 }
24110
24111
24112 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24113 PyObject *resultobj = 0;
24114 wxDateTime *arg1 = (wxDateTime *) 0 ;
24115 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24116 int arg3 = (int) wxDateTime::Inv_Year ;
24117 wxDateTime result;
24118 void *argp1 = 0 ;
24119 int res1 = 0 ;
24120 int val2 ;
24121 int ecode2 = 0 ;
24122 int val3 ;
24123 int ecode3 = 0 ;
24124 PyObject * obj0 = 0 ;
24125 PyObject * obj1 = 0 ;
24126 PyObject * obj2 = 0 ;
24127 char * kwnames[] = {
24128 (char *) "self",(char *) "month",(char *) "year", NULL
24129 };
24130
24131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24133 if (!SWIG_IsOK(res1)) {
24134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24135 }
24136 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24137 if (obj1) {
24138 ecode2 = SWIG_AsVal_int(obj1, &val2);
24139 if (!SWIG_IsOK(ecode2)) {
24140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24141 }
24142 arg2 = static_cast< wxDateTime::Month >(val2);
24143 }
24144 if (obj2) {
24145 ecode3 = SWIG_AsVal_int(obj2, &val3);
24146 if (!SWIG_IsOK(ecode3)) {
24147 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24148 }
24149 arg3 = static_cast< int >(val3);
24150 }
24151 {
24152 PyThreadState* __tstate = wxPyBeginAllowThreads();
24153 result = (arg1)->GetLastMonthDay(arg2,arg3);
24154 wxPyEndAllowThreads(__tstate);
24155 if (PyErr_Occurred()) SWIG_fail;
24156 }
24157 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24158 return resultobj;
24159 fail:
24160 return NULL;
24161 }
24162
24163
24164 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24165 PyObject *resultobj = 0;
24166 wxDateTime *arg1 = (wxDateTime *) 0 ;
24167 int arg2 ;
24168 wxDateTime *result = 0 ;
24169 void *argp1 = 0 ;
24170 int res1 = 0 ;
24171 int val2 ;
24172 int ecode2 = 0 ;
24173 PyObject * obj0 = 0 ;
24174 PyObject * obj1 = 0 ;
24175 char * kwnames[] = {
24176 (char *) "self",(char *) "yday", NULL
24177 };
24178
24179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24181 if (!SWIG_IsOK(res1)) {
24182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24183 }
24184 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24185 ecode2 = SWIG_AsVal_int(obj1, &val2);
24186 if (!SWIG_IsOK(ecode2)) {
24187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
24188 }
24189 arg2 = static_cast< int >(val2);
24190 {
24191 PyThreadState* __tstate = wxPyBeginAllowThreads();
24192 {
24193 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
24194 result = (wxDateTime *) &_result_ref;
24195 }
24196 wxPyEndAllowThreads(__tstate);
24197 if (PyErr_Occurred()) SWIG_fail;
24198 }
24199 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24200 return resultobj;
24201 fail:
24202 return NULL;
24203 }
24204
24205
24206 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24207 PyObject *resultobj = 0;
24208 wxDateTime *arg1 = (wxDateTime *) 0 ;
24209 int arg2 ;
24210 wxDateTime result;
24211 void *argp1 = 0 ;
24212 int res1 = 0 ;
24213 int val2 ;
24214 int ecode2 = 0 ;
24215 PyObject * obj0 = 0 ;
24216 PyObject * obj1 = 0 ;
24217 char * kwnames[] = {
24218 (char *) "self",(char *) "yday", NULL
24219 };
24220
24221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24223 if (!SWIG_IsOK(res1)) {
24224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24225 }
24226 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24227 ecode2 = SWIG_AsVal_int(obj1, &val2);
24228 if (!SWIG_IsOK(ecode2)) {
24229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
24230 }
24231 arg2 = static_cast< int >(val2);
24232 {
24233 PyThreadState* __tstate = wxPyBeginAllowThreads();
24234 result = (arg1)->GetYearDay(arg2);
24235 wxPyEndAllowThreads(__tstate);
24236 if (PyErr_Occurred()) SWIG_fail;
24237 }
24238 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24239 return resultobj;
24240 fail:
24241 return NULL;
24242 }
24243
24244
24245 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24246 PyObject *resultobj = 0;
24247 wxDateTime *arg1 = (wxDateTime *) 0 ;
24248 double result;
24249 void *argp1 = 0 ;
24250 int res1 = 0 ;
24251 PyObject *swig_obj[1] ;
24252
24253 if (!args) SWIG_fail;
24254 swig_obj[0] = args;
24255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24256 if (!SWIG_IsOK(res1)) {
24257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
24258 }
24259 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24260 {
24261 PyThreadState* __tstate = wxPyBeginAllowThreads();
24262 result = (double)(arg1)->GetJulianDayNumber();
24263 wxPyEndAllowThreads(__tstate);
24264 if (PyErr_Occurred()) SWIG_fail;
24265 }
24266 resultobj = SWIG_From_double(static_cast< double >(result));
24267 return resultobj;
24268 fail:
24269 return NULL;
24270 }
24271
24272
24273 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24274 PyObject *resultobj = 0;
24275 wxDateTime *arg1 = (wxDateTime *) 0 ;
24276 double result;
24277 void *argp1 = 0 ;
24278 int res1 = 0 ;
24279 PyObject *swig_obj[1] ;
24280
24281 if (!args) SWIG_fail;
24282 swig_obj[0] = args;
24283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24284 if (!SWIG_IsOK(res1)) {
24285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24286 }
24287 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24288 {
24289 PyThreadState* __tstate = wxPyBeginAllowThreads();
24290 result = (double)(arg1)->GetJDN();
24291 wxPyEndAllowThreads(__tstate);
24292 if (PyErr_Occurred()) SWIG_fail;
24293 }
24294 resultobj = SWIG_From_double(static_cast< double >(result));
24295 return resultobj;
24296 fail:
24297 return NULL;
24298 }
24299
24300
24301 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24302 PyObject *resultobj = 0;
24303 wxDateTime *arg1 = (wxDateTime *) 0 ;
24304 double result;
24305 void *argp1 = 0 ;
24306 int res1 = 0 ;
24307 PyObject *swig_obj[1] ;
24308
24309 if (!args) SWIG_fail;
24310 swig_obj[0] = args;
24311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24312 if (!SWIG_IsOK(res1)) {
24313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24314 }
24315 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24316 {
24317 PyThreadState* __tstate = wxPyBeginAllowThreads();
24318 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
24319 wxPyEndAllowThreads(__tstate);
24320 if (PyErr_Occurred()) SWIG_fail;
24321 }
24322 resultobj = SWIG_From_double(static_cast< double >(result));
24323 return resultobj;
24324 fail:
24325 return NULL;
24326 }
24327
24328
24329 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24330 PyObject *resultobj = 0;
24331 wxDateTime *arg1 = (wxDateTime *) 0 ;
24332 double result;
24333 void *argp1 = 0 ;
24334 int res1 = 0 ;
24335 PyObject *swig_obj[1] ;
24336
24337 if (!args) SWIG_fail;
24338 swig_obj[0] = args;
24339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24340 if (!SWIG_IsOK(res1)) {
24341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
24342 }
24343 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24344 {
24345 PyThreadState* __tstate = wxPyBeginAllowThreads();
24346 result = (double)(arg1)->GetMJD();
24347 wxPyEndAllowThreads(__tstate);
24348 if (PyErr_Occurred()) SWIG_fail;
24349 }
24350 resultobj = SWIG_From_double(static_cast< double >(result));
24351 return resultobj;
24352 fail:
24353 return NULL;
24354 }
24355
24356
24357 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24358 PyObject *resultobj = 0;
24359 wxDateTime *arg1 = (wxDateTime *) 0 ;
24360 double result;
24361 void *argp1 = 0 ;
24362 int res1 = 0 ;
24363 PyObject *swig_obj[1] ;
24364
24365 if (!args) SWIG_fail;
24366 swig_obj[0] = args;
24367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24368 if (!SWIG_IsOK(res1)) {
24369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
24370 }
24371 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24372 {
24373 PyThreadState* __tstate = wxPyBeginAllowThreads();
24374 result = (double)(arg1)->GetRataDie();
24375 wxPyEndAllowThreads(__tstate);
24376 if (PyErr_Occurred()) SWIG_fail;
24377 }
24378 resultobj = SWIG_From_double(static_cast< double >(result));
24379 return resultobj;
24380 fail:
24381 return NULL;
24382 }
24383
24384
24385 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24386 PyObject *resultobj = 0;
24387 wxDateTime *arg1 = (wxDateTime *) 0 ;
24388 wxDateTime::TimeZone *arg2 = 0 ;
24389 bool arg3 = (bool) false ;
24390 wxDateTime result;
24391 void *argp1 = 0 ;
24392 int res1 = 0 ;
24393 bool temp2 = false ;
24394 bool val3 ;
24395 int ecode3 = 0 ;
24396 PyObject * obj0 = 0 ;
24397 PyObject * obj1 = 0 ;
24398 PyObject * obj2 = 0 ;
24399 char * kwnames[] = {
24400 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24401 };
24402
24403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24405 if (!SWIG_IsOK(res1)) {
24406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24407 }
24408 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24409 {
24410 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24411 temp2 = true;
24412 }
24413 if (obj2) {
24414 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24415 if (!SWIG_IsOK(ecode3)) {
24416 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
24417 }
24418 arg3 = static_cast< bool >(val3);
24419 }
24420 {
24421 PyThreadState* __tstate = wxPyBeginAllowThreads();
24422 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24423 wxPyEndAllowThreads(__tstate);
24424 if (PyErr_Occurred()) SWIG_fail;
24425 }
24426 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24427 {
24428 if (temp2) delete arg2;
24429 }
24430 return resultobj;
24431 fail:
24432 {
24433 if (temp2) delete arg2;
24434 }
24435 return NULL;
24436 }
24437
24438
24439 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24440 PyObject *resultobj = 0;
24441 wxDateTime *arg1 = (wxDateTime *) 0 ;
24442 wxDateTime::TimeZone *arg2 = 0 ;
24443 bool arg3 = (bool) false ;
24444 wxDateTime *result = 0 ;
24445 void *argp1 = 0 ;
24446 int res1 = 0 ;
24447 bool temp2 = false ;
24448 bool val3 ;
24449 int ecode3 = 0 ;
24450 PyObject * obj0 = 0 ;
24451 PyObject * obj1 = 0 ;
24452 PyObject * obj2 = 0 ;
24453 char * kwnames[] = {
24454 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24455 };
24456
24457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24459 if (!SWIG_IsOK(res1)) {
24460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24461 }
24462 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24463 {
24464 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24465 temp2 = true;
24466 }
24467 if (obj2) {
24468 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24469 if (!SWIG_IsOK(ecode3)) {
24470 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
24471 }
24472 arg3 = static_cast< bool >(val3);
24473 }
24474 {
24475 PyThreadState* __tstate = wxPyBeginAllowThreads();
24476 {
24477 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24478 result = (wxDateTime *) &_result_ref;
24479 }
24480 wxPyEndAllowThreads(__tstate);
24481 if (PyErr_Occurred()) SWIG_fail;
24482 }
24483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24484 {
24485 if (temp2) delete arg2;
24486 }
24487 return resultobj;
24488 fail:
24489 {
24490 if (temp2) delete arg2;
24491 }
24492 return NULL;
24493 }
24494
24495
24496 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24497 PyObject *resultobj = 0;
24498 wxDateTime *arg1 = (wxDateTime *) 0 ;
24499 wxDateTime::TimeZone *arg2 = 0 ;
24500 bool arg3 = (bool) false ;
24501 wxDateTime result;
24502 void *argp1 = 0 ;
24503 int res1 = 0 ;
24504 bool temp2 = false ;
24505 bool val3 ;
24506 int ecode3 = 0 ;
24507 PyObject * obj0 = 0 ;
24508 PyObject * obj1 = 0 ;
24509 PyObject * obj2 = 0 ;
24510 char * kwnames[] = {
24511 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24512 };
24513
24514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24516 if (!SWIG_IsOK(res1)) {
24517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24518 }
24519 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24520 {
24521 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24522 temp2 = true;
24523 }
24524 if (obj2) {
24525 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24526 if (!SWIG_IsOK(ecode3)) {
24527 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
24528 }
24529 arg3 = static_cast< bool >(val3);
24530 }
24531 {
24532 PyThreadState* __tstate = wxPyBeginAllowThreads();
24533 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24534 wxPyEndAllowThreads(__tstate);
24535 if (PyErr_Occurred()) SWIG_fail;
24536 }
24537 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24538 {
24539 if (temp2) delete arg2;
24540 }
24541 return resultobj;
24542 fail:
24543 {
24544 if (temp2) delete arg2;
24545 }
24546 return NULL;
24547 }
24548
24549
24550 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24551 PyObject *resultobj = 0;
24552 wxDateTime *arg1 = (wxDateTime *) 0 ;
24553 wxDateTime::TimeZone *arg2 = 0 ;
24554 bool arg3 = (bool) false ;
24555 wxDateTime *result = 0 ;
24556 void *argp1 = 0 ;
24557 int res1 = 0 ;
24558 bool temp2 = false ;
24559 bool val3 ;
24560 int ecode3 = 0 ;
24561 PyObject * obj0 = 0 ;
24562 PyObject * obj1 = 0 ;
24563 PyObject * obj2 = 0 ;
24564 char * kwnames[] = {
24565 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24566 };
24567
24568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24570 if (!SWIG_IsOK(res1)) {
24571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24572 }
24573 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24574 {
24575 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24576 temp2 = true;
24577 }
24578 if (obj2) {
24579 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24580 if (!SWIG_IsOK(ecode3)) {
24581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
24582 }
24583 arg3 = static_cast< bool >(val3);
24584 }
24585 {
24586 PyThreadState* __tstate = wxPyBeginAllowThreads();
24587 {
24588 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24589 result = (wxDateTime *) &_result_ref;
24590 }
24591 wxPyEndAllowThreads(__tstate);
24592 if (PyErr_Occurred()) SWIG_fail;
24593 }
24594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24595 {
24596 if (temp2) delete arg2;
24597 }
24598 return resultobj;
24599 fail:
24600 {
24601 if (temp2) delete arg2;
24602 }
24603 return NULL;
24604 }
24605
24606
24607 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24608 PyObject *resultobj = 0;
24609 wxDateTime *arg1 = (wxDateTime *) 0 ;
24610 bool arg2 = (bool) false ;
24611 wxDateTime result;
24612 void *argp1 = 0 ;
24613 int res1 = 0 ;
24614 bool val2 ;
24615 int ecode2 = 0 ;
24616 PyObject * obj0 = 0 ;
24617 PyObject * obj1 = 0 ;
24618 char * kwnames[] = {
24619 (char *) "self",(char *) "noDST", NULL
24620 };
24621
24622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24624 if (!SWIG_IsOK(res1)) {
24625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24626 }
24627 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24628 if (obj1) {
24629 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24630 if (!SWIG_IsOK(ecode2)) {
24631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
24632 }
24633 arg2 = static_cast< bool >(val2);
24634 }
24635 {
24636 PyThreadState* __tstate = wxPyBeginAllowThreads();
24637 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
24638 wxPyEndAllowThreads(__tstate);
24639 if (PyErr_Occurred()) SWIG_fail;
24640 }
24641 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24642 return resultobj;
24643 fail:
24644 return NULL;
24645 }
24646
24647
24648 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24649 PyObject *resultobj = 0;
24650 wxDateTime *arg1 = (wxDateTime *) 0 ;
24651 bool arg2 = (bool) false ;
24652 wxDateTime *result = 0 ;
24653 void *argp1 = 0 ;
24654 int res1 = 0 ;
24655 bool val2 ;
24656 int ecode2 = 0 ;
24657 PyObject * obj0 = 0 ;
24658 PyObject * obj1 = 0 ;
24659 char * kwnames[] = {
24660 (char *) "self",(char *) "noDST", NULL
24661 };
24662
24663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24665 if (!SWIG_IsOK(res1)) {
24666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24667 }
24668 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24669 if (obj1) {
24670 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24671 if (!SWIG_IsOK(ecode2)) {
24672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
24673 }
24674 arg2 = static_cast< bool >(val2);
24675 }
24676 {
24677 PyThreadState* __tstate = wxPyBeginAllowThreads();
24678 {
24679 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
24680 result = (wxDateTime *) &_result_ref;
24681 }
24682 wxPyEndAllowThreads(__tstate);
24683 if (PyErr_Occurred()) SWIG_fail;
24684 }
24685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24686 return resultobj;
24687 fail:
24688 return NULL;
24689 }
24690
24691
24692 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24693 PyObject *resultobj = 0;
24694 wxDateTime *arg1 = (wxDateTime *) 0 ;
24695 bool arg2 = (bool) false ;
24696 wxDateTime result;
24697 void *argp1 = 0 ;
24698 int res1 = 0 ;
24699 bool val2 ;
24700 int ecode2 = 0 ;
24701 PyObject * obj0 = 0 ;
24702 PyObject * obj1 = 0 ;
24703 char * kwnames[] = {
24704 (char *) "self",(char *) "noDST", NULL
24705 };
24706
24707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24709 if (!SWIG_IsOK(res1)) {
24710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24711 }
24712 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24713 if (obj1) {
24714 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24715 if (!SWIG_IsOK(ecode2)) {
24716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
24717 }
24718 arg2 = static_cast< bool >(val2);
24719 }
24720 {
24721 PyThreadState* __tstate = wxPyBeginAllowThreads();
24722 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
24723 wxPyEndAllowThreads(__tstate);
24724 if (PyErr_Occurred()) SWIG_fail;
24725 }
24726 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24727 return resultobj;
24728 fail:
24729 return NULL;
24730 }
24731
24732
24733 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24734 PyObject *resultobj = 0;
24735 wxDateTime *arg1 = (wxDateTime *) 0 ;
24736 bool arg2 = (bool) false ;
24737 wxDateTime *result = 0 ;
24738 void *argp1 = 0 ;
24739 int res1 = 0 ;
24740 bool val2 ;
24741 int ecode2 = 0 ;
24742 PyObject * obj0 = 0 ;
24743 PyObject * obj1 = 0 ;
24744 char * kwnames[] = {
24745 (char *) "self",(char *) "noDST", NULL
24746 };
24747
24748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24750 if (!SWIG_IsOK(res1)) {
24751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24752 }
24753 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24754 if (obj1) {
24755 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24756 if (!SWIG_IsOK(ecode2)) {
24757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
24758 }
24759 arg2 = static_cast< bool >(val2);
24760 }
24761 {
24762 PyThreadState* __tstate = wxPyBeginAllowThreads();
24763 {
24764 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
24765 result = (wxDateTime *) &_result_ref;
24766 }
24767 wxPyEndAllowThreads(__tstate);
24768 if (PyErr_Occurred()) SWIG_fail;
24769 }
24770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24771 return resultobj;
24772 fail:
24773 return NULL;
24774 }
24775
24776
24777 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24778 PyObject *resultobj = 0;
24779 wxDateTime *arg1 = (wxDateTime *) 0 ;
24780 bool arg2 = (bool) false ;
24781 wxDateTime result;
24782 void *argp1 = 0 ;
24783 int res1 = 0 ;
24784 bool val2 ;
24785 int ecode2 = 0 ;
24786 PyObject * obj0 = 0 ;
24787 PyObject * obj1 = 0 ;
24788 char * kwnames[] = {
24789 (char *) "self",(char *) "noDST", NULL
24790 };
24791
24792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24794 if (!SWIG_IsOK(res1)) {
24795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24796 }
24797 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24798 if (obj1) {
24799 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24800 if (!SWIG_IsOK(ecode2)) {
24801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
24802 }
24803 arg2 = static_cast< bool >(val2);
24804 }
24805 {
24806 PyThreadState* __tstate = wxPyBeginAllowThreads();
24807 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
24808 wxPyEndAllowThreads(__tstate);
24809 if (PyErr_Occurred()) SWIG_fail;
24810 }
24811 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24812 return resultobj;
24813 fail:
24814 return NULL;
24815 }
24816
24817
24818 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24819 PyObject *resultobj = 0;
24820 wxDateTime *arg1 = (wxDateTime *) 0 ;
24821 bool arg2 = (bool) false ;
24822 wxDateTime *result = 0 ;
24823 void *argp1 = 0 ;
24824 int res1 = 0 ;
24825 bool val2 ;
24826 int ecode2 = 0 ;
24827 PyObject * obj0 = 0 ;
24828 PyObject * obj1 = 0 ;
24829 char * kwnames[] = {
24830 (char *) "self",(char *) "noDST", NULL
24831 };
24832
24833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24835 if (!SWIG_IsOK(res1)) {
24836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24837 }
24838 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24839 if (obj1) {
24840 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24841 if (!SWIG_IsOK(ecode2)) {
24842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
24843 }
24844 arg2 = static_cast< bool >(val2);
24845 }
24846 {
24847 PyThreadState* __tstate = wxPyBeginAllowThreads();
24848 {
24849 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
24850 result = (wxDateTime *) &_result_ref;
24851 }
24852 wxPyEndAllowThreads(__tstate);
24853 if (PyErr_Occurred()) SWIG_fail;
24854 }
24855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24856 return resultobj;
24857 fail:
24858 return NULL;
24859 }
24860
24861
24862 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24863 PyObject *resultobj = 0;
24864 wxDateTime *arg1 = (wxDateTime *) 0 ;
24865 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
24866 int result;
24867 void *argp1 = 0 ;
24868 int res1 = 0 ;
24869 int val2 ;
24870 int ecode2 = 0 ;
24871 PyObject * obj0 = 0 ;
24872 PyObject * obj1 = 0 ;
24873 char * kwnames[] = {
24874 (char *) "self",(char *) "country", NULL
24875 };
24876
24877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
24878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24879 if (!SWIG_IsOK(res1)) {
24880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
24881 }
24882 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24883 if (obj1) {
24884 ecode2 = SWIG_AsVal_int(obj1, &val2);
24885 if (!SWIG_IsOK(ecode2)) {
24886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
24887 }
24888 arg2 = static_cast< wxDateTime::Country >(val2);
24889 }
24890 {
24891 PyThreadState* __tstate = wxPyBeginAllowThreads();
24892 result = (int)(arg1)->IsDST(arg2);
24893 wxPyEndAllowThreads(__tstate);
24894 if (PyErr_Occurred()) SWIG_fail;
24895 }
24896 resultobj = SWIG_From_int(static_cast< int >(result));
24897 return resultobj;
24898 fail:
24899 return NULL;
24900 }
24901
24902
24903 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24904 PyObject *resultobj = 0;
24905 wxDateTime *arg1 = (wxDateTime *) 0 ;
24906 bool result;
24907 void *argp1 = 0 ;
24908 int res1 = 0 ;
24909 PyObject *swig_obj[1] ;
24910
24911 if (!args) SWIG_fail;
24912 swig_obj[0] = args;
24913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24914 if (!SWIG_IsOK(res1)) {
24915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24916 }
24917 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24918 {
24919 PyThreadState* __tstate = wxPyBeginAllowThreads();
24920 result = (bool)((wxDateTime const *)arg1)->IsValid();
24921 wxPyEndAllowThreads(__tstate);
24922 if (PyErr_Occurred()) SWIG_fail;
24923 }
24924 {
24925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24926 }
24927 return resultobj;
24928 fail:
24929 return NULL;
24930 }
24931
24932
24933 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24934 PyObject *resultobj = 0;
24935 wxDateTime *arg1 = (wxDateTime *) 0 ;
24936 time_t result;
24937 void *argp1 = 0 ;
24938 int res1 = 0 ;
24939 PyObject *swig_obj[1] ;
24940
24941 if (!args) SWIG_fail;
24942 swig_obj[0] = args;
24943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24944 if (!SWIG_IsOK(res1)) {
24945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24946 }
24947 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24948 {
24949 PyThreadState* __tstate = wxPyBeginAllowThreads();
24950 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
24951 wxPyEndAllowThreads(__tstate);
24952 if (PyErr_Occurred()) SWIG_fail;
24953 }
24954 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
24955 return resultobj;
24956 fail:
24957 return NULL;
24958 }
24959
24960
24961 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24962 PyObject *resultobj = 0;
24963 wxDateTime *arg1 = (wxDateTime *) 0 ;
24964 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24965 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24966 int result;
24967 void *argp1 = 0 ;
24968 int res1 = 0 ;
24969 bool temp2 = false ;
24970 PyObject * obj0 = 0 ;
24971 PyObject * obj1 = 0 ;
24972 char * kwnames[] = {
24973 (char *) "self",(char *) "tz", NULL
24974 };
24975
24976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24978 if (!SWIG_IsOK(res1)) {
24979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24980 }
24981 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24982 if (obj1) {
24983 {
24984 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24985 temp2 = true;
24986 }
24987 }
24988 {
24989 PyThreadState* __tstate = wxPyBeginAllowThreads();
24990 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
24991 wxPyEndAllowThreads(__tstate);
24992 if (PyErr_Occurred()) SWIG_fail;
24993 }
24994 resultobj = SWIG_From_int(static_cast< int >(result));
24995 {
24996 if (temp2) delete arg2;
24997 }
24998 return resultobj;
24999 fail:
25000 {
25001 if (temp2) delete arg2;
25002 }
25003 return NULL;
25004 }
25005
25006
25007 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25008 PyObject *resultobj = 0;
25009 wxDateTime *arg1 = (wxDateTime *) 0 ;
25010 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25011 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25012 wxDateTime::Month result;
25013 void *argp1 = 0 ;
25014 int res1 = 0 ;
25015 bool temp2 = false ;
25016 PyObject * obj0 = 0 ;
25017 PyObject * obj1 = 0 ;
25018 char * kwnames[] = {
25019 (char *) "self",(char *) "tz", NULL
25020 };
25021
25022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
25023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25024 if (!SWIG_IsOK(res1)) {
25025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25026 }
25027 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25028 if (obj1) {
25029 {
25030 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25031 temp2 = true;
25032 }
25033 }
25034 {
25035 PyThreadState* __tstate = wxPyBeginAllowThreads();
25036 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
25037 wxPyEndAllowThreads(__tstate);
25038 if (PyErr_Occurred()) SWIG_fail;
25039 }
25040 resultobj = SWIG_From_int(static_cast< int >(result));
25041 {
25042 if (temp2) delete arg2;
25043 }
25044 return resultobj;
25045 fail:
25046 {
25047 if (temp2) delete arg2;
25048 }
25049 return NULL;
25050 }
25051
25052
25053 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25054 PyObject *resultobj = 0;
25055 wxDateTime *arg1 = (wxDateTime *) 0 ;
25056 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25057 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25058 int result;
25059 void *argp1 = 0 ;
25060 int res1 = 0 ;
25061 bool temp2 = false ;
25062 PyObject * obj0 = 0 ;
25063 PyObject * obj1 = 0 ;
25064 char * kwnames[] = {
25065 (char *) "self",(char *) "tz", NULL
25066 };
25067
25068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
25069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25070 if (!SWIG_IsOK(res1)) {
25071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25072 }
25073 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25074 if (obj1) {
25075 {
25076 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25077 temp2 = true;
25078 }
25079 }
25080 {
25081 PyThreadState* __tstate = wxPyBeginAllowThreads();
25082 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
25083 wxPyEndAllowThreads(__tstate);
25084 if (PyErr_Occurred()) SWIG_fail;
25085 }
25086 resultobj = SWIG_From_int(static_cast< int >(result));
25087 {
25088 if (temp2) delete arg2;
25089 }
25090 return resultobj;
25091 fail:
25092 {
25093 if (temp2) delete arg2;
25094 }
25095 return NULL;
25096 }
25097
25098
25099 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25100 PyObject *resultobj = 0;
25101 wxDateTime *arg1 = (wxDateTime *) 0 ;
25102 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25103 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25104 wxDateTime::WeekDay result;
25105 void *argp1 = 0 ;
25106 int res1 = 0 ;
25107 bool temp2 = false ;
25108 PyObject * obj0 = 0 ;
25109 PyObject * obj1 = 0 ;
25110 char * kwnames[] = {
25111 (char *) "self",(char *) "tz", NULL
25112 };
25113
25114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25116 if (!SWIG_IsOK(res1)) {
25117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25118 }
25119 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25120 if (obj1) {
25121 {
25122 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25123 temp2 = true;
25124 }
25125 }
25126 {
25127 PyThreadState* __tstate = wxPyBeginAllowThreads();
25128 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
25129 wxPyEndAllowThreads(__tstate);
25130 if (PyErr_Occurred()) SWIG_fail;
25131 }
25132 resultobj = SWIG_From_int(static_cast< int >(result));
25133 {
25134 if (temp2) delete arg2;
25135 }
25136 return resultobj;
25137 fail:
25138 {
25139 if (temp2) delete arg2;
25140 }
25141 return NULL;
25142 }
25143
25144
25145 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25146 PyObject *resultobj = 0;
25147 wxDateTime *arg1 = (wxDateTime *) 0 ;
25148 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25149 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25150 int result;
25151 void *argp1 = 0 ;
25152 int res1 = 0 ;
25153 bool temp2 = false ;
25154 PyObject * obj0 = 0 ;
25155 PyObject * obj1 = 0 ;
25156 char * kwnames[] = {
25157 (char *) "self",(char *) "tz", NULL
25158 };
25159
25160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
25161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25162 if (!SWIG_IsOK(res1)) {
25163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25164 }
25165 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25166 if (obj1) {
25167 {
25168 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25169 temp2 = true;
25170 }
25171 }
25172 {
25173 PyThreadState* __tstate = wxPyBeginAllowThreads();
25174 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
25175 wxPyEndAllowThreads(__tstate);
25176 if (PyErr_Occurred()) SWIG_fail;
25177 }
25178 resultobj = SWIG_From_int(static_cast< int >(result));
25179 {
25180 if (temp2) delete arg2;
25181 }
25182 return resultobj;
25183 fail:
25184 {
25185 if (temp2) delete arg2;
25186 }
25187 return NULL;
25188 }
25189
25190
25191 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25192 PyObject *resultobj = 0;
25193 wxDateTime *arg1 = (wxDateTime *) 0 ;
25194 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25195 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25196 int result;
25197 void *argp1 = 0 ;
25198 int res1 = 0 ;
25199 bool temp2 = false ;
25200 PyObject * obj0 = 0 ;
25201 PyObject * obj1 = 0 ;
25202 char * kwnames[] = {
25203 (char *) "self",(char *) "tz", NULL
25204 };
25205
25206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
25207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25208 if (!SWIG_IsOK(res1)) {
25209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25210 }
25211 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25212 if (obj1) {
25213 {
25214 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25215 temp2 = true;
25216 }
25217 }
25218 {
25219 PyThreadState* __tstate = wxPyBeginAllowThreads();
25220 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
25221 wxPyEndAllowThreads(__tstate);
25222 if (PyErr_Occurred()) SWIG_fail;
25223 }
25224 resultobj = SWIG_From_int(static_cast< int >(result));
25225 {
25226 if (temp2) delete arg2;
25227 }
25228 return resultobj;
25229 fail:
25230 {
25231 if (temp2) delete arg2;
25232 }
25233 return NULL;
25234 }
25235
25236
25237 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25238 PyObject *resultobj = 0;
25239 wxDateTime *arg1 = (wxDateTime *) 0 ;
25240 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25241 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25242 int result;
25243 void *argp1 = 0 ;
25244 int res1 = 0 ;
25245 bool temp2 = false ;
25246 PyObject * obj0 = 0 ;
25247 PyObject * obj1 = 0 ;
25248 char * kwnames[] = {
25249 (char *) "self",(char *) "tz", NULL
25250 };
25251
25252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
25253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25254 if (!SWIG_IsOK(res1)) {
25255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25256 }
25257 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25258 if (obj1) {
25259 {
25260 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25261 temp2 = true;
25262 }
25263 }
25264 {
25265 PyThreadState* __tstate = wxPyBeginAllowThreads();
25266 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
25267 wxPyEndAllowThreads(__tstate);
25268 if (PyErr_Occurred()) SWIG_fail;
25269 }
25270 resultobj = SWIG_From_int(static_cast< int >(result));
25271 {
25272 if (temp2) delete arg2;
25273 }
25274 return resultobj;
25275 fail:
25276 {
25277 if (temp2) delete arg2;
25278 }
25279 return NULL;
25280 }
25281
25282
25283 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25284 PyObject *resultobj = 0;
25285 wxDateTime *arg1 = (wxDateTime *) 0 ;
25286 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25287 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25288 int result;
25289 void *argp1 = 0 ;
25290 int res1 = 0 ;
25291 bool temp2 = false ;
25292 PyObject * obj0 = 0 ;
25293 PyObject * obj1 = 0 ;
25294 char * kwnames[] = {
25295 (char *) "self",(char *) "tz", NULL
25296 };
25297
25298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
25299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25300 if (!SWIG_IsOK(res1)) {
25301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25302 }
25303 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25304 if (obj1) {
25305 {
25306 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25307 temp2 = true;
25308 }
25309 }
25310 {
25311 PyThreadState* __tstate = wxPyBeginAllowThreads();
25312 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
25313 wxPyEndAllowThreads(__tstate);
25314 if (PyErr_Occurred()) SWIG_fail;
25315 }
25316 resultobj = SWIG_From_int(static_cast< int >(result));
25317 {
25318 if (temp2) delete arg2;
25319 }
25320 return resultobj;
25321 fail:
25322 {
25323 if (temp2) delete arg2;
25324 }
25325 return NULL;
25326 }
25327
25328
25329 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25330 PyObject *resultobj = 0;
25331 wxDateTime *arg1 = (wxDateTime *) 0 ;
25332 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25333 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25334 int result;
25335 void *argp1 = 0 ;
25336 int res1 = 0 ;
25337 bool temp2 = false ;
25338 PyObject * obj0 = 0 ;
25339 PyObject * obj1 = 0 ;
25340 char * kwnames[] = {
25341 (char *) "self",(char *) "tz", NULL
25342 };
25343
25344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
25345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25346 if (!SWIG_IsOK(res1)) {
25347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25348 }
25349 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25350 if (obj1) {
25351 {
25352 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25353 temp2 = true;
25354 }
25355 }
25356 {
25357 PyThreadState* __tstate = wxPyBeginAllowThreads();
25358 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
25359 wxPyEndAllowThreads(__tstate);
25360 if (PyErr_Occurred()) SWIG_fail;
25361 }
25362 resultobj = SWIG_From_int(static_cast< int >(result));
25363 {
25364 if (temp2) delete arg2;
25365 }
25366 return resultobj;
25367 fail:
25368 {
25369 if (temp2) delete arg2;
25370 }
25371 return NULL;
25372 }
25373
25374
25375 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25376 PyObject *resultobj = 0;
25377 wxDateTime *arg1 = (wxDateTime *) 0 ;
25378 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25379 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25380 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25381 int result;
25382 void *argp1 = 0 ;
25383 int res1 = 0 ;
25384 int val2 ;
25385 int ecode2 = 0 ;
25386 bool temp3 = false ;
25387 PyObject * obj0 = 0 ;
25388 PyObject * obj1 = 0 ;
25389 PyObject * obj2 = 0 ;
25390 char * kwnames[] = {
25391 (char *) "self",(char *) "flags",(char *) "tz", NULL
25392 };
25393
25394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25396 if (!SWIG_IsOK(res1)) {
25397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25398 }
25399 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25400 if (obj1) {
25401 ecode2 = SWIG_AsVal_int(obj1, &val2);
25402 if (!SWIG_IsOK(ecode2)) {
25403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25404 }
25405 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25406 }
25407 if (obj2) {
25408 {
25409 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25410 temp3 = true;
25411 }
25412 }
25413 {
25414 PyThreadState* __tstate = wxPyBeginAllowThreads();
25415 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
25416 wxPyEndAllowThreads(__tstate);
25417 if (PyErr_Occurred()) SWIG_fail;
25418 }
25419 resultobj = SWIG_From_int(static_cast< int >(result));
25420 {
25421 if (temp3) delete arg3;
25422 }
25423 return resultobj;
25424 fail:
25425 {
25426 if (temp3) delete arg3;
25427 }
25428 return NULL;
25429 }
25430
25431
25432 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25433 PyObject *resultobj = 0;
25434 wxDateTime *arg1 = (wxDateTime *) 0 ;
25435 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25436 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25437 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25438 int result;
25439 void *argp1 = 0 ;
25440 int res1 = 0 ;
25441 int val2 ;
25442 int ecode2 = 0 ;
25443 bool temp3 = false ;
25444 PyObject * obj0 = 0 ;
25445 PyObject * obj1 = 0 ;
25446 PyObject * obj2 = 0 ;
25447 char * kwnames[] = {
25448 (char *) "self",(char *) "flags",(char *) "tz", NULL
25449 };
25450
25451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25453 if (!SWIG_IsOK(res1)) {
25454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25455 }
25456 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25457 if (obj1) {
25458 ecode2 = SWIG_AsVal_int(obj1, &val2);
25459 if (!SWIG_IsOK(ecode2)) {
25460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25461 }
25462 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25463 }
25464 if (obj2) {
25465 {
25466 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25467 temp3 = true;
25468 }
25469 }
25470 {
25471 PyThreadState* __tstate = wxPyBeginAllowThreads();
25472 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
25473 wxPyEndAllowThreads(__tstate);
25474 if (PyErr_Occurred()) SWIG_fail;
25475 }
25476 resultobj = SWIG_From_int(static_cast< int >(result));
25477 {
25478 if (temp3) delete arg3;
25479 }
25480 return resultobj;
25481 fail:
25482 {
25483 if (temp3) delete arg3;
25484 }
25485 return NULL;
25486 }
25487
25488
25489 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25490 PyObject *resultobj = 0;
25491 wxDateTime *arg1 = (wxDateTime *) 0 ;
25492 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25493 bool result;
25494 void *argp1 = 0 ;
25495 int res1 = 0 ;
25496 int val2 ;
25497 int ecode2 = 0 ;
25498 PyObject * obj0 = 0 ;
25499 PyObject * obj1 = 0 ;
25500 char * kwnames[] = {
25501 (char *) "self",(char *) "country", NULL
25502 };
25503
25504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
25505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25506 if (!SWIG_IsOK(res1)) {
25507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25508 }
25509 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25510 if (obj1) {
25511 ecode2 = SWIG_AsVal_int(obj1, &val2);
25512 if (!SWIG_IsOK(ecode2)) {
25513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25514 }
25515 arg2 = static_cast< wxDateTime::Country >(val2);
25516 }
25517 {
25518 PyThreadState* __tstate = wxPyBeginAllowThreads();
25519 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
25520 wxPyEndAllowThreads(__tstate);
25521 if (PyErr_Occurred()) SWIG_fail;
25522 }
25523 {
25524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25525 }
25526 return resultobj;
25527 fail:
25528 return NULL;
25529 }
25530
25531
25532 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25533 PyObject *resultobj = 0;
25534 wxDateTime *arg1 = (wxDateTime *) 0 ;
25535 wxDateTime *arg2 = 0 ;
25536 bool result;
25537 void *argp1 = 0 ;
25538 int res1 = 0 ;
25539 void *argp2 = 0 ;
25540 int res2 = 0 ;
25541 PyObject * obj0 = 0 ;
25542 PyObject * obj1 = 0 ;
25543 char * kwnames[] = {
25544 (char *) "self",(char *) "datetime", NULL
25545 };
25546
25547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
25548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25549 if (!SWIG_IsOK(res1)) {
25550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25551 }
25552 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25553 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25554 if (!SWIG_IsOK(res2)) {
25555 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25556 }
25557 if (!argp2) {
25558 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25559 }
25560 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25561 {
25562 PyThreadState* __tstate = wxPyBeginAllowThreads();
25563 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
25564 wxPyEndAllowThreads(__tstate);
25565 if (PyErr_Occurred()) SWIG_fail;
25566 }
25567 {
25568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25569 }
25570 return resultobj;
25571 fail:
25572 return NULL;
25573 }
25574
25575
25576 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25577 PyObject *resultobj = 0;
25578 wxDateTime *arg1 = (wxDateTime *) 0 ;
25579 wxDateTime *arg2 = 0 ;
25580 bool result;
25581 void *argp1 = 0 ;
25582 int res1 = 0 ;
25583 void *argp2 = 0 ;
25584 int res2 = 0 ;
25585 PyObject * obj0 = 0 ;
25586 PyObject * obj1 = 0 ;
25587 char * kwnames[] = {
25588 (char *) "self",(char *) "datetime", NULL
25589 };
25590
25591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
25592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25593 if (!SWIG_IsOK(res1)) {
25594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25595 }
25596 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25597 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25598 if (!SWIG_IsOK(res2)) {
25599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25600 }
25601 if (!argp2) {
25602 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25603 }
25604 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25605 {
25606 PyThreadState* __tstate = wxPyBeginAllowThreads();
25607 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
25608 wxPyEndAllowThreads(__tstate);
25609 if (PyErr_Occurred()) SWIG_fail;
25610 }
25611 {
25612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25613 }
25614 return resultobj;
25615 fail:
25616 return NULL;
25617 }
25618
25619
25620 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25621 PyObject *resultobj = 0;
25622 wxDateTime *arg1 = (wxDateTime *) 0 ;
25623 wxDateTime *arg2 = 0 ;
25624 bool result;
25625 void *argp1 = 0 ;
25626 int res1 = 0 ;
25627 void *argp2 = 0 ;
25628 int res2 = 0 ;
25629 PyObject * obj0 = 0 ;
25630 PyObject * obj1 = 0 ;
25631 char * kwnames[] = {
25632 (char *) "self",(char *) "datetime", NULL
25633 };
25634
25635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
25636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25637 if (!SWIG_IsOK(res1)) {
25638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25639 }
25640 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25641 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25642 if (!SWIG_IsOK(res2)) {
25643 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25644 }
25645 if (!argp2) {
25646 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25647 }
25648 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25649 {
25650 PyThreadState* __tstate = wxPyBeginAllowThreads();
25651 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
25652 wxPyEndAllowThreads(__tstate);
25653 if (PyErr_Occurred()) SWIG_fail;
25654 }
25655 {
25656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25657 }
25658 return resultobj;
25659 fail:
25660 return NULL;
25661 }
25662
25663
25664 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25665 PyObject *resultobj = 0;
25666 wxDateTime *arg1 = (wxDateTime *) 0 ;
25667 wxDateTime *arg2 = 0 ;
25668 wxDateTime *arg3 = 0 ;
25669 bool result;
25670 void *argp1 = 0 ;
25671 int res1 = 0 ;
25672 void *argp2 = 0 ;
25673 int res2 = 0 ;
25674 void *argp3 = 0 ;
25675 int res3 = 0 ;
25676 PyObject * obj0 = 0 ;
25677 PyObject * obj1 = 0 ;
25678 PyObject * obj2 = 0 ;
25679 char * kwnames[] = {
25680 (char *) "self",(char *) "t1",(char *) "t2", NULL
25681 };
25682
25683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25685 if (!SWIG_IsOK(res1)) {
25686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25687 }
25688 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25689 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25690 if (!SWIG_IsOK(res2)) {
25691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25692 }
25693 if (!argp2) {
25694 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25695 }
25696 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25697 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25698 if (!SWIG_IsOK(res3)) {
25699 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25700 }
25701 if (!argp3) {
25702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25703 }
25704 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25705 {
25706 PyThreadState* __tstate = wxPyBeginAllowThreads();
25707 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25708 wxPyEndAllowThreads(__tstate);
25709 if (PyErr_Occurred()) SWIG_fail;
25710 }
25711 {
25712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25713 }
25714 return resultobj;
25715 fail:
25716 return NULL;
25717 }
25718
25719
25720 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25721 PyObject *resultobj = 0;
25722 wxDateTime *arg1 = (wxDateTime *) 0 ;
25723 wxDateTime *arg2 = 0 ;
25724 wxDateTime *arg3 = 0 ;
25725 bool result;
25726 void *argp1 = 0 ;
25727 int res1 = 0 ;
25728 void *argp2 = 0 ;
25729 int res2 = 0 ;
25730 void *argp3 = 0 ;
25731 int res3 = 0 ;
25732 PyObject * obj0 = 0 ;
25733 PyObject * obj1 = 0 ;
25734 PyObject * obj2 = 0 ;
25735 char * kwnames[] = {
25736 (char *) "self",(char *) "t1",(char *) "t2", NULL
25737 };
25738
25739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25741 if (!SWIG_IsOK(res1)) {
25742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25743 }
25744 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25745 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25746 if (!SWIG_IsOK(res2)) {
25747 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25748 }
25749 if (!argp2) {
25750 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25751 }
25752 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25753 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25754 if (!SWIG_IsOK(res3)) {
25755 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25756 }
25757 if (!argp3) {
25758 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25759 }
25760 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25761 {
25762 PyThreadState* __tstate = wxPyBeginAllowThreads();
25763 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25764 wxPyEndAllowThreads(__tstate);
25765 if (PyErr_Occurred()) SWIG_fail;
25766 }
25767 {
25768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25769 }
25770 return resultobj;
25771 fail:
25772 return NULL;
25773 }
25774
25775
25776 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25777 PyObject *resultobj = 0;
25778 wxDateTime *arg1 = (wxDateTime *) 0 ;
25779 wxDateTime *arg2 = 0 ;
25780 bool result;
25781 void *argp1 = 0 ;
25782 int res1 = 0 ;
25783 void *argp2 = 0 ;
25784 int res2 = 0 ;
25785 PyObject * obj0 = 0 ;
25786 PyObject * obj1 = 0 ;
25787 char * kwnames[] = {
25788 (char *) "self",(char *) "dt", NULL
25789 };
25790
25791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
25792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25793 if (!SWIG_IsOK(res1)) {
25794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25795 }
25796 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25797 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25798 if (!SWIG_IsOK(res2)) {
25799 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25800 }
25801 if (!argp2) {
25802 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25803 }
25804 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25805 {
25806 PyThreadState* __tstate = wxPyBeginAllowThreads();
25807 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
25808 wxPyEndAllowThreads(__tstate);
25809 if (PyErr_Occurred()) SWIG_fail;
25810 }
25811 {
25812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25813 }
25814 return resultobj;
25815 fail:
25816 return NULL;
25817 }
25818
25819
25820 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25821 PyObject *resultobj = 0;
25822 wxDateTime *arg1 = (wxDateTime *) 0 ;
25823 wxDateTime *arg2 = 0 ;
25824 bool result;
25825 void *argp1 = 0 ;
25826 int res1 = 0 ;
25827 void *argp2 = 0 ;
25828 int res2 = 0 ;
25829 PyObject * obj0 = 0 ;
25830 PyObject * obj1 = 0 ;
25831 char * kwnames[] = {
25832 (char *) "self",(char *) "dt", NULL
25833 };
25834
25835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
25836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25837 if (!SWIG_IsOK(res1)) {
25838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25839 }
25840 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25841 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25842 if (!SWIG_IsOK(res2)) {
25843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25844 }
25845 if (!argp2) {
25846 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25847 }
25848 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25849 {
25850 PyThreadState* __tstate = wxPyBeginAllowThreads();
25851 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
25852 wxPyEndAllowThreads(__tstate);
25853 if (PyErr_Occurred()) SWIG_fail;
25854 }
25855 {
25856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25857 }
25858 return resultobj;
25859 fail:
25860 return NULL;
25861 }
25862
25863
25864 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25865 PyObject *resultobj = 0;
25866 wxDateTime *arg1 = (wxDateTime *) 0 ;
25867 wxDateTime *arg2 = 0 ;
25868 wxTimeSpan *arg3 = 0 ;
25869 bool result;
25870 void *argp1 = 0 ;
25871 int res1 = 0 ;
25872 void *argp2 = 0 ;
25873 int res2 = 0 ;
25874 void *argp3 = 0 ;
25875 int res3 = 0 ;
25876 PyObject * obj0 = 0 ;
25877 PyObject * obj1 = 0 ;
25878 PyObject * obj2 = 0 ;
25879 char * kwnames[] = {
25880 (char *) "self",(char *) "dt",(char *) "ts", NULL
25881 };
25882
25883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25885 if (!SWIG_IsOK(res1)) {
25886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25887 }
25888 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25889 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25890 if (!SWIG_IsOK(res2)) {
25891 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25892 }
25893 if (!argp2) {
25894 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25895 }
25896 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25897 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25898 if (!SWIG_IsOK(res3)) {
25899 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25900 }
25901 if (!argp3) {
25902 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25903 }
25904 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
25905 {
25906 PyThreadState* __tstate = wxPyBeginAllowThreads();
25907 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
25908 wxPyEndAllowThreads(__tstate);
25909 if (PyErr_Occurred()) SWIG_fail;
25910 }
25911 {
25912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25913 }
25914 return resultobj;
25915 fail:
25916 return NULL;
25917 }
25918
25919
25920 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25921 PyObject *resultobj = 0;
25922 wxDateTime *arg1 = (wxDateTime *) 0 ;
25923 wxTimeSpan *arg2 = 0 ;
25924 wxDateTime *result = 0 ;
25925 void *argp1 = 0 ;
25926 int res1 = 0 ;
25927 void *argp2 = 0 ;
25928 int res2 = 0 ;
25929 PyObject * obj0 = 0 ;
25930 PyObject * obj1 = 0 ;
25931 char * kwnames[] = {
25932 (char *) "self",(char *) "diff", NULL
25933 };
25934
25935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
25936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25937 if (!SWIG_IsOK(res1)) {
25938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25939 }
25940 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25941 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25942 if (!SWIG_IsOK(res2)) {
25943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25944 }
25945 if (!argp2) {
25946 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25947 }
25948 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
25949 {
25950 PyThreadState* __tstate = wxPyBeginAllowThreads();
25951 {
25952 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
25953 result = (wxDateTime *) &_result_ref;
25954 }
25955 wxPyEndAllowThreads(__tstate);
25956 if (PyErr_Occurred()) SWIG_fail;
25957 }
25958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25959 return resultobj;
25960 fail:
25961 return NULL;
25962 }
25963
25964
25965 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25966 PyObject *resultobj = 0;
25967 wxDateTime *arg1 = (wxDateTime *) 0 ;
25968 wxDateSpan *arg2 = 0 ;
25969 wxDateTime *result = 0 ;
25970 void *argp1 = 0 ;
25971 int res1 = 0 ;
25972 void *argp2 = 0 ;
25973 int res2 = 0 ;
25974 PyObject * obj0 = 0 ;
25975 PyObject * obj1 = 0 ;
25976 char * kwnames[] = {
25977 (char *) "self",(char *) "diff", NULL
25978 };
25979
25980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
25981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25982 if (!SWIG_IsOK(res1)) {
25983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25984 }
25985 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25986 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
25987 if (!SWIG_IsOK(res2)) {
25988 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25989 }
25990 if (!argp2) {
25991 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25992 }
25993 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
25994 {
25995 PyThreadState* __tstate = wxPyBeginAllowThreads();
25996 {
25997 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25998 result = (wxDateTime *) &_result_ref;
25999 }
26000 wxPyEndAllowThreads(__tstate);
26001 if (PyErr_Occurred()) SWIG_fail;
26002 }
26003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26004 return resultobj;
26005 fail:
26006 return NULL;
26007 }
26008
26009
26010 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26011 PyObject *resultobj = 0;
26012 wxDateTime *arg1 = (wxDateTime *) 0 ;
26013 wxTimeSpan *arg2 = 0 ;
26014 wxDateTime *result = 0 ;
26015 void *argp1 = 0 ;
26016 int res1 = 0 ;
26017 void *argp2 = 0 ;
26018 int res2 = 0 ;
26019 PyObject * obj0 = 0 ;
26020 PyObject * obj1 = 0 ;
26021 char * kwnames[] = {
26022 (char *) "self",(char *) "diff", NULL
26023 };
26024
26025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
26026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26027 if (!SWIG_IsOK(res1)) {
26028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26029 }
26030 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26031 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26032 if (!SWIG_IsOK(res2)) {
26033 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26034 }
26035 if (!argp2) {
26036 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26037 }
26038 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26039 {
26040 PyThreadState* __tstate = wxPyBeginAllowThreads();
26041 {
26042 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
26043 result = (wxDateTime *) &_result_ref;
26044 }
26045 wxPyEndAllowThreads(__tstate);
26046 if (PyErr_Occurred()) SWIG_fail;
26047 }
26048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26049 return resultobj;
26050 fail:
26051 return NULL;
26052 }
26053
26054
26055 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26056 PyObject *resultobj = 0;
26057 wxDateTime *arg1 = (wxDateTime *) 0 ;
26058 wxDateSpan *arg2 = 0 ;
26059 wxDateTime *result = 0 ;
26060 void *argp1 = 0 ;
26061 int res1 = 0 ;
26062 void *argp2 = 0 ;
26063 int res2 = 0 ;
26064 PyObject * obj0 = 0 ;
26065 PyObject * obj1 = 0 ;
26066 char * kwnames[] = {
26067 (char *) "self",(char *) "diff", NULL
26068 };
26069
26070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
26071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26072 if (!SWIG_IsOK(res1)) {
26073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26074 }
26075 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26076 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26077 if (!SWIG_IsOK(res2)) {
26078 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26079 }
26080 if (!argp2) {
26081 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26082 }
26083 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26084 {
26085 PyThreadState* __tstate = wxPyBeginAllowThreads();
26086 {
26087 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26088 result = (wxDateTime *) &_result_ref;
26089 }
26090 wxPyEndAllowThreads(__tstate);
26091 if (PyErr_Occurred()) SWIG_fail;
26092 }
26093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26094 return resultobj;
26095 fail:
26096 return NULL;
26097 }
26098
26099
26100 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26101 PyObject *resultobj = 0;
26102 wxDateTime *arg1 = (wxDateTime *) 0 ;
26103 wxDateTime *arg2 = 0 ;
26104 wxTimeSpan result;
26105 void *argp1 = 0 ;
26106 int res1 = 0 ;
26107 void *argp2 = 0 ;
26108 int res2 = 0 ;
26109 PyObject * obj0 = 0 ;
26110 PyObject * obj1 = 0 ;
26111 char * kwnames[] = {
26112 (char *) "self",(char *) "dt", NULL
26113 };
26114
26115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
26116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26117 if (!SWIG_IsOK(res1)) {
26118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26119 }
26120 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26121 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26122 if (!SWIG_IsOK(res2)) {
26123 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26124 }
26125 if (!argp2) {
26126 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26127 }
26128 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26129 {
26130 PyThreadState* __tstate = wxPyBeginAllowThreads();
26131 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
26132 wxPyEndAllowThreads(__tstate);
26133 if (PyErr_Occurred()) SWIG_fail;
26134 }
26135 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26136 return resultobj;
26137 fail:
26138 return NULL;
26139 }
26140
26141
26142 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26143 PyObject *resultobj = 0;
26144 wxDateTime *arg1 = (wxDateTime *) 0 ;
26145 wxTimeSpan *arg2 = 0 ;
26146 wxDateTime *result = 0 ;
26147 void *argp1 = 0 ;
26148 int res1 = 0 ;
26149 void *argp2 = 0 ;
26150 int res2 = 0 ;
26151
26152 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26154 if (!SWIG_IsOK(res1)) {
26155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26156 }
26157 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26158 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26159 if (!SWIG_IsOK(res2)) {
26160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26161 }
26162 if (!argp2) {
26163 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26164 }
26165 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26166 {
26167 PyThreadState* __tstate = wxPyBeginAllowThreads();
26168 {
26169 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
26170 result = (wxDateTime *) &_result_ref;
26171 }
26172 wxPyEndAllowThreads(__tstate);
26173 if (PyErr_Occurred()) SWIG_fail;
26174 }
26175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26176 return resultobj;
26177 fail:
26178 return NULL;
26179 }
26180
26181
26182 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26183 PyObject *resultobj = 0;
26184 wxDateTime *arg1 = (wxDateTime *) 0 ;
26185 wxDateSpan *arg2 = 0 ;
26186 wxDateTime *result = 0 ;
26187 void *argp1 = 0 ;
26188 int res1 = 0 ;
26189 void *argp2 = 0 ;
26190 int res2 = 0 ;
26191
26192 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26194 if (!SWIG_IsOK(res1)) {
26195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26196 }
26197 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26198 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26199 if (!SWIG_IsOK(res2)) {
26200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26201 }
26202 if (!argp2) {
26203 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26204 }
26205 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26206 {
26207 PyThreadState* __tstate = wxPyBeginAllowThreads();
26208 {
26209 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26210 result = (wxDateTime *) &_result_ref;
26211 }
26212 wxPyEndAllowThreads(__tstate);
26213 if (PyErr_Occurred()) SWIG_fail;
26214 }
26215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26216 return resultobj;
26217 fail:
26218 return NULL;
26219 }
26220
26221
26222 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
26223 int argc;
26224 PyObject *argv[3];
26225
26226 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
26227 --argc;
26228 if (argc == 2) {
26229 int _v = 0;
26230 {
26231 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26232 _v = SWIG_CheckState(res);
26233 }
26234 if (!_v) goto check_1;
26235 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
26236 }
26237 check_1:
26238
26239 if (argc == 2) {
26240 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
26241 }
26242
26243 fail:
26244 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
26245 return NULL;
26246 }
26247
26248
26249 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26250 PyObject *resultobj = 0;
26251 wxDateTime *arg1 = (wxDateTime *) 0 ;
26252 wxTimeSpan *arg2 = 0 ;
26253 wxDateTime *result = 0 ;
26254 void *argp1 = 0 ;
26255 int res1 = 0 ;
26256 void *argp2 = 0 ;
26257 int res2 = 0 ;
26258
26259 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26261 if (!SWIG_IsOK(res1)) {
26262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26263 }
26264 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26265 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26266 if (!SWIG_IsOK(res2)) {
26267 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26268 }
26269 if (!argp2) {
26270 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26271 }
26272 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26273 {
26274 PyThreadState* __tstate = wxPyBeginAllowThreads();
26275 {
26276 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
26277 result = (wxDateTime *) &_result_ref;
26278 }
26279 wxPyEndAllowThreads(__tstate);
26280 if (PyErr_Occurred()) SWIG_fail;
26281 }
26282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26283 return resultobj;
26284 fail:
26285 return NULL;
26286 }
26287
26288
26289 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26290 PyObject *resultobj = 0;
26291 wxDateTime *arg1 = (wxDateTime *) 0 ;
26292 wxDateSpan *arg2 = 0 ;
26293 wxDateTime *result = 0 ;
26294 void *argp1 = 0 ;
26295 int res1 = 0 ;
26296 void *argp2 = 0 ;
26297 int res2 = 0 ;
26298
26299 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26301 if (!SWIG_IsOK(res1)) {
26302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26303 }
26304 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26305 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26306 if (!SWIG_IsOK(res2)) {
26307 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26308 }
26309 if (!argp2) {
26310 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26311 }
26312 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26313 {
26314 PyThreadState* __tstate = wxPyBeginAllowThreads();
26315 {
26316 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26317 result = (wxDateTime *) &_result_ref;
26318 }
26319 wxPyEndAllowThreads(__tstate);
26320 if (PyErr_Occurred()) SWIG_fail;
26321 }
26322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26323 return resultobj;
26324 fail:
26325 return NULL;
26326 }
26327
26328
26329 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
26330 int argc;
26331 PyObject *argv[3];
26332
26333 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
26334 --argc;
26335 if (argc == 2) {
26336 int _v = 0;
26337 {
26338 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26339 _v = SWIG_CheckState(res);
26340 }
26341 if (!_v) goto check_1;
26342 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
26343 }
26344 check_1:
26345
26346 if (argc == 2) {
26347 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
26348 }
26349
26350 fail:
26351 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
26352 return NULL;
26353 }
26354
26355
26356 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26357 PyObject *resultobj = 0;
26358 wxDateTime *arg1 = (wxDateTime *) 0 ;
26359 wxTimeSpan *arg2 = 0 ;
26360 wxDateTime result;
26361 void *argp1 = 0 ;
26362 int res1 = 0 ;
26363 void *argp2 = 0 ;
26364 int res2 = 0 ;
26365
26366 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26368 if (!SWIG_IsOK(res1)) {
26369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26370 }
26371 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26372 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26373 if (!SWIG_IsOK(res2)) {
26374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26375 }
26376 if (!argp2) {
26377 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26378 }
26379 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26380 {
26381 PyThreadState* __tstate = wxPyBeginAllowThreads();
26382 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
26383 wxPyEndAllowThreads(__tstate);
26384 if (PyErr_Occurred()) SWIG_fail;
26385 }
26386 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26387 return resultobj;
26388 fail:
26389 return NULL;
26390 }
26391
26392
26393 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26394 PyObject *resultobj = 0;
26395 wxDateTime *arg1 = (wxDateTime *) 0 ;
26396 wxDateSpan *arg2 = 0 ;
26397 wxDateTime result;
26398 void *argp1 = 0 ;
26399 int res1 = 0 ;
26400 void *argp2 = 0 ;
26401 int res2 = 0 ;
26402
26403 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26405 if (!SWIG_IsOK(res1)) {
26406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26407 }
26408 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26409 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26410 if (!SWIG_IsOK(res2)) {
26411 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26412 }
26413 if (!argp2) {
26414 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26415 }
26416 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26417 {
26418 PyThreadState* __tstate = wxPyBeginAllowThreads();
26419 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
26420 wxPyEndAllowThreads(__tstate);
26421 if (PyErr_Occurred()) SWIG_fail;
26422 }
26423 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26424 return resultobj;
26425 fail:
26426 return NULL;
26427 }
26428
26429
26430 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
26431 int argc;
26432 PyObject *argv[3];
26433
26434 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
26435 --argc;
26436 if (argc == 2) {
26437 int _v = 0;
26438 {
26439 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26440 _v = SWIG_CheckState(res);
26441 }
26442 if (!_v) goto check_1;
26443 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
26444 }
26445 check_1:
26446
26447 if (argc == 2) {
26448 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
26449 }
26450
26451 fail:
26452 Py_INCREF(Py_NotImplemented);
26453 return Py_NotImplemented;
26454 }
26455
26456
26457 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26458 PyObject *resultobj = 0;
26459 wxDateTime *arg1 = (wxDateTime *) 0 ;
26460 wxDateTime *arg2 = 0 ;
26461 wxTimeSpan result;
26462 void *argp1 = 0 ;
26463 int res1 = 0 ;
26464 void *argp2 = 0 ;
26465 int res2 = 0 ;
26466
26467 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26469 if (!SWIG_IsOK(res1)) {
26470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26471 }
26472 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26473 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26474 if (!SWIG_IsOK(res2)) {
26475 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26476 }
26477 if (!argp2) {
26478 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26479 }
26480 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26481 {
26482 PyThreadState* __tstate = wxPyBeginAllowThreads();
26483 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
26484 wxPyEndAllowThreads(__tstate);
26485 if (PyErr_Occurred()) SWIG_fail;
26486 }
26487 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26488 return resultobj;
26489 fail:
26490 return NULL;
26491 }
26492
26493
26494 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26495 PyObject *resultobj = 0;
26496 wxDateTime *arg1 = (wxDateTime *) 0 ;
26497 wxTimeSpan *arg2 = 0 ;
26498 wxDateTime result;
26499 void *argp1 = 0 ;
26500 int res1 = 0 ;
26501 void *argp2 = 0 ;
26502 int res2 = 0 ;
26503
26504 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26506 if (!SWIG_IsOK(res1)) {
26507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26508 }
26509 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26510 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26511 if (!SWIG_IsOK(res2)) {
26512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26513 }
26514 if (!argp2) {
26515 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26516 }
26517 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26518 {
26519 PyThreadState* __tstate = wxPyBeginAllowThreads();
26520 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
26521 wxPyEndAllowThreads(__tstate);
26522 if (PyErr_Occurred()) SWIG_fail;
26523 }
26524 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26525 return resultobj;
26526 fail:
26527 return NULL;
26528 }
26529
26530
26531 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26532 PyObject *resultobj = 0;
26533 wxDateTime *arg1 = (wxDateTime *) 0 ;
26534 wxDateSpan *arg2 = 0 ;
26535 wxDateTime result;
26536 void *argp1 = 0 ;
26537 int res1 = 0 ;
26538 void *argp2 = 0 ;
26539 int res2 = 0 ;
26540
26541 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26543 if (!SWIG_IsOK(res1)) {
26544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26545 }
26546 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26547 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26548 if (!SWIG_IsOK(res2)) {
26549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26550 }
26551 if (!argp2) {
26552 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26553 }
26554 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26555 {
26556 PyThreadState* __tstate = wxPyBeginAllowThreads();
26557 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
26558 wxPyEndAllowThreads(__tstate);
26559 if (PyErr_Occurred()) SWIG_fail;
26560 }
26561 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26562 return resultobj;
26563 fail:
26564 return NULL;
26565 }
26566
26567
26568 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
26569 int argc;
26570 PyObject *argv[3];
26571
26572 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
26573 --argc;
26574 if (argc == 2) {
26575 int _v = 0;
26576 {
26577 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
26578 _v = SWIG_CheckState(res);
26579 }
26580 if (!_v) goto check_1;
26581 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
26582 }
26583 check_1:
26584
26585 if (argc == 2) {
26586 int _v = 0;
26587 {
26588 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26589 _v = SWIG_CheckState(res);
26590 }
26591 if (!_v) goto check_2;
26592 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
26593 }
26594 check_2:
26595
26596 if (argc == 2) {
26597 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
26598 }
26599
26600 fail:
26601 Py_INCREF(Py_NotImplemented);
26602 return Py_NotImplemented;
26603 }
26604
26605
26606 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26607 PyObject *resultobj = 0;
26608 wxDateTime *arg1 = (wxDateTime *) 0 ;
26609 wxDateTime *arg2 = (wxDateTime *) 0 ;
26610 bool result;
26611 void *argp1 = 0 ;
26612 int res1 = 0 ;
26613 void *argp2 = 0 ;
26614 int res2 = 0 ;
26615 PyObject * obj0 = 0 ;
26616 PyObject * obj1 = 0 ;
26617 char * kwnames[] = {
26618 (char *) "self",(char *) "other", NULL
26619 };
26620
26621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
26622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26623 if (!SWIG_IsOK(res1)) {
26624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26625 }
26626 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26627 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26628 if (!SWIG_IsOK(res2)) {
26629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26630 }
26631 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26632 {
26633 PyThreadState* __tstate = wxPyBeginAllowThreads();
26634 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
26635 wxPyEndAllowThreads(__tstate);
26636 if (PyErr_Occurred()) SWIG_fail;
26637 }
26638 {
26639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26640 }
26641 return resultobj;
26642 fail:
26643 return NULL;
26644 }
26645
26646
26647 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26648 PyObject *resultobj = 0;
26649 wxDateTime *arg1 = (wxDateTime *) 0 ;
26650 wxDateTime *arg2 = (wxDateTime *) 0 ;
26651 bool result;
26652 void *argp1 = 0 ;
26653 int res1 = 0 ;
26654 void *argp2 = 0 ;
26655 int res2 = 0 ;
26656 PyObject * obj0 = 0 ;
26657 PyObject * obj1 = 0 ;
26658 char * kwnames[] = {
26659 (char *) "self",(char *) "other", NULL
26660 };
26661
26662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
26663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26664 if (!SWIG_IsOK(res1)) {
26665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26666 }
26667 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26668 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26669 if (!SWIG_IsOK(res2)) {
26670 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26671 }
26672 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26673 {
26674 PyThreadState* __tstate = wxPyBeginAllowThreads();
26675 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
26676 wxPyEndAllowThreads(__tstate);
26677 if (PyErr_Occurred()) SWIG_fail;
26678 }
26679 {
26680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26681 }
26682 return resultobj;
26683 fail:
26684 return NULL;
26685 }
26686
26687
26688 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26689 PyObject *resultobj = 0;
26690 wxDateTime *arg1 = (wxDateTime *) 0 ;
26691 wxDateTime *arg2 = (wxDateTime *) 0 ;
26692 bool result;
26693 void *argp1 = 0 ;
26694 int res1 = 0 ;
26695 void *argp2 = 0 ;
26696 int res2 = 0 ;
26697 PyObject * obj0 = 0 ;
26698 PyObject * obj1 = 0 ;
26699 char * kwnames[] = {
26700 (char *) "self",(char *) "other", NULL
26701 };
26702
26703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
26704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26705 if (!SWIG_IsOK(res1)) {
26706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26707 }
26708 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26709 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26710 if (!SWIG_IsOK(res2)) {
26711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26712 }
26713 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26714 {
26715 PyThreadState* __tstate = wxPyBeginAllowThreads();
26716 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
26717 wxPyEndAllowThreads(__tstate);
26718 if (PyErr_Occurred()) SWIG_fail;
26719 }
26720 {
26721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26722 }
26723 return resultobj;
26724 fail:
26725 return NULL;
26726 }
26727
26728
26729 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26730 PyObject *resultobj = 0;
26731 wxDateTime *arg1 = (wxDateTime *) 0 ;
26732 wxDateTime *arg2 = (wxDateTime *) 0 ;
26733 bool result;
26734 void *argp1 = 0 ;
26735 int res1 = 0 ;
26736 void *argp2 = 0 ;
26737 int res2 = 0 ;
26738 PyObject * obj0 = 0 ;
26739 PyObject * obj1 = 0 ;
26740 char * kwnames[] = {
26741 (char *) "self",(char *) "other", NULL
26742 };
26743
26744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
26745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26746 if (!SWIG_IsOK(res1)) {
26747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26748 }
26749 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26750 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26751 if (!SWIG_IsOK(res2)) {
26752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26753 }
26754 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26755 {
26756 PyThreadState* __tstate = wxPyBeginAllowThreads();
26757 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
26758 wxPyEndAllowThreads(__tstate);
26759 if (PyErr_Occurred()) SWIG_fail;
26760 }
26761 {
26762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26763 }
26764 return resultobj;
26765 fail:
26766 return NULL;
26767 }
26768
26769
26770 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26771 PyObject *resultobj = 0;
26772 wxDateTime *arg1 = (wxDateTime *) 0 ;
26773 wxDateTime *arg2 = (wxDateTime *) 0 ;
26774 bool result;
26775 void *argp1 = 0 ;
26776 int res1 = 0 ;
26777 void *argp2 = 0 ;
26778 int res2 = 0 ;
26779 PyObject * obj0 = 0 ;
26780 PyObject * obj1 = 0 ;
26781 char * kwnames[] = {
26782 (char *) "self",(char *) "other", NULL
26783 };
26784
26785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
26786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26787 if (!SWIG_IsOK(res1)) {
26788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26789 }
26790 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26791 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26792 if (!SWIG_IsOK(res2)) {
26793 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26794 }
26795 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26796 {
26797 PyThreadState* __tstate = wxPyBeginAllowThreads();
26798 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
26799 wxPyEndAllowThreads(__tstate);
26800 if (PyErr_Occurred()) SWIG_fail;
26801 }
26802 {
26803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26804 }
26805 return resultobj;
26806 fail:
26807 return NULL;
26808 }
26809
26810
26811 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26812 PyObject *resultobj = 0;
26813 wxDateTime *arg1 = (wxDateTime *) 0 ;
26814 wxDateTime *arg2 = (wxDateTime *) 0 ;
26815 bool result;
26816 void *argp1 = 0 ;
26817 int res1 = 0 ;
26818 void *argp2 = 0 ;
26819 int res2 = 0 ;
26820 PyObject * obj0 = 0 ;
26821 PyObject * obj1 = 0 ;
26822 char * kwnames[] = {
26823 (char *) "self",(char *) "other", NULL
26824 };
26825
26826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
26827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26828 if (!SWIG_IsOK(res1)) {
26829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26830 }
26831 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26832 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26833 if (!SWIG_IsOK(res2)) {
26834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26835 }
26836 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26837 {
26838 PyThreadState* __tstate = wxPyBeginAllowThreads();
26839 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
26840 wxPyEndAllowThreads(__tstate);
26841 if (PyErr_Occurred()) SWIG_fail;
26842 }
26843 {
26844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26845 }
26846 return resultobj;
26847 fail:
26848 return NULL;
26849 }
26850
26851
26852 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26853 PyObject *resultobj = 0;
26854 wxDateTime *arg1 = (wxDateTime *) 0 ;
26855 wxString *arg2 = 0 ;
26856 int result;
26857 void *argp1 = 0 ;
26858 int res1 = 0 ;
26859 bool temp2 = false ;
26860 PyObject * obj0 = 0 ;
26861 PyObject * obj1 = 0 ;
26862 char * kwnames[] = {
26863 (char *) "self",(char *) "date", NULL
26864 };
26865
26866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
26867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26868 if (!SWIG_IsOK(res1)) {
26869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
26870 }
26871 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26872 {
26873 arg2 = wxString_in_helper(obj1);
26874 if (arg2 == NULL) SWIG_fail;
26875 temp2 = true;
26876 }
26877 {
26878 PyThreadState* __tstate = wxPyBeginAllowThreads();
26879 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
26880 wxPyEndAllowThreads(__tstate);
26881 if (PyErr_Occurred()) SWIG_fail;
26882 }
26883 resultobj = SWIG_From_int(static_cast< int >(result));
26884 {
26885 if (temp2)
26886 delete arg2;
26887 }
26888 return resultobj;
26889 fail:
26890 {
26891 if (temp2)
26892 delete arg2;
26893 }
26894 return NULL;
26895 }
26896
26897
26898 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26899 PyObject *resultobj = 0;
26900 wxDateTime *arg1 = (wxDateTime *) 0 ;
26901 wxString *arg2 = 0 ;
26902 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
26903 wxString *arg3 = (wxString *) &arg3_defvalue ;
26904 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
26905 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
26906 int result;
26907 void *argp1 = 0 ;
26908 int res1 = 0 ;
26909 bool temp2 = false ;
26910 bool temp3 = false ;
26911 void *argp4 = 0 ;
26912 int res4 = 0 ;
26913 PyObject * obj0 = 0 ;
26914 PyObject * obj1 = 0 ;
26915 PyObject * obj2 = 0 ;
26916 PyObject * obj3 = 0 ;
26917 char * kwnames[] = {
26918 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
26919 };
26920
26921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26923 if (!SWIG_IsOK(res1)) {
26924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
26925 }
26926 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26927 {
26928 arg2 = wxString_in_helper(obj1);
26929 if (arg2 == NULL) SWIG_fail;
26930 temp2 = true;
26931 }
26932 if (obj2) {
26933 {
26934 arg3 = wxString_in_helper(obj2);
26935 if (arg3 == NULL) SWIG_fail;
26936 temp3 = true;
26937 }
26938 }
26939 if (obj3) {
26940 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
26941 if (!SWIG_IsOK(res4)) {
26942 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26943 }
26944 if (!argp4) {
26945 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26946 }
26947 arg4 = reinterpret_cast< wxDateTime * >(argp4);
26948 }
26949 {
26950 PyThreadState* __tstate = wxPyBeginAllowThreads();
26951 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
26952 wxPyEndAllowThreads(__tstate);
26953 if (PyErr_Occurred()) SWIG_fail;
26954 }
26955 resultobj = SWIG_From_int(static_cast< int >(result));
26956 {
26957 if (temp2)
26958 delete arg2;
26959 }
26960 {
26961 if (temp3)
26962 delete arg3;
26963 }
26964 return resultobj;
26965 fail:
26966 {
26967 if (temp2)
26968 delete arg2;
26969 }
26970 {
26971 if (temp3)
26972 delete arg3;
26973 }
26974 return NULL;
26975 }
26976
26977
26978 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26979 PyObject *resultobj = 0;
26980 wxDateTime *arg1 = (wxDateTime *) 0 ;
26981 wxString *arg2 = 0 ;
26982 int result;
26983 void *argp1 = 0 ;
26984 int res1 = 0 ;
26985 bool temp2 = false ;
26986 PyObject * obj0 = 0 ;
26987 PyObject * obj1 = 0 ;
26988 char * kwnames[] = {
26989 (char *) "self",(char *) "datetime", NULL
26990 };
26991
26992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
26993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26994 if (!SWIG_IsOK(res1)) {
26995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
26996 }
26997 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26998 {
26999 arg2 = wxString_in_helper(obj1);
27000 if (arg2 == NULL) SWIG_fail;
27001 temp2 = true;
27002 }
27003 {
27004 PyThreadState* __tstate = wxPyBeginAllowThreads();
27005 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
27006 wxPyEndAllowThreads(__tstate);
27007 if (PyErr_Occurred()) SWIG_fail;
27008 }
27009 resultobj = SWIG_From_int(static_cast< int >(result));
27010 {
27011 if (temp2)
27012 delete arg2;
27013 }
27014 return resultobj;
27015 fail:
27016 {
27017 if (temp2)
27018 delete arg2;
27019 }
27020 return NULL;
27021 }
27022
27023
27024 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27025 PyObject *resultobj = 0;
27026 wxDateTime *arg1 = (wxDateTime *) 0 ;
27027 wxString *arg2 = 0 ;
27028 int result;
27029 void *argp1 = 0 ;
27030 int res1 = 0 ;
27031 bool temp2 = false ;
27032 PyObject * obj0 = 0 ;
27033 PyObject * obj1 = 0 ;
27034 char * kwnames[] = {
27035 (char *) "self",(char *) "date", NULL
27036 };
27037
27038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
27039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27040 if (!SWIG_IsOK(res1)) {
27041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
27042 }
27043 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27044 {
27045 arg2 = wxString_in_helper(obj1);
27046 if (arg2 == NULL) SWIG_fail;
27047 temp2 = true;
27048 }
27049 {
27050 PyThreadState* __tstate = wxPyBeginAllowThreads();
27051 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
27052 wxPyEndAllowThreads(__tstate);
27053 if (PyErr_Occurred()) SWIG_fail;
27054 }
27055 resultobj = SWIG_From_int(static_cast< int >(result));
27056 {
27057 if (temp2)
27058 delete arg2;
27059 }
27060 return resultobj;
27061 fail:
27062 {
27063 if (temp2)
27064 delete arg2;
27065 }
27066 return NULL;
27067 }
27068
27069
27070 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27071 PyObject *resultobj = 0;
27072 wxDateTime *arg1 = (wxDateTime *) 0 ;
27073 wxString *arg2 = 0 ;
27074 int result;
27075 void *argp1 = 0 ;
27076 int res1 = 0 ;
27077 bool temp2 = false ;
27078 PyObject * obj0 = 0 ;
27079 PyObject * obj1 = 0 ;
27080 char * kwnames[] = {
27081 (char *) "self",(char *) "time", NULL
27082 };
27083
27084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
27085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27086 if (!SWIG_IsOK(res1)) {
27087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27088 }
27089 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27090 {
27091 arg2 = wxString_in_helper(obj1);
27092 if (arg2 == NULL) SWIG_fail;
27093 temp2 = true;
27094 }
27095 {
27096 PyThreadState* __tstate = wxPyBeginAllowThreads();
27097 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
27098 wxPyEndAllowThreads(__tstate);
27099 if (PyErr_Occurred()) SWIG_fail;
27100 }
27101 resultobj = SWIG_From_int(static_cast< int >(result));
27102 {
27103 if (temp2)
27104 delete arg2;
27105 }
27106 return resultobj;
27107 fail:
27108 {
27109 if (temp2)
27110 delete arg2;
27111 }
27112 return NULL;
27113 }
27114
27115
27116 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27117 PyObject *resultobj = 0;
27118 wxDateTime *arg1 = (wxDateTime *) 0 ;
27119 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
27120 wxString *arg2 = (wxString *) &arg2_defvalue ;
27121 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
27122 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
27123 wxString result;
27124 void *argp1 = 0 ;
27125 int res1 = 0 ;
27126 bool temp2 = false ;
27127 bool temp3 = false ;
27128 PyObject * obj0 = 0 ;
27129 PyObject * obj1 = 0 ;
27130 PyObject * obj2 = 0 ;
27131 char * kwnames[] = {
27132 (char *) "self",(char *) "format",(char *) "tz", NULL
27133 };
27134
27135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27137 if (!SWIG_IsOK(res1)) {
27138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27139 }
27140 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27141 if (obj1) {
27142 {
27143 arg2 = wxString_in_helper(obj1);
27144 if (arg2 == NULL) SWIG_fail;
27145 temp2 = true;
27146 }
27147 }
27148 if (obj2) {
27149 {
27150 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
27151 temp3 = true;
27152 }
27153 }
27154 {
27155 PyThreadState* __tstate = wxPyBeginAllowThreads();
27156 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
27157 wxPyEndAllowThreads(__tstate);
27158 if (PyErr_Occurred()) SWIG_fail;
27159 }
27160 {
27161 #if wxUSE_UNICODE
27162 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27163 #else
27164 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27165 #endif
27166 }
27167 {
27168 if (temp2)
27169 delete arg2;
27170 }
27171 {
27172 if (temp3) delete arg3;
27173 }
27174 return resultobj;
27175 fail:
27176 {
27177 if (temp2)
27178 delete arg2;
27179 }
27180 {
27181 if (temp3) delete arg3;
27182 }
27183 return NULL;
27184 }
27185
27186
27187 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27188 PyObject *resultobj = 0;
27189 wxDateTime *arg1 = (wxDateTime *) 0 ;
27190 wxString result;
27191 void *argp1 = 0 ;
27192 int res1 = 0 ;
27193 PyObject *swig_obj[1] ;
27194
27195 if (!args) SWIG_fail;
27196 swig_obj[0] = args;
27197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27198 if (!SWIG_IsOK(res1)) {
27199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27200 }
27201 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27202 {
27203 PyThreadState* __tstate = wxPyBeginAllowThreads();
27204 result = ((wxDateTime const *)arg1)->FormatDate();
27205 wxPyEndAllowThreads(__tstate);
27206 if (PyErr_Occurred()) SWIG_fail;
27207 }
27208 {
27209 #if wxUSE_UNICODE
27210 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27211 #else
27212 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27213 #endif
27214 }
27215 return resultobj;
27216 fail:
27217 return NULL;
27218 }
27219
27220
27221 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27222 PyObject *resultobj = 0;
27223 wxDateTime *arg1 = (wxDateTime *) 0 ;
27224 wxString result;
27225 void *argp1 = 0 ;
27226 int res1 = 0 ;
27227 PyObject *swig_obj[1] ;
27228
27229 if (!args) SWIG_fail;
27230 swig_obj[0] = args;
27231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27232 if (!SWIG_IsOK(res1)) {
27233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27234 }
27235 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27236 {
27237 PyThreadState* __tstate = wxPyBeginAllowThreads();
27238 result = ((wxDateTime const *)arg1)->FormatTime();
27239 wxPyEndAllowThreads(__tstate);
27240 if (PyErr_Occurred()) SWIG_fail;
27241 }
27242 {
27243 #if wxUSE_UNICODE
27244 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27245 #else
27246 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27247 #endif
27248 }
27249 return resultobj;
27250 fail:
27251 return NULL;
27252 }
27253
27254
27255 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27256 PyObject *resultobj = 0;
27257 wxDateTime *arg1 = (wxDateTime *) 0 ;
27258 wxString result;
27259 void *argp1 = 0 ;
27260 int res1 = 0 ;
27261 PyObject *swig_obj[1] ;
27262
27263 if (!args) SWIG_fail;
27264 swig_obj[0] = args;
27265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27266 if (!SWIG_IsOK(res1)) {
27267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27268 }
27269 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27270 {
27271 PyThreadState* __tstate = wxPyBeginAllowThreads();
27272 result = ((wxDateTime const *)arg1)->FormatISODate();
27273 wxPyEndAllowThreads(__tstate);
27274 if (PyErr_Occurred()) SWIG_fail;
27275 }
27276 {
27277 #if wxUSE_UNICODE
27278 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27279 #else
27280 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27281 #endif
27282 }
27283 return resultobj;
27284 fail:
27285 return NULL;
27286 }
27287
27288
27289 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27290 PyObject *resultobj = 0;
27291 wxDateTime *arg1 = (wxDateTime *) 0 ;
27292 wxString result;
27293 void *argp1 = 0 ;
27294 int res1 = 0 ;
27295 PyObject *swig_obj[1] ;
27296
27297 if (!args) SWIG_fail;
27298 swig_obj[0] = args;
27299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27300 if (!SWIG_IsOK(res1)) {
27301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27302 }
27303 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27304 {
27305 PyThreadState* __tstate = wxPyBeginAllowThreads();
27306 result = ((wxDateTime const *)arg1)->FormatISOTime();
27307 wxPyEndAllowThreads(__tstate);
27308 if (PyErr_Occurred()) SWIG_fail;
27309 }
27310 {
27311 #if wxUSE_UNICODE
27312 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27313 #else
27314 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27315 #endif
27316 }
27317 return resultobj;
27318 fail:
27319 return NULL;
27320 }
27321
27322
27323 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27324 PyObject *obj;
27325 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27326 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
27327 return SWIG_Py_Void();
27328 }
27329
27330 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27331 return SWIG_Python_InitShadowInstance(args);
27332 }
27333
27334 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27335 PyObject *resultobj = 0;
27336 long arg1 ;
27337 wxTimeSpan result;
27338 long val1 ;
27339 int ecode1 = 0 ;
27340 PyObject * obj0 = 0 ;
27341 char * kwnames[] = {
27342 (char *) "ms", NULL
27343 };
27344
27345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
27346 ecode1 = SWIG_AsVal_long(obj0, &val1);
27347 if (!SWIG_IsOK(ecode1)) {
27348 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
27349 }
27350 arg1 = static_cast< long >(val1);
27351 {
27352 PyThreadState* __tstate = wxPyBeginAllowThreads();
27353 result = wxTimeSpan::Milliseconds(arg1);
27354 wxPyEndAllowThreads(__tstate);
27355 if (PyErr_Occurred()) SWIG_fail;
27356 }
27357 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27358 return resultobj;
27359 fail:
27360 return NULL;
27361 }
27362
27363
27364 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27365 PyObject *resultobj = 0;
27366 wxTimeSpan result;
27367
27368 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
27369 {
27370 PyThreadState* __tstate = wxPyBeginAllowThreads();
27371 result = wxTimeSpan::Millisecond();
27372 wxPyEndAllowThreads(__tstate);
27373 if (PyErr_Occurred()) SWIG_fail;
27374 }
27375 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27376 return resultobj;
27377 fail:
27378 return NULL;
27379 }
27380
27381
27382 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27383 PyObject *resultobj = 0;
27384 long arg1 ;
27385 wxTimeSpan result;
27386 long val1 ;
27387 int ecode1 = 0 ;
27388 PyObject * obj0 = 0 ;
27389 char * kwnames[] = {
27390 (char *) "sec", NULL
27391 };
27392
27393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
27394 ecode1 = SWIG_AsVal_long(obj0, &val1);
27395 if (!SWIG_IsOK(ecode1)) {
27396 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
27397 }
27398 arg1 = static_cast< long >(val1);
27399 {
27400 PyThreadState* __tstate = wxPyBeginAllowThreads();
27401 result = wxTimeSpan::Seconds(arg1);
27402 wxPyEndAllowThreads(__tstate);
27403 if (PyErr_Occurred()) SWIG_fail;
27404 }
27405 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27406 return resultobj;
27407 fail:
27408 return NULL;
27409 }
27410
27411
27412 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27413 PyObject *resultobj = 0;
27414 wxTimeSpan result;
27415
27416 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
27417 {
27418 PyThreadState* __tstate = wxPyBeginAllowThreads();
27419 result = wxTimeSpan::Second();
27420 wxPyEndAllowThreads(__tstate);
27421 if (PyErr_Occurred()) SWIG_fail;
27422 }
27423 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27424 return resultobj;
27425 fail:
27426 return NULL;
27427 }
27428
27429
27430 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27431 PyObject *resultobj = 0;
27432 long arg1 ;
27433 wxTimeSpan result;
27434 long val1 ;
27435 int ecode1 = 0 ;
27436 PyObject * obj0 = 0 ;
27437 char * kwnames[] = {
27438 (char *) "min", NULL
27439 };
27440
27441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
27442 ecode1 = SWIG_AsVal_long(obj0, &val1);
27443 if (!SWIG_IsOK(ecode1)) {
27444 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
27445 }
27446 arg1 = static_cast< long >(val1);
27447 {
27448 PyThreadState* __tstate = wxPyBeginAllowThreads();
27449 result = wxTimeSpan::Minutes(arg1);
27450 wxPyEndAllowThreads(__tstate);
27451 if (PyErr_Occurred()) SWIG_fail;
27452 }
27453 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27454 return resultobj;
27455 fail:
27456 return NULL;
27457 }
27458
27459
27460 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27461 PyObject *resultobj = 0;
27462 wxTimeSpan result;
27463
27464 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
27465 {
27466 PyThreadState* __tstate = wxPyBeginAllowThreads();
27467 result = wxTimeSpan::Minute();
27468 wxPyEndAllowThreads(__tstate);
27469 if (PyErr_Occurred()) SWIG_fail;
27470 }
27471 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27472 return resultobj;
27473 fail:
27474 return NULL;
27475 }
27476
27477
27478 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27479 PyObject *resultobj = 0;
27480 long arg1 ;
27481 wxTimeSpan result;
27482 long val1 ;
27483 int ecode1 = 0 ;
27484 PyObject * obj0 = 0 ;
27485 char * kwnames[] = {
27486 (char *) "hours", NULL
27487 };
27488
27489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
27490 ecode1 = SWIG_AsVal_long(obj0, &val1);
27491 if (!SWIG_IsOK(ecode1)) {
27492 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
27493 }
27494 arg1 = static_cast< long >(val1);
27495 {
27496 PyThreadState* __tstate = wxPyBeginAllowThreads();
27497 result = wxTimeSpan::Hours(arg1);
27498 wxPyEndAllowThreads(__tstate);
27499 if (PyErr_Occurred()) SWIG_fail;
27500 }
27501 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27502 return resultobj;
27503 fail:
27504 return NULL;
27505 }
27506
27507
27508 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27509 PyObject *resultobj = 0;
27510 wxTimeSpan result;
27511
27512 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
27513 {
27514 PyThreadState* __tstate = wxPyBeginAllowThreads();
27515 result = wxTimeSpan::Hour();
27516 wxPyEndAllowThreads(__tstate);
27517 if (PyErr_Occurred()) SWIG_fail;
27518 }
27519 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27520 return resultobj;
27521 fail:
27522 return NULL;
27523 }
27524
27525
27526 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27527 PyObject *resultobj = 0;
27528 long arg1 ;
27529 wxTimeSpan result;
27530 long val1 ;
27531 int ecode1 = 0 ;
27532 PyObject * obj0 = 0 ;
27533 char * kwnames[] = {
27534 (char *) "days", NULL
27535 };
27536
27537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
27538 ecode1 = SWIG_AsVal_long(obj0, &val1);
27539 if (!SWIG_IsOK(ecode1)) {
27540 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
27541 }
27542 arg1 = static_cast< long >(val1);
27543 {
27544 PyThreadState* __tstate = wxPyBeginAllowThreads();
27545 result = wxTimeSpan::Days(arg1);
27546 wxPyEndAllowThreads(__tstate);
27547 if (PyErr_Occurred()) SWIG_fail;
27548 }
27549 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27550 return resultobj;
27551 fail:
27552 return NULL;
27553 }
27554
27555
27556 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27557 PyObject *resultobj = 0;
27558 wxTimeSpan result;
27559
27560 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
27561 {
27562 PyThreadState* __tstate = wxPyBeginAllowThreads();
27563 result = wxTimeSpan::Day();
27564 wxPyEndAllowThreads(__tstate);
27565 if (PyErr_Occurred()) SWIG_fail;
27566 }
27567 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27568 return resultobj;
27569 fail:
27570 return NULL;
27571 }
27572
27573
27574 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27575 PyObject *resultobj = 0;
27576 long arg1 ;
27577 wxTimeSpan result;
27578 long val1 ;
27579 int ecode1 = 0 ;
27580 PyObject * obj0 = 0 ;
27581 char * kwnames[] = {
27582 (char *) "days", NULL
27583 };
27584
27585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
27586 ecode1 = SWIG_AsVal_long(obj0, &val1);
27587 if (!SWIG_IsOK(ecode1)) {
27588 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
27589 }
27590 arg1 = static_cast< long >(val1);
27591 {
27592 PyThreadState* __tstate = wxPyBeginAllowThreads();
27593 result = wxTimeSpan::Weeks(arg1);
27594 wxPyEndAllowThreads(__tstate);
27595 if (PyErr_Occurred()) SWIG_fail;
27596 }
27597 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27598 return resultobj;
27599 fail:
27600 return NULL;
27601 }
27602
27603
27604 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27605 PyObject *resultobj = 0;
27606 wxTimeSpan result;
27607
27608 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
27609 {
27610 PyThreadState* __tstate = wxPyBeginAllowThreads();
27611 result = wxTimeSpan::Week();
27612 wxPyEndAllowThreads(__tstate);
27613 if (PyErr_Occurred()) SWIG_fail;
27614 }
27615 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27616 return resultobj;
27617 fail:
27618 return NULL;
27619 }
27620
27621
27622 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27623 PyObject *resultobj = 0;
27624 long arg1 = (long) 0 ;
27625 long arg2 = (long) 0 ;
27626 long arg3 = (long) 0 ;
27627 long arg4 = (long) 0 ;
27628 wxTimeSpan *result = 0 ;
27629 long val1 ;
27630 int ecode1 = 0 ;
27631 long val2 ;
27632 int ecode2 = 0 ;
27633 long val3 ;
27634 int ecode3 = 0 ;
27635 long val4 ;
27636 int ecode4 = 0 ;
27637 PyObject * obj0 = 0 ;
27638 PyObject * obj1 = 0 ;
27639 PyObject * obj2 = 0 ;
27640 PyObject * obj3 = 0 ;
27641 char * kwnames[] = {
27642 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
27643 };
27644
27645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27646 if (obj0) {
27647 ecode1 = SWIG_AsVal_long(obj0, &val1);
27648 if (!SWIG_IsOK(ecode1)) {
27649 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
27650 }
27651 arg1 = static_cast< long >(val1);
27652 }
27653 if (obj1) {
27654 ecode2 = SWIG_AsVal_long(obj1, &val2);
27655 if (!SWIG_IsOK(ecode2)) {
27656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
27657 }
27658 arg2 = static_cast< long >(val2);
27659 }
27660 if (obj2) {
27661 ecode3 = SWIG_AsVal_long(obj2, &val3);
27662 if (!SWIG_IsOK(ecode3)) {
27663 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
27664 }
27665 arg3 = static_cast< long >(val3);
27666 }
27667 if (obj3) {
27668 ecode4 = SWIG_AsVal_long(obj3, &val4);
27669 if (!SWIG_IsOK(ecode4)) {
27670 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
27671 }
27672 arg4 = static_cast< long >(val4);
27673 }
27674 {
27675 PyThreadState* __tstate = wxPyBeginAllowThreads();
27676 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
27677 wxPyEndAllowThreads(__tstate);
27678 if (PyErr_Occurred()) SWIG_fail;
27679 }
27680 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
27681 return resultobj;
27682 fail:
27683 return NULL;
27684 }
27685
27686
27687 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27688 PyObject *resultobj = 0;
27689 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27690 void *argp1 = 0 ;
27691 int res1 = 0 ;
27692 PyObject *swig_obj[1] ;
27693
27694 if (!args) SWIG_fail;
27695 swig_obj[0] = args;
27696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27697 if (!SWIG_IsOK(res1)) {
27698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27699 }
27700 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27701 {
27702 PyThreadState* __tstate = wxPyBeginAllowThreads();
27703 delete arg1;
27704
27705 wxPyEndAllowThreads(__tstate);
27706 if (PyErr_Occurred()) SWIG_fail;
27707 }
27708 resultobj = SWIG_Py_Void();
27709 return resultobj;
27710 fail:
27711 return NULL;
27712 }
27713
27714
27715 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27716 PyObject *resultobj = 0;
27717 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27718 wxTimeSpan *arg2 = 0 ;
27719 wxTimeSpan *result = 0 ;
27720 void *argp1 = 0 ;
27721 int res1 = 0 ;
27722 void *argp2 = 0 ;
27723 int res2 = 0 ;
27724 PyObject * obj0 = 0 ;
27725 PyObject * obj1 = 0 ;
27726 char * kwnames[] = {
27727 (char *) "self",(char *) "diff", NULL
27728 };
27729
27730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
27731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27732 if (!SWIG_IsOK(res1)) {
27733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27734 }
27735 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27736 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27737 if (!SWIG_IsOK(res2)) {
27738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27739 }
27740 if (!argp2) {
27741 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27742 }
27743 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27744 {
27745 PyThreadState* __tstate = wxPyBeginAllowThreads();
27746 {
27747 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27748 result = (wxTimeSpan *) &_result_ref;
27749 }
27750 wxPyEndAllowThreads(__tstate);
27751 if (PyErr_Occurred()) SWIG_fail;
27752 }
27753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27754 return resultobj;
27755 fail:
27756 return NULL;
27757 }
27758
27759
27760 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27761 PyObject *resultobj = 0;
27762 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27763 wxTimeSpan *arg2 = 0 ;
27764 wxTimeSpan *result = 0 ;
27765 void *argp1 = 0 ;
27766 int res1 = 0 ;
27767 void *argp2 = 0 ;
27768 int res2 = 0 ;
27769 PyObject * obj0 = 0 ;
27770 PyObject * obj1 = 0 ;
27771 char * kwnames[] = {
27772 (char *) "self",(char *) "diff", NULL
27773 };
27774
27775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27777 if (!SWIG_IsOK(res1)) {
27778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27779 }
27780 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27781 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27782 if (!SWIG_IsOK(res2)) {
27783 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27784 }
27785 if (!argp2) {
27786 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27787 }
27788 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27789 {
27790 PyThreadState* __tstate = wxPyBeginAllowThreads();
27791 {
27792 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27793 result = (wxTimeSpan *) &_result_ref;
27794 }
27795 wxPyEndAllowThreads(__tstate);
27796 if (PyErr_Occurred()) SWIG_fail;
27797 }
27798 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27799 return resultobj;
27800 fail:
27801 return NULL;
27802 }
27803
27804
27805 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27806 PyObject *resultobj = 0;
27807 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27808 int arg2 ;
27809 wxTimeSpan *result = 0 ;
27810 void *argp1 = 0 ;
27811 int res1 = 0 ;
27812 int val2 ;
27813 int ecode2 = 0 ;
27814 PyObject * obj0 = 0 ;
27815 PyObject * obj1 = 0 ;
27816 char * kwnames[] = {
27817 (char *) "self",(char *) "n", NULL
27818 };
27819
27820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
27821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27822 if (!SWIG_IsOK(res1)) {
27823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27824 }
27825 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27826 ecode2 = SWIG_AsVal_int(obj1, &val2);
27827 if (!SWIG_IsOK(ecode2)) {
27828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
27829 }
27830 arg2 = static_cast< int >(val2);
27831 {
27832 PyThreadState* __tstate = wxPyBeginAllowThreads();
27833 {
27834 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
27835 result = (wxTimeSpan *) &_result_ref;
27836 }
27837 wxPyEndAllowThreads(__tstate);
27838 if (PyErr_Occurred()) SWIG_fail;
27839 }
27840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27841 return resultobj;
27842 fail:
27843 return NULL;
27844 }
27845
27846
27847 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27848 PyObject *resultobj = 0;
27849 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27850 wxTimeSpan *result = 0 ;
27851 void *argp1 = 0 ;
27852 int res1 = 0 ;
27853 PyObject *swig_obj[1] ;
27854
27855 if (!args) SWIG_fail;
27856 swig_obj[0] = args;
27857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27858 if (!SWIG_IsOK(res1)) {
27859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27860 }
27861 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27862 {
27863 PyThreadState* __tstate = wxPyBeginAllowThreads();
27864 {
27865 wxTimeSpan &_result_ref = (arg1)->Neg();
27866 result = (wxTimeSpan *) &_result_ref;
27867 }
27868 wxPyEndAllowThreads(__tstate);
27869 if (PyErr_Occurred()) SWIG_fail;
27870 }
27871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27872 return resultobj;
27873 fail:
27874 return NULL;
27875 }
27876
27877
27878 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27879 PyObject *resultobj = 0;
27880 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27881 wxTimeSpan result;
27882 void *argp1 = 0 ;
27883 int res1 = 0 ;
27884 PyObject *swig_obj[1] ;
27885
27886 if (!args) SWIG_fail;
27887 swig_obj[0] = args;
27888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27889 if (!SWIG_IsOK(res1)) {
27890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
27891 }
27892 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27893 {
27894 PyThreadState* __tstate = wxPyBeginAllowThreads();
27895 result = ((wxTimeSpan const *)arg1)->Abs();
27896 wxPyEndAllowThreads(__tstate);
27897 if (PyErr_Occurred()) SWIG_fail;
27898 }
27899 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27900 return resultobj;
27901 fail:
27902 return NULL;
27903 }
27904
27905
27906 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27907 PyObject *resultobj = 0;
27908 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27909 wxTimeSpan *arg2 = 0 ;
27910 wxTimeSpan *result = 0 ;
27911 void *argp1 = 0 ;
27912 int res1 = 0 ;
27913 void *argp2 = 0 ;
27914 int res2 = 0 ;
27915 PyObject * obj0 = 0 ;
27916 PyObject * obj1 = 0 ;
27917 char * kwnames[] = {
27918 (char *) "self",(char *) "diff", NULL
27919 };
27920
27921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
27922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27923 if (!SWIG_IsOK(res1)) {
27924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27925 }
27926 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27927 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27928 if (!SWIG_IsOK(res2)) {
27929 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27930 }
27931 if (!argp2) {
27932 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27933 }
27934 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27935 {
27936 PyThreadState* __tstate = wxPyBeginAllowThreads();
27937 {
27938 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27939 result = (wxTimeSpan *) &_result_ref;
27940 }
27941 wxPyEndAllowThreads(__tstate);
27942 if (PyErr_Occurred()) SWIG_fail;
27943 }
27944 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27945 return resultobj;
27946 fail:
27947 return NULL;
27948 }
27949
27950
27951 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27952 PyObject *resultobj = 0;
27953 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27954 wxTimeSpan *arg2 = 0 ;
27955 wxTimeSpan *result = 0 ;
27956 void *argp1 = 0 ;
27957 int res1 = 0 ;
27958 void *argp2 = 0 ;
27959 int res2 = 0 ;
27960 PyObject * obj0 = 0 ;
27961 PyObject * obj1 = 0 ;
27962 char * kwnames[] = {
27963 (char *) "self",(char *) "diff", NULL
27964 };
27965
27966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
27967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27968 if (!SWIG_IsOK(res1)) {
27969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27970 }
27971 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27972 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27973 if (!SWIG_IsOK(res2)) {
27974 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27975 }
27976 if (!argp2) {
27977 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27978 }
27979 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27980 {
27981 PyThreadState* __tstate = wxPyBeginAllowThreads();
27982 {
27983 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27984 result = (wxTimeSpan *) &_result_ref;
27985 }
27986 wxPyEndAllowThreads(__tstate);
27987 if (PyErr_Occurred()) SWIG_fail;
27988 }
27989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27990 return resultobj;
27991 fail:
27992 return NULL;
27993 }
27994
27995
27996 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27997 PyObject *resultobj = 0;
27998 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27999 int arg2 ;
28000 wxTimeSpan *result = 0 ;
28001 void *argp1 = 0 ;
28002 int res1 = 0 ;
28003 int val2 ;
28004 int ecode2 = 0 ;
28005 PyObject * obj0 = 0 ;
28006 PyObject * obj1 = 0 ;
28007 char * kwnames[] = {
28008 (char *) "self",(char *) "n", NULL
28009 };
28010
28011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
28012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28013 if (!SWIG_IsOK(res1)) {
28014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28015 }
28016 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28017 ecode2 = SWIG_AsVal_int(obj1, &val2);
28018 if (!SWIG_IsOK(ecode2)) {
28019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
28020 }
28021 arg2 = static_cast< int >(val2);
28022 {
28023 PyThreadState* __tstate = wxPyBeginAllowThreads();
28024 {
28025 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
28026 result = (wxTimeSpan *) &_result_ref;
28027 }
28028 wxPyEndAllowThreads(__tstate);
28029 if (PyErr_Occurred()) SWIG_fail;
28030 }
28031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28032 return resultobj;
28033 fail:
28034 return NULL;
28035 }
28036
28037
28038 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28039 PyObject *resultobj = 0;
28040 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28041 wxTimeSpan *result = 0 ;
28042 void *argp1 = 0 ;
28043 int res1 = 0 ;
28044 PyObject *swig_obj[1] ;
28045
28046 if (!args) SWIG_fail;
28047 swig_obj[0] = args;
28048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28049 if (!SWIG_IsOK(res1)) {
28050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28051 }
28052 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28053 {
28054 PyThreadState* __tstate = wxPyBeginAllowThreads();
28055 {
28056 wxTimeSpan &_result_ref = (arg1)->operator -();
28057 result = (wxTimeSpan *) &_result_ref;
28058 }
28059 wxPyEndAllowThreads(__tstate);
28060 if (PyErr_Occurred()) SWIG_fail;
28061 }
28062 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28063 return resultobj;
28064 fail:
28065 return NULL;
28066 }
28067
28068
28069 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28070 PyObject *resultobj = 0;
28071 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28072 wxTimeSpan *arg2 = 0 ;
28073 wxTimeSpan result;
28074 void *argp1 = 0 ;
28075 int res1 = 0 ;
28076 void *argp2 = 0 ;
28077 int res2 = 0 ;
28078 PyObject * obj0 = 0 ;
28079 PyObject * obj1 = 0 ;
28080 char * kwnames[] = {
28081 (char *) "self",(char *) "other", NULL
28082 };
28083
28084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
28085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28086 if (!SWIG_IsOK(res1)) {
28087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28088 }
28089 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28090 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28091 if (!SWIG_IsOK(res2)) {
28092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28093 }
28094 if (!argp2) {
28095 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28096 }
28097 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28098 {
28099 PyThreadState* __tstate = wxPyBeginAllowThreads();
28100 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
28101 wxPyEndAllowThreads(__tstate);
28102 if (PyErr_Occurred()) SWIG_fail;
28103 }
28104 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28105 return resultobj;
28106 fail:
28107 return NULL;
28108 }
28109
28110
28111 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28112 PyObject *resultobj = 0;
28113 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28114 wxTimeSpan *arg2 = 0 ;
28115 wxTimeSpan result;
28116 void *argp1 = 0 ;
28117 int res1 = 0 ;
28118 void *argp2 = 0 ;
28119 int res2 = 0 ;
28120 PyObject * obj0 = 0 ;
28121 PyObject * obj1 = 0 ;
28122 char * kwnames[] = {
28123 (char *) "self",(char *) "other", NULL
28124 };
28125
28126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
28127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28128 if (!SWIG_IsOK(res1)) {
28129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28130 }
28131 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28132 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28133 if (!SWIG_IsOK(res2)) {
28134 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28135 }
28136 if (!argp2) {
28137 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28138 }
28139 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28140 {
28141 PyThreadState* __tstate = wxPyBeginAllowThreads();
28142 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
28143 wxPyEndAllowThreads(__tstate);
28144 if (PyErr_Occurred()) SWIG_fail;
28145 }
28146 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28147 return resultobj;
28148 fail:
28149 return NULL;
28150 }
28151
28152
28153 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28154 PyObject *resultobj = 0;
28155 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28156 int arg2 ;
28157 wxTimeSpan result;
28158 void *argp1 = 0 ;
28159 int res1 = 0 ;
28160 int val2 ;
28161 int ecode2 = 0 ;
28162 PyObject * obj0 = 0 ;
28163 PyObject * obj1 = 0 ;
28164 char * kwnames[] = {
28165 (char *) "self",(char *) "n", NULL
28166 };
28167
28168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
28169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28170 if (!SWIG_IsOK(res1)) {
28171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28172 }
28173 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28174 ecode2 = SWIG_AsVal_int(obj1, &val2);
28175 if (!SWIG_IsOK(ecode2)) {
28176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
28177 }
28178 arg2 = static_cast< int >(val2);
28179 {
28180 PyThreadState* __tstate = wxPyBeginAllowThreads();
28181 result = wxTimeSpan___mul__(arg1,arg2);
28182 wxPyEndAllowThreads(__tstate);
28183 if (PyErr_Occurred()) SWIG_fail;
28184 }
28185 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28186 return resultobj;
28187 fail:
28188 return NULL;
28189 }
28190
28191
28192 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28193 PyObject *resultobj = 0;
28194 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28195 int arg2 ;
28196 wxTimeSpan result;
28197 void *argp1 = 0 ;
28198 int res1 = 0 ;
28199 int val2 ;
28200 int ecode2 = 0 ;
28201 PyObject * obj0 = 0 ;
28202 PyObject * obj1 = 0 ;
28203 char * kwnames[] = {
28204 (char *) "self",(char *) "n", NULL
28205 };
28206
28207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
28208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28209 if (!SWIG_IsOK(res1)) {
28210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28211 }
28212 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28213 ecode2 = SWIG_AsVal_int(obj1, &val2);
28214 if (!SWIG_IsOK(ecode2)) {
28215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
28216 }
28217 arg2 = static_cast< int >(val2);
28218 {
28219 PyThreadState* __tstate = wxPyBeginAllowThreads();
28220 result = wxTimeSpan___rmul__(arg1,arg2);
28221 wxPyEndAllowThreads(__tstate);
28222 if (PyErr_Occurred()) SWIG_fail;
28223 }
28224 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28225 return resultobj;
28226 fail:
28227 return NULL;
28228 }
28229
28230
28231 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28232 PyObject *resultobj = 0;
28233 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28234 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28235 bool result;
28236 void *argp1 = 0 ;
28237 int res1 = 0 ;
28238 void *argp2 = 0 ;
28239 int res2 = 0 ;
28240 PyObject * obj0 = 0 ;
28241 PyObject * obj1 = 0 ;
28242 char * kwnames[] = {
28243 (char *) "self",(char *) "other", NULL
28244 };
28245
28246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28248 if (!SWIG_IsOK(res1)) {
28249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28250 }
28251 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28252 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28253 if (!SWIG_IsOK(res2)) {
28254 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28255 }
28256 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28257 {
28258 PyThreadState* __tstate = wxPyBeginAllowThreads();
28259 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
28260 wxPyEndAllowThreads(__tstate);
28261 if (PyErr_Occurred()) SWIG_fail;
28262 }
28263 {
28264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28265 }
28266 return resultobj;
28267 fail:
28268 return NULL;
28269 }
28270
28271
28272 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28273 PyObject *resultobj = 0;
28274 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28275 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28276 bool result;
28277 void *argp1 = 0 ;
28278 int res1 = 0 ;
28279 void *argp2 = 0 ;
28280 int res2 = 0 ;
28281 PyObject * obj0 = 0 ;
28282 PyObject * obj1 = 0 ;
28283 char * kwnames[] = {
28284 (char *) "self",(char *) "other", NULL
28285 };
28286
28287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28289 if (!SWIG_IsOK(res1)) {
28290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28291 }
28292 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28293 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28294 if (!SWIG_IsOK(res2)) {
28295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28296 }
28297 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28298 {
28299 PyThreadState* __tstate = wxPyBeginAllowThreads();
28300 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
28301 wxPyEndAllowThreads(__tstate);
28302 if (PyErr_Occurred()) SWIG_fail;
28303 }
28304 {
28305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28306 }
28307 return resultobj;
28308 fail:
28309 return NULL;
28310 }
28311
28312
28313 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28314 PyObject *resultobj = 0;
28315 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28316 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28317 bool result;
28318 void *argp1 = 0 ;
28319 int res1 = 0 ;
28320 void *argp2 = 0 ;
28321 int res2 = 0 ;
28322 PyObject * obj0 = 0 ;
28323 PyObject * obj1 = 0 ;
28324 char * kwnames[] = {
28325 (char *) "self",(char *) "other", NULL
28326 };
28327
28328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28330 if (!SWIG_IsOK(res1)) {
28331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28332 }
28333 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28334 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28335 if (!SWIG_IsOK(res2)) {
28336 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28337 }
28338 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28339 {
28340 PyThreadState* __tstate = wxPyBeginAllowThreads();
28341 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
28342 wxPyEndAllowThreads(__tstate);
28343 if (PyErr_Occurred()) SWIG_fail;
28344 }
28345 {
28346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28347 }
28348 return resultobj;
28349 fail:
28350 return NULL;
28351 }
28352
28353
28354 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28355 PyObject *resultobj = 0;
28356 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28357 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28358 bool result;
28359 void *argp1 = 0 ;
28360 int res1 = 0 ;
28361 void *argp2 = 0 ;
28362 int res2 = 0 ;
28363 PyObject * obj0 = 0 ;
28364 PyObject * obj1 = 0 ;
28365 char * kwnames[] = {
28366 (char *) "self",(char *) "other", NULL
28367 };
28368
28369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28371 if (!SWIG_IsOK(res1)) {
28372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28373 }
28374 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28375 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28376 if (!SWIG_IsOK(res2)) {
28377 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28378 }
28379 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28380 {
28381 PyThreadState* __tstate = wxPyBeginAllowThreads();
28382 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
28383 wxPyEndAllowThreads(__tstate);
28384 if (PyErr_Occurred()) SWIG_fail;
28385 }
28386 {
28387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28388 }
28389 return resultobj;
28390 fail:
28391 return NULL;
28392 }
28393
28394
28395 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28396 PyObject *resultobj = 0;
28397 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28398 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28399 bool result;
28400 void *argp1 = 0 ;
28401 int res1 = 0 ;
28402 void *argp2 = 0 ;
28403 int res2 = 0 ;
28404 PyObject * obj0 = 0 ;
28405 PyObject * obj1 = 0 ;
28406 char * kwnames[] = {
28407 (char *) "self",(char *) "other", NULL
28408 };
28409
28410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28412 if (!SWIG_IsOK(res1)) {
28413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28414 }
28415 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28416 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28417 if (!SWIG_IsOK(res2)) {
28418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28419 }
28420 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28421 {
28422 PyThreadState* __tstate = wxPyBeginAllowThreads();
28423 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
28424 wxPyEndAllowThreads(__tstate);
28425 if (PyErr_Occurred()) SWIG_fail;
28426 }
28427 {
28428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28429 }
28430 return resultobj;
28431 fail:
28432 return NULL;
28433 }
28434
28435
28436 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28437 PyObject *resultobj = 0;
28438 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28439 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28440 bool result;
28441 void *argp1 = 0 ;
28442 int res1 = 0 ;
28443 void *argp2 = 0 ;
28444 int res2 = 0 ;
28445 PyObject * obj0 = 0 ;
28446 PyObject * obj1 = 0 ;
28447 char * kwnames[] = {
28448 (char *) "self",(char *) "other", NULL
28449 };
28450
28451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28453 if (!SWIG_IsOK(res1)) {
28454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28455 }
28456 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28457 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28458 if (!SWIG_IsOK(res2)) {
28459 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28460 }
28461 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28462 {
28463 PyThreadState* __tstate = wxPyBeginAllowThreads();
28464 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
28465 wxPyEndAllowThreads(__tstate);
28466 if (PyErr_Occurred()) SWIG_fail;
28467 }
28468 {
28469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28470 }
28471 return resultobj;
28472 fail:
28473 return NULL;
28474 }
28475
28476
28477 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28478 PyObject *resultobj = 0;
28479 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28480 bool result;
28481 void *argp1 = 0 ;
28482 int res1 = 0 ;
28483 PyObject *swig_obj[1] ;
28484
28485 if (!args) SWIG_fail;
28486 swig_obj[0] = args;
28487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28488 if (!SWIG_IsOK(res1)) {
28489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28490 }
28491 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28492 {
28493 PyThreadState* __tstate = wxPyBeginAllowThreads();
28494 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
28495 wxPyEndAllowThreads(__tstate);
28496 if (PyErr_Occurred()) SWIG_fail;
28497 }
28498 {
28499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28500 }
28501 return resultobj;
28502 fail:
28503 return NULL;
28504 }
28505
28506
28507 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28508 PyObject *resultobj = 0;
28509 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28510 bool result;
28511 void *argp1 = 0 ;
28512 int res1 = 0 ;
28513 PyObject *swig_obj[1] ;
28514
28515 if (!args) SWIG_fail;
28516 swig_obj[0] = args;
28517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28518 if (!SWIG_IsOK(res1)) {
28519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28520 }
28521 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28522 {
28523 PyThreadState* __tstate = wxPyBeginAllowThreads();
28524 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
28525 wxPyEndAllowThreads(__tstate);
28526 if (PyErr_Occurred()) SWIG_fail;
28527 }
28528 {
28529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28530 }
28531 return resultobj;
28532 fail:
28533 return NULL;
28534 }
28535
28536
28537 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28538 PyObject *resultobj = 0;
28539 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28540 bool result;
28541 void *argp1 = 0 ;
28542 int res1 = 0 ;
28543 PyObject *swig_obj[1] ;
28544
28545 if (!args) SWIG_fail;
28546 swig_obj[0] = args;
28547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28548 if (!SWIG_IsOK(res1)) {
28549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28550 }
28551 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28552 {
28553 PyThreadState* __tstate = wxPyBeginAllowThreads();
28554 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
28555 wxPyEndAllowThreads(__tstate);
28556 if (PyErr_Occurred()) SWIG_fail;
28557 }
28558 {
28559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28560 }
28561 return resultobj;
28562 fail:
28563 return NULL;
28564 }
28565
28566
28567 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28568 PyObject *resultobj = 0;
28569 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28570 wxTimeSpan *arg2 = 0 ;
28571 bool result;
28572 void *argp1 = 0 ;
28573 int res1 = 0 ;
28574 void *argp2 = 0 ;
28575 int res2 = 0 ;
28576 PyObject * obj0 = 0 ;
28577 PyObject * obj1 = 0 ;
28578 char * kwnames[] = {
28579 (char *) "self",(char *) "ts", NULL
28580 };
28581
28582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
28583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28584 if (!SWIG_IsOK(res1)) {
28585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28586 }
28587 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28588 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28589 if (!SWIG_IsOK(res2)) {
28590 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28591 }
28592 if (!argp2) {
28593 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28594 }
28595 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28596 {
28597 PyThreadState* __tstate = wxPyBeginAllowThreads();
28598 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
28599 wxPyEndAllowThreads(__tstate);
28600 if (PyErr_Occurred()) SWIG_fail;
28601 }
28602 {
28603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28604 }
28605 return resultobj;
28606 fail:
28607 return NULL;
28608 }
28609
28610
28611 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28612 PyObject *resultobj = 0;
28613 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28614 wxTimeSpan *arg2 = 0 ;
28615 bool result;
28616 void *argp1 = 0 ;
28617 int res1 = 0 ;
28618 void *argp2 = 0 ;
28619 int res2 = 0 ;
28620 PyObject * obj0 = 0 ;
28621 PyObject * obj1 = 0 ;
28622 char * kwnames[] = {
28623 (char *) "self",(char *) "ts", NULL
28624 };
28625
28626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
28627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28628 if (!SWIG_IsOK(res1)) {
28629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28630 }
28631 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28632 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28633 if (!SWIG_IsOK(res2)) {
28634 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28635 }
28636 if (!argp2) {
28637 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28638 }
28639 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28640 {
28641 PyThreadState* __tstate = wxPyBeginAllowThreads();
28642 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
28643 wxPyEndAllowThreads(__tstate);
28644 if (PyErr_Occurred()) SWIG_fail;
28645 }
28646 {
28647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28648 }
28649 return resultobj;
28650 fail:
28651 return NULL;
28652 }
28653
28654
28655 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28656 PyObject *resultobj = 0;
28657 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28658 wxTimeSpan *arg2 = 0 ;
28659 bool result;
28660 void *argp1 = 0 ;
28661 int res1 = 0 ;
28662 void *argp2 = 0 ;
28663 int res2 = 0 ;
28664 PyObject * obj0 = 0 ;
28665 PyObject * obj1 = 0 ;
28666 char * kwnames[] = {
28667 (char *) "self",(char *) "t", NULL
28668 };
28669
28670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
28671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28672 if (!SWIG_IsOK(res1)) {
28673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28674 }
28675 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28676 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28677 if (!SWIG_IsOK(res2)) {
28678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28679 }
28680 if (!argp2) {
28681 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28682 }
28683 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28684 {
28685 PyThreadState* __tstate = wxPyBeginAllowThreads();
28686 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
28687 wxPyEndAllowThreads(__tstate);
28688 if (PyErr_Occurred()) SWIG_fail;
28689 }
28690 {
28691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28692 }
28693 return resultobj;
28694 fail:
28695 return NULL;
28696 }
28697
28698
28699 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28700 PyObject *resultobj = 0;
28701 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28702 int result;
28703 void *argp1 = 0 ;
28704 int res1 = 0 ;
28705 PyObject *swig_obj[1] ;
28706
28707 if (!args) SWIG_fail;
28708 swig_obj[0] = args;
28709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28710 if (!SWIG_IsOK(res1)) {
28711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28712 }
28713 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28714 {
28715 PyThreadState* __tstate = wxPyBeginAllowThreads();
28716 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
28717 wxPyEndAllowThreads(__tstate);
28718 if (PyErr_Occurred()) SWIG_fail;
28719 }
28720 resultobj = SWIG_From_int(static_cast< int >(result));
28721 return resultobj;
28722 fail:
28723 return NULL;
28724 }
28725
28726
28727 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28728 PyObject *resultobj = 0;
28729 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28730 int result;
28731 void *argp1 = 0 ;
28732 int res1 = 0 ;
28733 PyObject *swig_obj[1] ;
28734
28735 if (!args) SWIG_fail;
28736 swig_obj[0] = args;
28737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28738 if (!SWIG_IsOK(res1)) {
28739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28740 }
28741 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28742 {
28743 PyThreadState* __tstate = wxPyBeginAllowThreads();
28744 result = (int)((wxTimeSpan const *)arg1)->GetDays();
28745 wxPyEndAllowThreads(__tstate);
28746 if (PyErr_Occurred()) SWIG_fail;
28747 }
28748 resultobj = SWIG_From_int(static_cast< int >(result));
28749 return resultobj;
28750 fail:
28751 return NULL;
28752 }
28753
28754
28755 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28756 PyObject *resultobj = 0;
28757 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28758 int result;
28759 void *argp1 = 0 ;
28760 int res1 = 0 ;
28761 PyObject *swig_obj[1] ;
28762
28763 if (!args) SWIG_fail;
28764 swig_obj[0] = args;
28765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28766 if (!SWIG_IsOK(res1)) {
28767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28768 }
28769 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28770 {
28771 PyThreadState* __tstate = wxPyBeginAllowThreads();
28772 result = (int)((wxTimeSpan const *)arg1)->GetHours();
28773 wxPyEndAllowThreads(__tstate);
28774 if (PyErr_Occurred()) SWIG_fail;
28775 }
28776 resultobj = SWIG_From_int(static_cast< int >(result));
28777 return resultobj;
28778 fail:
28779 return NULL;
28780 }
28781
28782
28783 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28784 PyObject *resultobj = 0;
28785 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28786 int result;
28787 void *argp1 = 0 ;
28788 int res1 = 0 ;
28789 PyObject *swig_obj[1] ;
28790
28791 if (!args) SWIG_fail;
28792 swig_obj[0] = args;
28793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28794 if (!SWIG_IsOK(res1)) {
28795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28796 }
28797 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28798 {
28799 PyThreadState* __tstate = wxPyBeginAllowThreads();
28800 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
28801 wxPyEndAllowThreads(__tstate);
28802 if (PyErr_Occurred()) SWIG_fail;
28803 }
28804 resultobj = SWIG_From_int(static_cast< int >(result));
28805 return resultobj;
28806 fail:
28807 return NULL;
28808 }
28809
28810
28811 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28812 PyObject *resultobj = 0;
28813 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28814 wxLongLong result;
28815 void *argp1 = 0 ;
28816 int res1 = 0 ;
28817 PyObject *swig_obj[1] ;
28818
28819 if (!args) SWIG_fail;
28820 swig_obj[0] = args;
28821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28822 if (!SWIG_IsOK(res1)) {
28823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28824 }
28825 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28826 {
28827 PyThreadState* __tstate = wxPyBeginAllowThreads();
28828 result = ((wxTimeSpan const *)arg1)->GetSeconds();
28829 wxPyEndAllowThreads(__tstate);
28830 if (PyErr_Occurred()) SWIG_fail;
28831 }
28832 {
28833 PyObject *hi, *lo, *shifter, *shifted;
28834 hi = PyLong_FromLong( (&result)->GetHi() );
28835 lo = PyLong_FromLong( (&result)->GetLo() );
28836 shifter = PyLong_FromLong(32);
28837 shifted = PyNumber_Lshift(hi, shifter);
28838 resultobj = PyNumber_Or(shifted, lo);
28839 Py_DECREF(hi);
28840 Py_DECREF(lo);
28841 Py_DECREF(shifter);
28842 Py_DECREF(shifted);
28843 }
28844 return resultobj;
28845 fail:
28846 return NULL;
28847 }
28848
28849
28850 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28851 PyObject *resultobj = 0;
28852 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28853 wxLongLong result;
28854 void *argp1 = 0 ;
28855 int res1 = 0 ;
28856 PyObject *swig_obj[1] ;
28857
28858 if (!args) SWIG_fail;
28859 swig_obj[0] = args;
28860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28861 if (!SWIG_IsOK(res1)) {
28862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28863 }
28864 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28865 {
28866 PyThreadState* __tstate = wxPyBeginAllowThreads();
28867 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
28868 wxPyEndAllowThreads(__tstate);
28869 if (PyErr_Occurred()) SWIG_fail;
28870 }
28871 {
28872 PyObject *hi, *lo, *shifter, *shifted;
28873 hi = PyLong_FromLong( (&result)->GetHi() );
28874 lo = PyLong_FromLong( (&result)->GetLo() );
28875 shifter = PyLong_FromLong(32);
28876 shifted = PyNumber_Lshift(hi, shifter);
28877 resultobj = PyNumber_Or(shifted, lo);
28878 Py_DECREF(hi);
28879 Py_DECREF(lo);
28880 Py_DECREF(shifter);
28881 Py_DECREF(shifted);
28882 }
28883 return resultobj;
28884 fail:
28885 return NULL;
28886 }
28887
28888
28889 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28890 PyObject *resultobj = 0;
28891 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28892 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
28893 wxString *arg2 = (wxString *) &arg2_defvalue ;
28894 wxString result;
28895 void *argp1 = 0 ;
28896 int res1 = 0 ;
28897 bool temp2 = false ;
28898 PyObject * obj0 = 0 ;
28899 PyObject * obj1 = 0 ;
28900 char * kwnames[] = {
28901 (char *) "self",(char *) "format", NULL
28902 };
28903
28904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
28905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28906 if (!SWIG_IsOK(res1)) {
28907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28908 }
28909 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28910 if (obj1) {
28911 {
28912 arg2 = wxString_in_helper(obj1);
28913 if (arg2 == NULL) SWIG_fail;
28914 temp2 = true;
28915 }
28916 }
28917 {
28918 PyThreadState* __tstate = wxPyBeginAllowThreads();
28919 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
28920 wxPyEndAllowThreads(__tstate);
28921 if (PyErr_Occurred()) SWIG_fail;
28922 }
28923 {
28924 #if wxUSE_UNICODE
28925 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28926 #else
28927 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28928 #endif
28929 }
28930 {
28931 if (temp2)
28932 delete arg2;
28933 }
28934 return resultobj;
28935 fail:
28936 {
28937 if (temp2)
28938 delete arg2;
28939 }
28940 return NULL;
28941 }
28942
28943
28944 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28945 PyObject *obj;
28946 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28947 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
28948 return SWIG_Py_Void();
28949 }
28950
28951 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28952 return SWIG_Python_InitShadowInstance(args);
28953 }
28954
28955 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28956 PyObject *resultobj = 0;
28957 int arg1 = (int) 0 ;
28958 int arg2 = (int) 0 ;
28959 int arg3 = (int) 0 ;
28960 int arg4 = (int) 0 ;
28961 wxDateSpan *result = 0 ;
28962 int val1 ;
28963 int ecode1 = 0 ;
28964 int val2 ;
28965 int ecode2 = 0 ;
28966 int val3 ;
28967 int ecode3 = 0 ;
28968 int val4 ;
28969 int ecode4 = 0 ;
28970 PyObject * obj0 = 0 ;
28971 PyObject * obj1 = 0 ;
28972 PyObject * obj2 = 0 ;
28973 PyObject * obj3 = 0 ;
28974 char * kwnames[] = {
28975 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
28976 };
28977
28978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28979 if (obj0) {
28980 ecode1 = SWIG_AsVal_int(obj0, &val1);
28981 if (!SWIG_IsOK(ecode1)) {
28982 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
28983 }
28984 arg1 = static_cast< int >(val1);
28985 }
28986 if (obj1) {
28987 ecode2 = SWIG_AsVal_int(obj1, &val2);
28988 if (!SWIG_IsOK(ecode2)) {
28989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
28990 }
28991 arg2 = static_cast< int >(val2);
28992 }
28993 if (obj2) {
28994 ecode3 = SWIG_AsVal_int(obj2, &val3);
28995 if (!SWIG_IsOK(ecode3)) {
28996 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
28997 }
28998 arg3 = static_cast< int >(val3);
28999 }
29000 if (obj3) {
29001 ecode4 = SWIG_AsVal_int(obj3, &val4);
29002 if (!SWIG_IsOK(ecode4)) {
29003 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
29004 }
29005 arg4 = static_cast< int >(val4);
29006 }
29007 {
29008 PyThreadState* __tstate = wxPyBeginAllowThreads();
29009 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
29010 wxPyEndAllowThreads(__tstate);
29011 if (PyErr_Occurred()) SWIG_fail;
29012 }
29013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
29014 return resultobj;
29015 fail:
29016 return NULL;
29017 }
29018
29019
29020 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29021 PyObject *resultobj = 0;
29022 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29023 void *argp1 = 0 ;
29024 int res1 = 0 ;
29025 PyObject *swig_obj[1] ;
29026
29027 if (!args) SWIG_fail;
29028 swig_obj[0] = args;
29029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29030 if (!SWIG_IsOK(res1)) {
29031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29032 }
29033 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29034 {
29035 PyThreadState* __tstate = wxPyBeginAllowThreads();
29036 delete arg1;
29037
29038 wxPyEndAllowThreads(__tstate);
29039 if (PyErr_Occurred()) SWIG_fail;
29040 }
29041 resultobj = SWIG_Py_Void();
29042 return resultobj;
29043 fail:
29044 return NULL;
29045 }
29046
29047
29048 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29049 PyObject *resultobj = 0;
29050 int arg1 ;
29051 wxDateSpan result;
29052 int val1 ;
29053 int ecode1 = 0 ;
29054 PyObject * obj0 = 0 ;
29055 char * kwnames[] = {
29056 (char *) "days", NULL
29057 };
29058
29059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
29060 ecode1 = SWIG_AsVal_int(obj0, &val1);
29061 if (!SWIG_IsOK(ecode1)) {
29062 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
29063 }
29064 arg1 = static_cast< int >(val1);
29065 {
29066 PyThreadState* __tstate = wxPyBeginAllowThreads();
29067 result = wxDateSpan::Days(arg1);
29068 wxPyEndAllowThreads(__tstate);
29069 if (PyErr_Occurred()) SWIG_fail;
29070 }
29071 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29072 return resultobj;
29073 fail:
29074 return NULL;
29075 }
29076
29077
29078 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29079 PyObject *resultobj = 0;
29080 wxDateSpan result;
29081
29082 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
29083 {
29084 PyThreadState* __tstate = wxPyBeginAllowThreads();
29085 result = wxDateSpan::Day();
29086 wxPyEndAllowThreads(__tstate);
29087 if (PyErr_Occurred()) SWIG_fail;
29088 }
29089 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29090 return resultobj;
29091 fail:
29092 return NULL;
29093 }
29094
29095
29096 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29097 PyObject *resultobj = 0;
29098 int arg1 ;
29099 wxDateSpan result;
29100 int val1 ;
29101 int ecode1 = 0 ;
29102 PyObject * obj0 = 0 ;
29103 char * kwnames[] = {
29104 (char *) "weeks", NULL
29105 };
29106
29107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
29108 ecode1 = SWIG_AsVal_int(obj0, &val1);
29109 if (!SWIG_IsOK(ecode1)) {
29110 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
29111 }
29112 arg1 = static_cast< int >(val1);
29113 {
29114 PyThreadState* __tstate = wxPyBeginAllowThreads();
29115 result = wxDateSpan::Weeks(arg1);
29116 wxPyEndAllowThreads(__tstate);
29117 if (PyErr_Occurred()) SWIG_fail;
29118 }
29119 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29120 return resultobj;
29121 fail:
29122 return NULL;
29123 }
29124
29125
29126 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29127 PyObject *resultobj = 0;
29128 wxDateSpan result;
29129
29130 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
29131 {
29132 PyThreadState* __tstate = wxPyBeginAllowThreads();
29133 result = wxDateSpan::Week();
29134 wxPyEndAllowThreads(__tstate);
29135 if (PyErr_Occurred()) SWIG_fail;
29136 }
29137 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29138 return resultobj;
29139 fail:
29140 return NULL;
29141 }
29142
29143
29144 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29145 PyObject *resultobj = 0;
29146 int arg1 ;
29147 wxDateSpan result;
29148 int val1 ;
29149 int ecode1 = 0 ;
29150 PyObject * obj0 = 0 ;
29151 char * kwnames[] = {
29152 (char *) "mon", NULL
29153 };
29154
29155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
29156 ecode1 = SWIG_AsVal_int(obj0, &val1);
29157 if (!SWIG_IsOK(ecode1)) {
29158 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
29159 }
29160 arg1 = static_cast< int >(val1);
29161 {
29162 PyThreadState* __tstate = wxPyBeginAllowThreads();
29163 result = wxDateSpan::Months(arg1);
29164 wxPyEndAllowThreads(__tstate);
29165 if (PyErr_Occurred()) SWIG_fail;
29166 }
29167 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29168 return resultobj;
29169 fail:
29170 return NULL;
29171 }
29172
29173
29174 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29175 PyObject *resultobj = 0;
29176 wxDateSpan result;
29177
29178 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
29179 {
29180 PyThreadState* __tstate = wxPyBeginAllowThreads();
29181 result = wxDateSpan::Month();
29182 wxPyEndAllowThreads(__tstate);
29183 if (PyErr_Occurred()) SWIG_fail;
29184 }
29185 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29186 return resultobj;
29187 fail:
29188 return NULL;
29189 }
29190
29191
29192 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29193 PyObject *resultobj = 0;
29194 int arg1 ;
29195 wxDateSpan result;
29196 int val1 ;
29197 int ecode1 = 0 ;
29198 PyObject * obj0 = 0 ;
29199 char * kwnames[] = {
29200 (char *) "years", NULL
29201 };
29202
29203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
29204 ecode1 = SWIG_AsVal_int(obj0, &val1);
29205 if (!SWIG_IsOK(ecode1)) {
29206 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
29207 }
29208 arg1 = static_cast< int >(val1);
29209 {
29210 PyThreadState* __tstate = wxPyBeginAllowThreads();
29211 result = wxDateSpan::Years(arg1);
29212 wxPyEndAllowThreads(__tstate);
29213 if (PyErr_Occurred()) SWIG_fail;
29214 }
29215 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29216 return resultobj;
29217 fail:
29218 return NULL;
29219 }
29220
29221
29222 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29223 PyObject *resultobj = 0;
29224 wxDateSpan result;
29225
29226 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
29227 {
29228 PyThreadState* __tstate = wxPyBeginAllowThreads();
29229 result = wxDateSpan::Year();
29230 wxPyEndAllowThreads(__tstate);
29231 if (PyErr_Occurred()) SWIG_fail;
29232 }
29233 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29234 return resultobj;
29235 fail:
29236 return NULL;
29237 }
29238
29239
29240 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29241 PyObject *resultobj = 0;
29242 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29243 int arg2 ;
29244 wxDateSpan *result = 0 ;
29245 void *argp1 = 0 ;
29246 int res1 = 0 ;
29247 int val2 ;
29248 int ecode2 = 0 ;
29249 PyObject * obj0 = 0 ;
29250 PyObject * obj1 = 0 ;
29251 char * kwnames[] = {
29252 (char *) "self",(char *) "n", NULL
29253 };
29254
29255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
29256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29257 if (!SWIG_IsOK(res1)) {
29258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29259 }
29260 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29261 ecode2 = SWIG_AsVal_int(obj1, &val2);
29262 if (!SWIG_IsOK(ecode2)) {
29263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
29264 }
29265 arg2 = static_cast< int >(val2);
29266 {
29267 PyThreadState* __tstate = wxPyBeginAllowThreads();
29268 {
29269 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
29270 result = (wxDateSpan *) &_result_ref;
29271 }
29272 wxPyEndAllowThreads(__tstate);
29273 if (PyErr_Occurred()) SWIG_fail;
29274 }
29275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29276 return resultobj;
29277 fail:
29278 return NULL;
29279 }
29280
29281
29282 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29283 PyObject *resultobj = 0;
29284 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29285 int arg2 ;
29286 wxDateSpan *result = 0 ;
29287 void *argp1 = 0 ;
29288 int res1 = 0 ;
29289 int val2 ;
29290 int ecode2 = 0 ;
29291 PyObject * obj0 = 0 ;
29292 PyObject * obj1 = 0 ;
29293 char * kwnames[] = {
29294 (char *) "self",(char *) "n", NULL
29295 };
29296
29297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
29298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29299 if (!SWIG_IsOK(res1)) {
29300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29301 }
29302 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29303 ecode2 = SWIG_AsVal_int(obj1, &val2);
29304 if (!SWIG_IsOK(ecode2)) {
29305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
29306 }
29307 arg2 = static_cast< int >(val2);
29308 {
29309 PyThreadState* __tstate = wxPyBeginAllowThreads();
29310 {
29311 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
29312 result = (wxDateSpan *) &_result_ref;
29313 }
29314 wxPyEndAllowThreads(__tstate);
29315 if (PyErr_Occurred()) SWIG_fail;
29316 }
29317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29318 return resultobj;
29319 fail:
29320 return NULL;
29321 }
29322
29323
29324 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29325 PyObject *resultobj = 0;
29326 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29327 int arg2 ;
29328 wxDateSpan *result = 0 ;
29329 void *argp1 = 0 ;
29330 int res1 = 0 ;
29331 int val2 ;
29332 int ecode2 = 0 ;
29333 PyObject * obj0 = 0 ;
29334 PyObject * obj1 = 0 ;
29335 char * kwnames[] = {
29336 (char *) "self",(char *) "n", NULL
29337 };
29338
29339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
29340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29341 if (!SWIG_IsOK(res1)) {
29342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29343 }
29344 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29345 ecode2 = SWIG_AsVal_int(obj1, &val2);
29346 if (!SWIG_IsOK(ecode2)) {
29347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
29348 }
29349 arg2 = static_cast< int >(val2);
29350 {
29351 PyThreadState* __tstate = wxPyBeginAllowThreads();
29352 {
29353 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
29354 result = (wxDateSpan *) &_result_ref;
29355 }
29356 wxPyEndAllowThreads(__tstate);
29357 if (PyErr_Occurred()) SWIG_fail;
29358 }
29359 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29360 return resultobj;
29361 fail:
29362 return NULL;
29363 }
29364
29365
29366 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29367 PyObject *resultobj = 0;
29368 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29369 int arg2 ;
29370 wxDateSpan *result = 0 ;
29371 void *argp1 = 0 ;
29372 int res1 = 0 ;
29373 int val2 ;
29374 int ecode2 = 0 ;
29375 PyObject * obj0 = 0 ;
29376 PyObject * obj1 = 0 ;
29377 char * kwnames[] = {
29378 (char *) "self",(char *) "n", NULL
29379 };
29380
29381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
29382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29383 if (!SWIG_IsOK(res1)) {
29384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29385 }
29386 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29387 ecode2 = SWIG_AsVal_int(obj1, &val2);
29388 if (!SWIG_IsOK(ecode2)) {
29389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
29390 }
29391 arg2 = static_cast< int >(val2);
29392 {
29393 PyThreadState* __tstate = wxPyBeginAllowThreads();
29394 {
29395 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
29396 result = (wxDateSpan *) &_result_ref;
29397 }
29398 wxPyEndAllowThreads(__tstate);
29399 if (PyErr_Occurred()) SWIG_fail;
29400 }
29401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29402 return resultobj;
29403 fail:
29404 return NULL;
29405 }
29406
29407
29408 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29409 PyObject *resultobj = 0;
29410 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29411 int result;
29412 void *argp1 = 0 ;
29413 int res1 = 0 ;
29414 PyObject *swig_obj[1] ;
29415
29416 if (!args) SWIG_fail;
29417 swig_obj[0] = args;
29418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29419 if (!SWIG_IsOK(res1)) {
29420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29421 }
29422 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29423 {
29424 PyThreadState* __tstate = wxPyBeginAllowThreads();
29425 result = (int)((wxDateSpan const *)arg1)->GetYears();
29426 wxPyEndAllowThreads(__tstate);
29427 if (PyErr_Occurred()) SWIG_fail;
29428 }
29429 resultobj = SWIG_From_int(static_cast< int >(result));
29430 return resultobj;
29431 fail:
29432 return NULL;
29433 }
29434
29435
29436 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29437 PyObject *resultobj = 0;
29438 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29439 int result;
29440 void *argp1 = 0 ;
29441 int res1 = 0 ;
29442 PyObject *swig_obj[1] ;
29443
29444 if (!args) SWIG_fail;
29445 swig_obj[0] = args;
29446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29447 if (!SWIG_IsOK(res1)) {
29448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29449 }
29450 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29451 {
29452 PyThreadState* __tstate = wxPyBeginAllowThreads();
29453 result = (int)((wxDateSpan const *)arg1)->GetMonths();
29454 wxPyEndAllowThreads(__tstate);
29455 if (PyErr_Occurred()) SWIG_fail;
29456 }
29457 resultobj = SWIG_From_int(static_cast< int >(result));
29458 return resultobj;
29459 fail:
29460 return NULL;
29461 }
29462
29463
29464 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29465 PyObject *resultobj = 0;
29466 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29467 int result;
29468 void *argp1 = 0 ;
29469 int res1 = 0 ;
29470 PyObject *swig_obj[1] ;
29471
29472 if (!args) SWIG_fail;
29473 swig_obj[0] = args;
29474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29475 if (!SWIG_IsOK(res1)) {
29476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29477 }
29478 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29479 {
29480 PyThreadState* __tstate = wxPyBeginAllowThreads();
29481 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
29482 wxPyEndAllowThreads(__tstate);
29483 if (PyErr_Occurred()) SWIG_fail;
29484 }
29485 resultobj = SWIG_From_int(static_cast< int >(result));
29486 return resultobj;
29487 fail:
29488 return NULL;
29489 }
29490
29491
29492 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29493 PyObject *resultobj = 0;
29494 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29495 int result;
29496 void *argp1 = 0 ;
29497 int res1 = 0 ;
29498 PyObject *swig_obj[1] ;
29499
29500 if (!args) SWIG_fail;
29501 swig_obj[0] = args;
29502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29503 if (!SWIG_IsOK(res1)) {
29504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29505 }
29506 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29507 {
29508 PyThreadState* __tstate = wxPyBeginAllowThreads();
29509 result = (int)((wxDateSpan const *)arg1)->GetDays();
29510 wxPyEndAllowThreads(__tstate);
29511 if (PyErr_Occurred()) SWIG_fail;
29512 }
29513 resultobj = SWIG_From_int(static_cast< int >(result));
29514 return resultobj;
29515 fail:
29516 return NULL;
29517 }
29518
29519
29520 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29521 PyObject *resultobj = 0;
29522 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29523 int result;
29524 void *argp1 = 0 ;
29525 int res1 = 0 ;
29526 PyObject *swig_obj[1] ;
29527
29528 if (!args) SWIG_fail;
29529 swig_obj[0] = args;
29530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29531 if (!SWIG_IsOK(res1)) {
29532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29533 }
29534 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29535 {
29536 PyThreadState* __tstate = wxPyBeginAllowThreads();
29537 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
29538 wxPyEndAllowThreads(__tstate);
29539 if (PyErr_Occurred()) SWIG_fail;
29540 }
29541 resultobj = SWIG_From_int(static_cast< int >(result));
29542 return resultobj;
29543 fail:
29544 return NULL;
29545 }
29546
29547
29548 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29549 PyObject *resultobj = 0;
29550 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29551 wxDateSpan *arg2 = 0 ;
29552 wxDateSpan *result = 0 ;
29553 void *argp1 = 0 ;
29554 int res1 = 0 ;
29555 void *argp2 = 0 ;
29556 int res2 = 0 ;
29557 PyObject * obj0 = 0 ;
29558 PyObject * obj1 = 0 ;
29559 char * kwnames[] = {
29560 (char *) "self",(char *) "other", NULL
29561 };
29562
29563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29565 if (!SWIG_IsOK(res1)) {
29566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29567 }
29568 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29569 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29570 if (!SWIG_IsOK(res2)) {
29571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29572 }
29573 if (!argp2) {
29574 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29575 }
29576 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29577 {
29578 PyThreadState* __tstate = wxPyBeginAllowThreads();
29579 {
29580 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
29581 result = (wxDateSpan *) &_result_ref;
29582 }
29583 wxPyEndAllowThreads(__tstate);
29584 if (PyErr_Occurred()) SWIG_fail;
29585 }
29586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29587 return resultobj;
29588 fail:
29589 return NULL;
29590 }
29591
29592
29593 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29594 PyObject *resultobj = 0;
29595 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29596 wxDateSpan *arg2 = 0 ;
29597 wxDateSpan *result = 0 ;
29598 void *argp1 = 0 ;
29599 int res1 = 0 ;
29600 void *argp2 = 0 ;
29601 int res2 = 0 ;
29602 PyObject * obj0 = 0 ;
29603 PyObject * obj1 = 0 ;
29604 char * kwnames[] = {
29605 (char *) "self",(char *) "other", NULL
29606 };
29607
29608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29610 if (!SWIG_IsOK(res1)) {
29611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29612 }
29613 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29614 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29615 if (!SWIG_IsOK(res2)) {
29616 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29617 }
29618 if (!argp2) {
29619 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29620 }
29621 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29622 {
29623 PyThreadState* __tstate = wxPyBeginAllowThreads();
29624 {
29625 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
29626 result = (wxDateSpan *) &_result_ref;
29627 }
29628 wxPyEndAllowThreads(__tstate);
29629 if (PyErr_Occurred()) SWIG_fail;
29630 }
29631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29632 return resultobj;
29633 fail:
29634 return NULL;
29635 }
29636
29637
29638 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29639 PyObject *resultobj = 0;
29640 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29641 wxDateSpan *result = 0 ;
29642 void *argp1 = 0 ;
29643 int res1 = 0 ;
29644 PyObject *swig_obj[1] ;
29645
29646 if (!args) SWIG_fail;
29647 swig_obj[0] = args;
29648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29649 if (!SWIG_IsOK(res1)) {
29650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29651 }
29652 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29653 {
29654 PyThreadState* __tstate = wxPyBeginAllowThreads();
29655 {
29656 wxDateSpan &_result_ref = (arg1)->Neg();
29657 result = (wxDateSpan *) &_result_ref;
29658 }
29659 wxPyEndAllowThreads(__tstate);
29660 if (PyErr_Occurred()) SWIG_fail;
29661 }
29662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29663 return resultobj;
29664 fail:
29665 return NULL;
29666 }
29667
29668
29669 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29670 PyObject *resultobj = 0;
29671 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29672 int arg2 ;
29673 wxDateSpan *result = 0 ;
29674 void *argp1 = 0 ;
29675 int res1 = 0 ;
29676 int val2 ;
29677 int ecode2 = 0 ;
29678 PyObject * obj0 = 0 ;
29679 PyObject * obj1 = 0 ;
29680 char * kwnames[] = {
29681 (char *) "self",(char *) "factor", NULL
29682 };
29683
29684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29686 if (!SWIG_IsOK(res1)) {
29687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29688 }
29689 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29690 ecode2 = SWIG_AsVal_int(obj1, &val2);
29691 if (!SWIG_IsOK(ecode2)) {
29692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29693 }
29694 arg2 = static_cast< int >(val2);
29695 {
29696 PyThreadState* __tstate = wxPyBeginAllowThreads();
29697 {
29698 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
29699 result = (wxDateSpan *) &_result_ref;
29700 }
29701 wxPyEndAllowThreads(__tstate);
29702 if (PyErr_Occurred()) SWIG_fail;
29703 }
29704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29705 return resultobj;
29706 fail:
29707 return NULL;
29708 }
29709
29710
29711 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29712 PyObject *resultobj = 0;
29713 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29714 wxDateSpan *arg2 = 0 ;
29715 wxDateSpan *result = 0 ;
29716 void *argp1 = 0 ;
29717 int res1 = 0 ;
29718 void *argp2 = 0 ;
29719 int res2 = 0 ;
29720 PyObject * obj0 = 0 ;
29721 PyObject * obj1 = 0 ;
29722 char * kwnames[] = {
29723 (char *) "self",(char *) "other", NULL
29724 };
29725
29726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29728 if (!SWIG_IsOK(res1)) {
29729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29730 }
29731 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29732 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29733 if (!SWIG_IsOK(res2)) {
29734 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29735 }
29736 if (!argp2) {
29737 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29738 }
29739 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29740 {
29741 PyThreadState* __tstate = wxPyBeginAllowThreads();
29742 {
29743 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
29744 result = (wxDateSpan *) &_result_ref;
29745 }
29746 wxPyEndAllowThreads(__tstate);
29747 if (PyErr_Occurred()) SWIG_fail;
29748 }
29749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29750 return resultobj;
29751 fail:
29752 return NULL;
29753 }
29754
29755
29756 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29757 PyObject *resultobj = 0;
29758 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29759 wxDateSpan *arg2 = 0 ;
29760 wxDateSpan *result = 0 ;
29761 void *argp1 = 0 ;
29762 int res1 = 0 ;
29763 void *argp2 = 0 ;
29764 int res2 = 0 ;
29765 PyObject * obj0 = 0 ;
29766 PyObject * obj1 = 0 ;
29767 char * kwnames[] = {
29768 (char *) "self",(char *) "other", NULL
29769 };
29770
29771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29773 if (!SWIG_IsOK(res1)) {
29774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29775 }
29776 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29777 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29778 if (!SWIG_IsOK(res2)) {
29779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29780 }
29781 if (!argp2) {
29782 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29783 }
29784 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29785 {
29786 PyThreadState* __tstate = wxPyBeginAllowThreads();
29787 {
29788 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
29789 result = (wxDateSpan *) &_result_ref;
29790 }
29791 wxPyEndAllowThreads(__tstate);
29792 if (PyErr_Occurred()) SWIG_fail;
29793 }
29794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29795 return resultobj;
29796 fail:
29797 return NULL;
29798 }
29799
29800
29801 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29802 PyObject *resultobj = 0;
29803 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29804 wxDateSpan *result = 0 ;
29805 void *argp1 = 0 ;
29806 int res1 = 0 ;
29807 PyObject *swig_obj[1] ;
29808
29809 if (!args) SWIG_fail;
29810 swig_obj[0] = args;
29811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29812 if (!SWIG_IsOK(res1)) {
29813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29814 }
29815 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29816 {
29817 PyThreadState* __tstate = wxPyBeginAllowThreads();
29818 {
29819 wxDateSpan &_result_ref = (arg1)->operator -();
29820 result = (wxDateSpan *) &_result_ref;
29821 }
29822 wxPyEndAllowThreads(__tstate);
29823 if (PyErr_Occurred()) SWIG_fail;
29824 }
29825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29826 return resultobj;
29827 fail:
29828 return NULL;
29829 }
29830
29831
29832 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29833 PyObject *resultobj = 0;
29834 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29835 int arg2 ;
29836 wxDateSpan *result = 0 ;
29837 void *argp1 = 0 ;
29838 int res1 = 0 ;
29839 int val2 ;
29840 int ecode2 = 0 ;
29841 PyObject * obj0 = 0 ;
29842 PyObject * obj1 = 0 ;
29843 char * kwnames[] = {
29844 (char *) "self",(char *) "factor", NULL
29845 };
29846
29847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29849 if (!SWIG_IsOK(res1)) {
29850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29851 }
29852 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29853 ecode2 = SWIG_AsVal_int(obj1, &val2);
29854 if (!SWIG_IsOK(ecode2)) {
29855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29856 }
29857 arg2 = static_cast< int >(val2);
29858 {
29859 PyThreadState* __tstate = wxPyBeginAllowThreads();
29860 {
29861 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
29862 result = (wxDateSpan *) &_result_ref;
29863 }
29864 wxPyEndAllowThreads(__tstate);
29865 if (PyErr_Occurred()) SWIG_fail;
29866 }
29867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29868 return resultobj;
29869 fail:
29870 return NULL;
29871 }
29872
29873
29874 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29875 PyObject *resultobj = 0;
29876 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29877 wxDateSpan *arg2 = 0 ;
29878 wxDateSpan result;
29879 void *argp1 = 0 ;
29880 int res1 = 0 ;
29881 void *argp2 = 0 ;
29882 int res2 = 0 ;
29883 PyObject * obj0 = 0 ;
29884 PyObject * obj1 = 0 ;
29885 char * kwnames[] = {
29886 (char *) "self",(char *) "other", NULL
29887 };
29888
29889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29891 if (!SWIG_IsOK(res1)) {
29892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29893 }
29894 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29895 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29896 if (!SWIG_IsOK(res2)) {
29897 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29898 }
29899 if (!argp2) {
29900 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29901 }
29902 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29903 {
29904 PyThreadState* __tstate = wxPyBeginAllowThreads();
29905 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
29906 wxPyEndAllowThreads(__tstate);
29907 if (PyErr_Occurred()) SWIG_fail;
29908 }
29909 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29910 return resultobj;
29911 fail:
29912 return NULL;
29913 }
29914
29915
29916 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29917 PyObject *resultobj = 0;
29918 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29919 wxDateSpan *arg2 = 0 ;
29920 wxDateSpan result;
29921 void *argp1 = 0 ;
29922 int res1 = 0 ;
29923 void *argp2 = 0 ;
29924 int res2 = 0 ;
29925 PyObject * obj0 = 0 ;
29926 PyObject * obj1 = 0 ;
29927 char * kwnames[] = {
29928 (char *) "self",(char *) "other", NULL
29929 };
29930
29931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29933 if (!SWIG_IsOK(res1)) {
29934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29935 }
29936 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29937 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29938 if (!SWIG_IsOK(res2)) {
29939 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29940 }
29941 if (!argp2) {
29942 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29943 }
29944 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29945 {
29946 PyThreadState* __tstate = wxPyBeginAllowThreads();
29947 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
29948 wxPyEndAllowThreads(__tstate);
29949 if (PyErr_Occurred()) SWIG_fail;
29950 }
29951 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29952 return resultobj;
29953 fail:
29954 return NULL;
29955 }
29956
29957
29958 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29959 PyObject *resultobj = 0;
29960 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29961 int arg2 ;
29962 wxDateSpan result;
29963 void *argp1 = 0 ;
29964 int res1 = 0 ;
29965 int val2 ;
29966 int ecode2 = 0 ;
29967 PyObject * obj0 = 0 ;
29968 PyObject * obj1 = 0 ;
29969 char * kwnames[] = {
29970 (char *) "self",(char *) "n", NULL
29971 };
29972
29973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29975 if (!SWIG_IsOK(res1)) {
29976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29977 }
29978 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29979 ecode2 = SWIG_AsVal_int(obj1, &val2);
29980 if (!SWIG_IsOK(ecode2)) {
29981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29982 }
29983 arg2 = static_cast< int >(val2);
29984 {
29985 PyThreadState* __tstate = wxPyBeginAllowThreads();
29986 result = wxDateSpan___mul__(arg1,arg2);
29987 wxPyEndAllowThreads(__tstate);
29988 if (PyErr_Occurred()) SWIG_fail;
29989 }
29990 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29991 return resultobj;
29992 fail:
29993 return NULL;
29994 }
29995
29996
29997 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29998 PyObject *resultobj = 0;
29999 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30000 int arg2 ;
30001 wxDateSpan result;
30002 void *argp1 = 0 ;
30003 int res1 = 0 ;
30004 int val2 ;
30005 int ecode2 = 0 ;
30006 PyObject * obj0 = 0 ;
30007 PyObject * obj1 = 0 ;
30008 char * kwnames[] = {
30009 (char *) "self",(char *) "n", NULL
30010 };
30011
30012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
30013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30014 if (!SWIG_IsOK(res1)) {
30015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30016 }
30017 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30018 ecode2 = SWIG_AsVal_int(obj1, &val2);
30019 if (!SWIG_IsOK(ecode2)) {
30020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
30021 }
30022 arg2 = static_cast< int >(val2);
30023 {
30024 PyThreadState* __tstate = wxPyBeginAllowThreads();
30025 result = wxDateSpan___rmul__(arg1,arg2);
30026 wxPyEndAllowThreads(__tstate);
30027 if (PyErr_Occurred()) SWIG_fail;
30028 }
30029 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30030 return resultobj;
30031 fail:
30032 return NULL;
30033 }
30034
30035
30036 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30037 PyObject *resultobj = 0;
30038 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30039 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30040 bool result;
30041 void *argp1 = 0 ;
30042 int res1 = 0 ;
30043 void *argp2 = 0 ;
30044 int res2 = 0 ;
30045 PyObject * obj0 = 0 ;
30046 PyObject * obj1 = 0 ;
30047 char * kwnames[] = {
30048 (char *) "self",(char *) "other", NULL
30049 };
30050
30051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
30052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30053 if (!SWIG_IsOK(res1)) {
30054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30055 }
30056 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30057 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30058 if (!SWIG_IsOK(res2)) {
30059 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30060 }
30061 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30062 {
30063 PyThreadState* __tstate = wxPyBeginAllowThreads();
30064 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
30065 wxPyEndAllowThreads(__tstate);
30066 if (PyErr_Occurred()) SWIG_fail;
30067 }
30068 {
30069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30070 }
30071 return resultobj;
30072 fail:
30073 return NULL;
30074 }
30075
30076
30077 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30078 PyObject *resultobj = 0;
30079 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30080 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30081 bool result;
30082 void *argp1 = 0 ;
30083 int res1 = 0 ;
30084 void *argp2 = 0 ;
30085 int res2 = 0 ;
30086 PyObject * obj0 = 0 ;
30087 PyObject * obj1 = 0 ;
30088 char * kwnames[] = {
30089 (char *) "self",(char *) "other", NULL
30090 };
30091
30092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
30093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30094 if (!SWIG_IsOK(res1)) {
30095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30096 }
30097 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30098 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30099 if (!SWIG_IsOK(res2)) {
30100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30101 }
30102 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30103 {
30104 PyThreadState* __tstate = wxPyBeginAllowThreads();
30105 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
30106 wxPyEndAllowThreads(__tstate);
30107 if (PyErr_Occurred()) SWIG_fail;
30108 }
30109 {
30110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30111 }
30112 return resultobj;
30113 fail:
30114 return NULL;
30115 }
30116
30117
30118 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30119 PyObject *obj;
30120 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30121 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
30122 return SWIG_Py_Void();
30123 }
30124
30125 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30126 return SWIG_Python_InitShadowInstance(args);
30127 }
30128
30129 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30130 PyObject *resultobj = 0;
30131 long result;
30132
30133 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
30134 {
30135 PyThreadState* __tstate = wxPyBeginAllowThreads();
30136 result = (long)wxGetLocalTime();
30137 wxPyEndAllowThreads(__tstate);
30138 if (PyErr_Occurred()) SWIG_fail;
30139 }
30140 resultobj = SWIG_From_long(static_cast< long >(result));
30141 return resultobj;
30142 fail:
30143 return NULL;
30144 }
30145
30146
30147 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30148 PyObject *resultobj = 0;
30149 long result;
30150
30151 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
30152 {
30153 PyThreadState* __tstate = wxPyBeginAllowThreads();
30154 result = (long)wxGetUTCTime();
30155 wxPyEndAllowThreads(__tstate);
30156 if (PyErr_Occurred()) SWIG_fail;
30157 }
30158 resultobj = SWIG_From_long(static_cast< long >(result));
30159 return resultobj;
30160 fail:
30161 return NULL;
30162 }
30163
30164
30165 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30166 PyObject *resultobj = 0;
30167 long result;
30168
30169 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
30170 {
30171 PyThreadState* __tstate = wxPyBeginAllowThreads();
30172 result = (long)wxGetCurrentTime();
30173 wxPyEndAllowThreads(__tstate);
30174 if (PyErr_Occurred()) SWIG_fail;
30175 }
30176 resultobj = SWIG_From_long(static_cast< long >(result));
30177 return resultobj;
30178 fail:
30179 return NULL;
30180 }
30181
30182
30183 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30184 PyObject *resultobj = 0;
30185 wxLongLong result;
30186
30187 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
30188 {
30189 PyThreadState* __tstate = wxPyBeginAllowThreads();
30190 result = wxGetLocalTimeMillis();
30191 wxPyEndAllowThreads(__tstate);
30192 if (PyErr_Occurred()) SWIG_fail;
30193 }
30194 {
30195 PyObject *hi, *lo, *shifter, *shifted;
30196 hi = PyLong_FromLong( (&result)->GetHi() );
30197 lo = PyLong_FromLong( (&result)->GetLo() );
30198 shifter = PyLong_FromLong(32);
30199 shifted = PyNumber_Lshift(hi, shifter);
30200 resultobj = PyNumber_Or(shifted, lo);
30201 Py_DECREF(hi);
30202 Py_DECREF(lo);
30203 Py_DECREF(shifter);
30204 Py_DECREF(shifted);
30205 }
30206 return resultobj;
30207 fail:
30208 return NULL;
30209 }
30210
30211
30212 SWIGINTERN int DefaultDateTime_set(PyObject *) {
30213 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
30214 return 1;
30215 }
30216
30217
30218 SWIGINTERN PyObject *DefaultDateTime_get(void) {
30219 PyObject *pyobj = 0;
30220
30221 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
30222 return pyobj;
30223 }
30224
30225
30226 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30227 PyObject *resultobj = 0;
30228 wxDataFormatId arg1 ;
30229 wxDataFormat *result = 0 ;
30230 int val1 ;
30231 int ecode1 = 0 ;
30232 PyObject * obj0 = 0 ;
30233 char * kwnames[] = {
30234 (char *) "type", NULL
30235 };
30236
30237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
30238 ecode1 = SWIG_AsVal_int(obj0, &val1);
30239 if (!SWIG_IsOK(ecode1)) {
30240 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
30241 }
30242 arg1 = static_cast< wxDataFormatId >(val1);
30243 {
30244 PyThreadState* __tstate = wxPyBeginAllowThreads();
30245 result = (wxDataFormat *)new wxDataFormat(arg1);
30246 wxPyEndAllowThreads(__tstate);
30247 if (PyErr_Occurred()) SWIG_fail;
30248 }
30249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
30250 return resultobj;
30251 fail:
30252 return NULL;
30253 }
30254
30255
30256 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30257 PyObject *resultobj = 0;
30258 wxString *arg1 = 0 ;
30259 wxDataFormat *result = 0 ;
30260 bool temp1 = false ;
30261 PyObject * obj0 = 0 ;
30262 char * kwnames[] = {
30263 (char *) "format", NULL
30264 };
30265
30266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
30267 {
30268 arg1 = wxString_in_helper(obj0);
30269 if (arg1 == NULL) SWIG_fail;
30270 temp1 = true;
30271 }
30272 {
30273 PyThreadState* __tstate = wxPyBeginAllowThreads();
30274 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
30275 wxPyEndAllowThreads(__tstate);
30276 if (PyErr_Occurred()) SWIG_fail;
30277 }
30278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30279 {
30280 if (temp1)
30281 delete arg1;
30282 }
30283 return resultobj;
30284 fail:
30285 {
30286 if (temp1)
30287 delete arg1;
30288 }
30289 return NULL;
30290 }
30291
30292
30293 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30294 PyObject *resultobj = 0;
30295 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30296 void *argp1 = 0 ;
30297 int res1 = 0 ;
30298 PyObject *swig_obj[1] ;
30299
30300 if (!args) SWIG_fail;
30301 swig_obj[0] = args;
30302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
30303 if (!SWIG_IsOK(res1)) {
30304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30305 }
30306 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30307 {
30308 PyThreadState* __tstate = wxPyBeginAllowThreads();
30309 delete arg1;
30310
30311 wxPyEndAllowThreads(__tstate);
30312 if (PyErr_Occurred()) SWIG_fail;
30313 }
30314 resultobj = SWIG_Py_Void();
30315 return resultobj;
30316 fail:
30317 return NULL;
30318 }
30319
30320
30321 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30322 PyObject *resultobj = 0;
30323 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30324 wxDataFormatId arg2 ;
30325 bool result;
30326 void *argp1 = 0 ;
30327 int res1 = 0 ;
30328 int val2 ;
30329 int ecode2 = 0 ;
30330
30331 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30333 if (!SWIG_IsOK(res1)) {
30334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30335 }
30336 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30337 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30338 if (!SWIG_IsOK(ecode2)) {
30339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30340 }
30341 arg2 = static_cast< wxDataFormatId >(val2);
30342 {
30343 PyThreadState* __tstate = wxPyBeginAllowThreads();
30344 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
30345 wxPyEndAllowThreads(__tstate);
30346 if (PyErr_Occurred()) SWIG_fail;
30347 }
30348 {
30349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30350 }
30351 return resultobj;
30352 fail:
30353 return NULL;
30354 }
30355
30356
30357 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30358 PyObject *resultobj = 0;
30359 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30360 wxDataFormatId arg2 ;
30361 bool result;
30362 void *argp1 = 0 ;
30363 int res1 = 0 ;
30364 int val2 ;
30365 int ecode2 = 0 ;
30366
30367 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30369 if (!SWIG_IsOK(res1)) {
30370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30371 }
30372 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30373 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30374 if (!SWIG_IsOK(ecode2)) {
30375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30376 }
30377 arg2 = static_cast< wxDataFormatId >(val2);
30378 {
30379 PyThreadState* __tstate = wxPyBeginAllowThreads();
30380 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
30381 wxPyEndAllowThreads(__tstate);
30382 if (PyErr_Occurred()) SWIG_fail;
30383 }
30384 {
30385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30386 }
30387 return resultobj;
30388 fail:
30389 return NULL;
30390 }
30391
30392
30393 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30394 PyObject *resultobj = 0;
30395 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30396 wxDataFormat *arg2 = 0 ;
30397 bool result;
30398 void *argp1 = 0 ;
30399 int res1 = 0 ;
30400 void *argp2 = 0 ;
30401 int res2 = 0 ;
30402
30403 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30405 if (!SWIG_IsOK(res1)) {
30406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30407 }
30408 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30409 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30410 if (!SWIG_IsOK(res2)) {
30411 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30412 }
30413 if (!argp2) {
30414 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30415 }
30416 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30417 {
30418 PyThreadState* __tstate = wxPyBeginAllowThreads();
30419 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
30420 wxPyEndAllowThreads(__tstate);
30421 if (PyErr_Occurred()) SWIG_fail;
30422 }
30423 {
30424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30425 }
30426 return resultobj;
30427 fail:
30428 return NULL;
30429 }
30430
30431
30432 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
30433 int argc;
30434 PyObject *argv[3];
30435
30436 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
30437 --argc;
30438 if (argc == 2) {
30439 int _v = 0;
30440 {
30441 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30442 _v = SWIG_CheckState(res);
30443 }
30444 if (!_v) goto check_1;
30445 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
30446 }
30447 check_1:
30448
30449 if (argc == 2) {
30450 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
30451 }
30452
30453 fail:
30454 Py_INCREF(Py_NotImplemented);
30455 return Py_NotImplemented;
30456 }
30457
30458
30459 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30460 PyObject *resultobj = 0;
30461 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30462 wxDataFormat *arg2 = 0 ;
30463 bool result;
30464 void *argp1 = 0 ;
30465 int res1 = 0 ;
30466 void *argp2 = 0 ;
30467 int res2 = 0 ;
30468
30469 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30471 if (!SWIG_IsOK(res1)) {
30472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30473 }
30474 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30475 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30476 if (!SWIG_IsOK(res2)) {
30477 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30478 }
30479 if (!argp2) {
30480 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30481 }
30482 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30483 {
30484 PyThreadState* __tstate = wxPyBeginAllowThreads();
30485 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
30486 wxPyEndAllowThreads(__tstate);
30487 if (PyErr_Occurred()) SWIG_fail;
30488 }
30489 {
30490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30491 }
30492 return resultobj;
30493 fail:
30494 return NULL;
30495 }
30496
30497
30498 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
30499 int argc;
30500 PyObject *argv[3];
30501
30502 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
30503 --argc;
30504 if (argc == 2) {
30505 int _v = 0;
30506 {
30507 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30508 _v = SWIG_CheckState(res);
30509 }
30510 if (!_v) goto check_1;
30511 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
30512 }
30513 check_1:
30514
30515 if (argc == 2) {
30516 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
30517 }
30518
30519 fail:
30520 Py_INCREF(Py_NotImplemented);
30521 return Py_NotImplemented;
30522 }
30523
30524
30525 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30526 PyObject *resultobj = 0;
30527 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30528 wxDataFormatId arg2 ;
30529 void *argp1 = 0 ;
30530 int res1 = 0 ;
30531 int val2 ;
30532 int ecode2 = 0 ;
30533 PyObject * obj0 = 0 ;
30534 PyObject * obj1 = 0 ;
30535 char * kwnames[] = {
30536 (char *) "self",(char *) "format", NULL
30537 };
30538
30539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
30540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30541 if (!SWIG_IsOK(res1)) {
30542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30543 }
30544 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30545 ecode2 = SWIG_AsVal_int(obj1, &val2);
30546 if (!SWIG_IsOK(ecode2)) {
30547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30548 }
30549 arg2 = static_cast< wxDataFormatId >(val2);
30550 {
30551 PyThreadState* __tstate = wxPyBeginAllowThreads();
30552 (arg1)->SetType(arg2);
30553 wxPyEndAllowThreads(__tstate);
30554 if (PyErr_Occurred()) SWIG_fail;
30555 }
30556 resultobj = SWIG_Py_Void();
30557 return resultobj;
30558 fail:
30559 return NULL;
30560 }
30561
30562
30563 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30564 PyObject *resultobj = 0;
30565 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30566 wxDataFormatId result;
30567 void *argp1 = 0 ;
30568 int res1 = 0 ;
30569 PyObject *swig_obj[1] ;
30570
30571 if (!args) SWIG_fail;
30572 swig_obj[0] = args;
30573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30574 if (!SWIG_IsOK(res1)) {
30575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30576 }
30577 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30578 {
30579 PyThreadState* __tstate = wxPyBeginAllowThreads();
30580 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
30581 wxPyEndAllowThreads(__tstate);
30582 if (PyErr_Occurred()) SWIG_fail;
30583 }
30584 resultobj = SWIG_From_int(static_cast< int >(result));
30585 return resultobj;
30586 fail:
30587 return NULL;
30588 }
30589
30590
30591 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30592 PyObject *resultobj = 0;
30593 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30594 wxString result;
30595 void *argp1 = 0 ;
30596 int res1 = 0 ;
30597 PyObject *swig_obj[1] ;
30598
30599 if (!args) SWIG_fail;
30600 swig_obj[0] = args;
30601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30602 if (!SWIG_IsOK(res1)) {
30603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30604 }
30605 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30606 {
30607 PyThreadState* __tstate = wxPyBeginAllowThreads();
30608 result = ((wxDataFormat const *)arg1)->GetId();
30609 wxPyEndAllowThreads(__tstate);
30610 if (PyErr_Occurred()) SWIG_fail;
30611 }
30612 {
30613 #if wxUSE_UNICODE
30614 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30615 #else
30616 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30617 #endif
30618 }
30619 return resultobj;
30620 fail:
30621 return NULL;
30622 }
30623
30624
30625 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30626 PyObject *resultobj = 0;
30627 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30628 wxString *arg2 = 0 ;
30629 void *argp1 = 0 ;
30630 int res1 = 0 ;
30631 bool temp2 = false ;
30632 PyObject * obj0 = 0 ;
30633 PyObject * obj1 = 0 ;
30634 char * kwnames[] = {
30635 (char *) "self",(char *) "format", NULL
30636 };
30637
30638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30640 if (!SWIG_IsOK(res1)) {
30641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30642 }
30643 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30644 {
30645 arg2 = wxString_in_helper(obj1);
30646 if (arg2 == NULL) SWIG_fail;
30647 temp2 = true;
30648 }
30649 {
30650 PyThreadState* __tstate = wxPyBeginAllowThreads();
30651 (arg1)->SetId((wxString const &)*arg2);
30652 wxPyEndAllowThreads(__tstate);
30653 if (PyErr_Occurred()) SWIG_fail;
30654 }
30655 resultobj = SWIG_Py_Void();
30656 {
30657 if (temp2)
30658 delete arg2;
30659 }
30660 return resultobj;
30661 fail:
30662 {
30663 if (temp2)
30664 delete arg2;
30665 }
30666 return NULL;
30667 }
30668
30669
30670 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30671 PyObject *obj;
30672 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30673 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
30674 return SWIG_Py_Void();
30675 }
30676
30677 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30678 return SWIG_Python_InitShadowInstance(args);
30679 }
30680
30681 SWIGINTERN int FormatInvalid_set(PyObject *) {
30682 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
30683 return 1;
30684 }
30685
30686
30687 SWIGINTERN PyObject *FormatInvalid_get(void) {
30688 PyObject *pyobj = 0;
30689
30690 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
30691 return pyobj;
30692 }
30693
30694
30695 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30696 PyObject *resultobj = 0;
30697 wxDataObject *arg1 = (wxDataObject *) 0 ;
30698 void *argp1 = 0 ;
30699 int res1 = 0 ;
30700 PyObject *swig_obj[1] ;
30701
30702 if (!args) SWIG_fail;
30703 swig_obj[0] = args;
30704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
30705 if (!SWIG_IsOK(res1)) {
30706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
30707 }
30708 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30709 {
30710 PyThreadState* __tstate = wxPyBeginAllowThreads();
30711 delete arg1;
30712
30713 wxPyEndAllowThreads(__tstate);
30714 if (PyErr_Occurred()) SWIG_fail;
30715 }
30716 resultobj = SWIG_Py_Void();
30717 return resultobj;
30718 fail:
30719 return NULL;
30720 }
30721
30722
30723 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30724 PyObject *resultobj = 0;
30725 wxDataObject *arg1 = (wxDataObject *) 0 ;
30726 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30727 SwigValueWrapper<wxDataFormat > result;
30728 void *argp1 = 0 ;
30729 int res1 = 0 ;
30730 int val2 ;
30731 int ecode2 = 0 ;
30732 PyObject * obj0 = 0 ;
30733 PyObject * obj1 = 0 ;
30734 char * kwnames[] = {
30735 (char *) "self",(char *) "dir", NULL
30736 };
30737
30738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
30739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30740 if (!SWIG_IsOK(res1)) {
30741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30742 }
30743 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30744 if (obj1) {
30745 ecode2 = SWIG_AsVal_int(obj1, &val2);
30746 if (!SWIG_IsOK(ecode2)) {
30747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30748 }
30749 arg2 = static_cast< wxDataObject::Direction >(val2);
30750 }
30751 {
30752 PyThreadState* __tstate = wxPyBeginAllowThreads();
30753 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
30754 wxPyEndAllowThreads(__tstate);
30755 if (PyErr_Occurred()) SWIG_fail;
30756 }
30757 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30758 return resultobj;
30759 fail:
30760 return NULL;
30761 }
30762
30763
30764 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30765 PyObject *resultobj = 0;
30766 wxDataObject *arg1 = (wxDataObject *) 0 ;
30767 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30768 size_t result;
30769 void *argp1 = 0 ;
30770 int res1 = 0 ;
30771 int val2 ;
30772 int ecode2 = 0 ;
30773 PyObject * obj0 = 0 ;
30774 PyObject * obj1 = 0 ;
30775 char * kwnames[] = {
30776 (char *) "self",(char *) "dir", NULL
30777 };
30778
30779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
30780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30781 if (!SWIG_IsOK(res1)) {
30782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30783 }
30784 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30785 if (obj1) {
30786 ecode2 = SWIG_AsVal_int(obj1, &val2);
30787 if (!SWIG_IsOK(ecode2)) {
30788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30789 }
30790 arg2 = static_cast< wxDataObject::Direction >(val2);
30791 }
30792 {
30793 PyThreadState* __tstate = wxPyBeginAllowThreads();
30794 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
30795 wxPyEndAllowThreads(__tstate);
30796 if (PyErr_Occurred()) SWIG_fail;
30797 }
30798 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30799 return resultobj;
30800 fail:
30801 return NULL;
30802 }
30803
30804
30805 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30806 PyObject *resultobj = 0;
30807 wxDataObject *arg1 = (wxDataObject *) 0 ;
30808 wxDataFormat *arg2 = 0 ;
30809 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
30810 bool result;
30811 void *argp1 = 0 ;
30812 int res1 = 0 ;
30813 void *argp2 = 0 ;
30814 int res2 = 0 ;
30815 int val3 ;
30816 int ecode3 = 0 ;
30817 PyObject * obj0 = 0 ;
30818 PyObject * obj1 = 0 ;
30819 PyObject * obj2 = 0 ;
30820 char * kwnames[] = {
30821 (char *) "self",(char *) "format",(char *) "dir", NULL
30822 };
30823
30824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30826 if (!SWIG_IsOK(res1)) {
30827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30828 }
30829 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30830 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30831 if (!SWIG_IsOK(res2)) {
30832 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30833 }
30834 if (!argp2) {
30835 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30836 }
30837 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30838 if (obj2) {
30839 ecode3 = SWIG_AsVal_int(obj2, &val3);
30840 if (!SWIG_IsOK(ecode3)) {
30841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
30842 }
30843 arg3 = static_cast< wxDataObject::Direction >(val3);
30844 }
30845 {
30846 PyThreadState* __tstate = wxPyBeginAllowThreads();
30847 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
30848 wxPyEndAllowThreads(__tstate);
30849 if (PyErr_Occurred()) SWIG_fail;
30850 }
30851 {
30852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30853 }
30854 return resultobj;
30855 fail:
30856 return NULL;
30857 }
30858
30859
30860 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30861 PyObject *resultobj = 0;
30862 wxDataObject *arg1 = (wxDataObject *) 0 ;
30863 wxDataFormat *arg2 = 0 ;
30864 size_t result;
30865 void *argp1 = 0 ;
30866 int res1 = 0 ;
30867 void *argp2 = 0 ;
30868 int res2 = 0 ;
30869 PyObject * obj0 = 0 ;
30870 PyObject * obj1 = 0 ;
30871 char * kwnames[] = {
30872 (char *) "self",(char *) "format", NULL
30873 };
30874
30875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
30876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30877 if (!SWIG_IsOK(res1)) {
30878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30879 }
30880 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30881 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30882 if (!SWIG_IsOK(res2)) {
30883 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30884 }
30885 if (!argp2) {
30886 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30887 }
30888 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30889 {
30890 PyThreadState* __tstate = wxPyBeginAllowThreads();
30891 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
30892 wxPyEndAllowThreads(__tstate);
30893 if (PyErr_Occurred()) SWIG_fail;
30894 }
30895 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30896 return resultobj;
30897 fail:
30898 return NULL;
30899 }
30900
30901
30902 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30903 PyObject *resultobj = 0;
30904 wxDataObject *arg1 = (wxDataObject *) 0 ;
30905 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30906 PyObject *result = 0 ;
30907 void *argp1 = 0 ;
30908 int res1 = 0 ;
30909 int val2 ;
30910 int ecode2 = 0 ;
30911 PyObject * obj0 = 0 ;
30912 PyObject * obj1 = 0 ;
30913 char * kwnames[] = {
30914 (char *) "self",(char *) "dir", NULL
30915 };
30916
30917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
30918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30919 if (!SWIG_IsOK(res1)) {
30920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
30921 }
30922 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30923 if (obj1) {
30924 ecode2 = SWIG_AsVal_int(obj1, &val2);
30925 if (!SWIG_IsOK(ecode2)) {
30926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30927 }
30928 arg2 = static_cast< wxDataObject::Direction >(val2);
30929 }
30930 {
30931 PyThreadState* __tstate = wxPyBeginAllowThreads();
30932 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
30933 wxPyEndAllowThreads(__tstate);
30934 if (PyErr_Occurred()) SWIG_fail;
30935 }
30936 resultobj = result;
30937 return resultobj;
30938 fail:
30939 return NULL;
30940 }
30941
30942
30943 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30944 PyObject *resultobj = 0;
30945 wxDataObject *arg1 = (wxDataObject *) 0 ;
30946 wxDataFormat *arg2 = 0 ;
30947 PyObject *result = 0 ;
30948 void *argp1 = 0 ;
30949 int res1 = 0 ;
30950 void *argp2 = 0 ;
30951 int res2 = 0 ;
30952 PyObject * obj0 = 0 ;
30953 PyObject * obj1 = 0 ;
30954 char * kwnames[] = {
30955 (char *) "self",(char *) "format", NULL
30956 };
30957
30958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
30959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30960 if (!SWIG_IsOK(res1)) {
30961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
30962 }
30963 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30964 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30965 if (!SWIG_IsOK(res2)) {
30966 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30967 }
30968 if (!argp2) {
30969 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30970 }
30971 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30972 {
30973 PyThreadState* __tstate = wxPyBeginAllowThreads();
30974 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
30975 wxPyEndAllowThreads(__tstate);
30976 if (PyErr_Occurred()) SWIG_fail;
30977 }
30978 resultobj = result;
30979 return resultobj;
30980 fail:
30981 return NULL;
30982 }
30983
30984
30985 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30986 PyObject *resultobj = 0;
30987 wxDataObject *arg1 = (wxDataObject *) 0 ;
30988 wxDataFormat *arg2 = 0 ;
30989 PyObject *arg3 = (PyObject *) 0 ;
30990 bool result;
30991 void *argp1 = 0 ;
30992 int res1 = 0 ;
30993 void *argp2 = 0 ;
30994 int res2 = 0 ;
30995 PyObject * obj0 = 0 ;
30996 PyObject * obj1 = 0 ;
30997 PyObject * obj2 = 0 ;
30998 char * kwnames[] = {
30999 (char *) "self",(char *) "format",(char *) "data", NULL
31000 };
31001
31002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31004 if (!SWIG_IsOK(res1)) {
31005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
31006 }
31007 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31008 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31009 if (!SWIG_IsOK(res2)) {
31010 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31011 }
31012 if (!argp2) {
31013 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31014 }
31015 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31016 arg3 = obj2;
31017 {
31018 PyThreadState* __tstate = wxPyBeginAllowThreads();
31019 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
31020 wxPyEndAllowThreads(__tstate);
31021 if (PyErr_Occurred()) SWIG_fail;
31022 }
31023 {
31024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31025 }
31026 return resultobj;
31027 fail:
31028 return NULL;
31029 }
31030
31031
31032 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31033 PyObject *obj;
31034 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31035 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
31036 return SWIG_Py_Void();
31037 }
31038
31039 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31040 PyObject *resultobj = 0;
31041 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31042 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31043 wxDataObjectSimple *result = 0 ;
31044 void *argp1 = 0 ;
31045 int res1 = 0 ;
31046 PyObject * obj0 = 0 ;
31047 char * kwnames[] = {
31048 (char *) "format", NULL
31049 };
31050
31051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
31052 if (obj0) {
31053 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31054 if (!SWIG_IsOK(res1)) {
31055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31056 }
31057 if (!argp1) {
31058 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31059 }
31060 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31061 }
31062 {
31063 PyThreadState* __tstate = wxPyBeginAllowThreads();
31064 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
31065 wxPyEndAllowThreads(__tstate);
31066 if (PyErr_Occurred()) SWIG_fail;
31067 }
31068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
31069 return resultobj;
31070 fail:
31071 return NULL;
31072 }
31073
31074
31075 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31076 PyObject *resultobj = 0;
31077 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31078 wxDataFormat *result = 0 ;
31079 void *argp1 = 0 ;
31080 int res1 = 0 ;
31081 PyObject *swig_obj[1] ;
31082
31083 if (!args) SWIG_fail;
31084 swig_obj[0] = args;
31085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31086 if (!SWIG_IsOK(res1)) {
31087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31088 }
31089 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31090 {
31091 PyThreadState* __tstate = wxPyBeginAllowThreads();
31092 {
31093 wxDataFormat const &_result_ref = (arg1)->GetFormat();
31094 result = (wxDataFormat *) &_result_ref;
31095 }
31096 wxPyEndAllowThreads(__tstate);
31097 if (PyErr_Occurred()) SWIG_fail;
31098 }
31099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
31100 return resultobj;
31101 fail:
31102 return NULL;
31103 }
31104
31105
31106 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31107 PyObject *resultobj = 0;
31108 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31109 wxDataFormat *arg2 = 0 ;
31110 void *argp1 = 0 ;
31111 int res1 = 0 ;
31112 void *argp2 = 0 ;
31113 int res2 = 0 ;
31114 PyObject * obj0 = 0 ;
31115 PyObject * obj1 = 0 ;
31116 char * kwnames[] = {
31117 (char *) "self",(char *) "format", NULL
31118 };
31119
31120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31122 if (!SWIG_IsOK(res1)) {
31123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31124 }
31125 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31126 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31127 if (!SWIG_IsOK(res2)) {
31128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31129 }
31130 if (!argp2) {
31131 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31132 }
31133 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31134 {
31135 PyThreadState* __tstate = wxPyBeginAllowThreads();
31136 (arg1)->SetFormat((wxDataFormat const &)*arg2);
31137 wxPyEndAllowThreads(__tstate);
31138 if (PyErr_Occurred()) SWIG_fail;
31139 }
31140 resultobj = SWIG_Py_Void();
31141 return resultobj;
31142 fail:
31143 return NULL;
31144 }
31145
31146
31147 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31148 PyObject *resultobj = 0;
31149 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31150 size_t result;
31151 void *argp1 = 0 ;
31152 int res1 = 0 ;
31153 PyObject *swig_obj[1] ;
31154
31155 if (!args) SWIG_fail;
31156 swig_obj[0] = args;
31157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31158 if (!SWIG_IsOK(res1)) {
31159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
31160 }
31161 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31162 {
31163 PyThreadState* __tstate = wxPyBeginAllowThreads();
31164 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
31165 wxPyEndAllowThreads(__tstate);
31166 if (PyErr_Occurred()) SWIG_fail;
31167 }
31168 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31169 return resultobj;
31170 fail:
31171 return NULL;
31172 }
31173
31174
31175 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31176 PyObject *resultobj = 0;
31177 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31178 PyObject *result = 0 ;
31179 void *argp1 = 0 ;
31180 int res1 = 0 ;
31181 PyObject *swig_obj[1] ;
31182
31183 if (!args) SWIG_fail;
31184 swig_obj[0] = args;
31185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31186 if (!SWIG_IsOK(res1)) {
31187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31188 }
31189 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31190 {
31191 PyThreadState* __tstate = wxPyBeginAllowThreads();
31192 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
31193 wxPyEndAllowThreads(__tstate);
31194 if (PyErr_Occurred()) SWIG_fail;
31195 }
31196 resultobj = result;
31197 return resultobj;
31198 fail:
31199 return NULL;
31200 }
31201
31202
31203 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31204 PyObject *resultobj = 0;
31205 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31206 PyObject *arg2 = (PyObject *) 0 ;
31207 bool result;
31208 void *argp1 = 0 ;
31209 int res1 = 0 ;
31210 PyObject * obj0 = 0 ;
31211 PyObject * obj1 = 0 ;
31212 char * kwnames[] = {
31213 (char *) "self",(char *) "data", NULL
31214 };
31215
31216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31218 if (!SWIG_IsOK(res1)) {
31219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31220 }
31221 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31222 arg2 = obj1;
31223 {
31224 PyThreadState* __tstate = wxPyBeginAllowThreads();
31225 result = (bool)wxDataObjectSimple_SetData(arg1,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 *DataObjectSimple_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_wxDataObjectSimple, SWIG_NewClientData(obj));
31242 return SWIG_Py_Void();
31243 }
31244
31245 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31246 return SWIG_Python_InitShadowInstance(args);
31247 }
31248
31249 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31250 PyObject *resultobj = 0;
31251 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31252 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31253 wxPyDataObjectSimple *result = 0 ;
31254 void *argp1 = 0 ;
31255 int res1 = 0 ;
31256 PyObject * obj0 = 0 ;
31257 char * kwnames[] = {
31258 (char *) "format", NULL
31259 };
31260
31261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
31262 if (obj0) {
31263 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31264 if (!SWIG_IsOK(res1)) {
31265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31266 }
31267 if (!argp1) {
31268 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31269 }
31270 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31271 }
31272 {
31273 PyThreadState* __tstate = wxPyBeginAllowThreads();
31274 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
31275 wxPyEndAllowThreads(__tstate);
31276 if (PyErr_Occurred()) SWIG_fail;
31277 }
31278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
31279 return resultobj;
31280 fail:
31281 return NULL;
31282 }
31283
31284
31285 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31286 PyObject *resultobj = 0;
31287 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
31288 PyObject *arg2 = (PyObject *) 0 ;
31289 PyObject *arg3 = (PyObject *) 0 ;
31290 void *argp1 = 0 ;
31291 int res1 = 0 ;
31292 PyObject * obj0 = 0 ;
31293 PyObject * obj1 = 0 ;
31294 PyObject * obj2 = 0 ;
31295 char * kwnames[] = {
31296 (char *) "self",(char *) "self",(char *) "_class", NULL
31297 };
31298
31299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
31301 if (!SWIG_IsOK(res1)) {
31302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
31303 }
31304 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
31305 arg2 = obj1;
31306 arg3 = obj2;
31307 {
31308 PyThreadState* __tstate = wxPyBeginAllowThreads();
31309 (arg1)->_setCallbackInfo(arg2,arg3);
31310 wxPyEndAllowThreads(__tstate);
31311 if (PyErr_Occurred()) SWIG_fail;
31312 }
31313 resultobj = SWIG_Py_Void();
31314 return resultobj;
31315 fail:
31316 return NULL;
31317 }
31318
31319
31320 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31321 PyObject *obj;
31322 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31323 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
31324 return SWIG_Py_Void();
31325 }
31326
31327 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31328 return SWIG_Python_InitShadowInstance(args);
31329 }
31330
31331 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31332 PyObject *resultobj = 0;
31333 wxDataObjectComposite *result = 0 ;
31334
31335 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
31336 {
31337 PyThreadState* __tstate = wxPyBeginAllowThreads();
31338 result = (wxDataObjectComposite *)new wxDataObjectComposite();
31339 wxPyEndAllowThreads(__tstate);
31340 if (PyErr_Occurred()) SWIG_fail;
31341 }
31342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
31343 return resultobj;
31344 fail:
31345 return NULL;
31346 }
31347
31348
31349 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31350 PyObject *resultobj = 0;
31351 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31352 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
31353 bool arg3 = (bool) false ;
31354 void *argp1 = 0 ;
31355 int res1 = 0 ;
31356 int res2 = 0 ;
31357 bool val3 ;
31358 int ecode3 = 0 ;
31359 PyObject * obj0 = 0 ;
31360 PyObject * obj1 = 0 ;
31361 PyObject * obj2 = 0 ;
31362 char * kwnames[] = {
31363 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
31364 };
31365
31366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31368 if (!SWIG_IsOK(res1)) {
31369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
31370 }
31371 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31372 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
31373 if (!SWIG_IsOK(res2)) {
31374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
31375 }
31376 if (obj2) {
31377 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31378 if (!SWIG_IsOK(ecode3)) {
31379 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
31380 }
31381 arg3 = static_cast< bool >(val3);
31382 }
31383 {
31384 PyThreadState* __tstate = wxPyBeginAllowThreads();
31385 (arg1)->Add(arg2,arg3);
31386 wxPyEndAllowThreads(__tstate);
31387 if (PyErr_Occurred()) SWIG_fail;
31388 }
31389 resultobj = SWIG_Py_Void();
31390 return resultobj;
31391 fail:
31392 return NULL;
31393 }
31394
31395
31396 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31397 PyObject *resultobj = 0;
31398 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31399 SwigValueWrapper<wxDataFormat > result;
31400 void *argp1 = 0 ;
31401 int res1 = 0 ;
31402 PyObject *swig_obj[1] ;
31403
31404 if (!args) SWIG_fail;
31405 swig_obj[0] = args;
31406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31407 if (!SWIG_IsOK(res1)) {
31408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
31409 }
31410 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31411 {
31412 PyThreadState* __tstate = wxPyBeginAllowThreads();
31413 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
31414 wxPyEndAllowThreads(__tstate);
31415 if (PyErr_Occurred()) SWIG_fail;
31416 }
31417 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31418 return resultobj;
31419 fail:
31420 return NULL;
31421 }
31422
31423
31424 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31425 PyObject *obj;
31426 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31427 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
31428 return SWIG_Py_Void();
31429 }
31430
31431 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31432 return SWIG_Python_InitShadowInstance(args);
31433 }
31434
31435 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31436 PyObject *resultobj = 0;
31437 wxString const &arg1_defvalue = wxPyEmptyString ;
31438 wxString *arg1 = (wxString *) &arg1_defvalue ;
31439 wxTextDataObject *result = 0 ;
31440 bool temp1 = false ;
31441 PyObject * obj0 = 0 ;
31442 char * kwnames[] = {
31443 (char *) "text", NULL
31444 };
31445
31446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
31447 if (obj0) {
31448 {
31449 arg1 = wxString_in_helper(obj0);
31450 if (arg1 == NULL) SWIG_fail;
31451 temp1 = true;
31452 }
31453 }
31454 {
31455 PyThreadState* __tstate = wxPyBeginAllowThreads();
31456 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
31457 wxPyEndAllowThreads(__tstate);
31458 if (PyErr_Occurred()) SWIG_fail;
31459 }
31460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
31461 {
31462 if (temp1)
31463 delete arg1;
31464 }
31465 return resultobj;
31466 fail:
31467 {
31468 if (temp1)
31469 delete arg1;
31470 }
31471 return NULL;
31472 }
31473
31474
31475 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31476 PyObject *resultobj = 0;
31477 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31478 size_t result;
31479 void *argp1 = 0 ;
31480 int res1 = 0 ;
31481 PyObject *swig_obj[1] ;
31482
31483 if (!args) SWIG_fail;
31484 swig_obj[0] = args;
31485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31486 if (!SWIG_IsOK(res1)) {
31487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31488 }
31489 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31490 {
31491 PyThreadState* __tstate = wxPyBeginAllowThreads();
31492 result = (size_t)(arg1)->GetTextLength();
31493 wxPyEndAllowThreads(__tstate);
31494 if (PyErr_Occurred()) SWIG_fail;
31495 }
31496 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31497 return resultobj;
31498 fail:
31499 return NULL;
31500 }
31501
31502
31503 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31504 PyObject *resultobj = 0;
31505 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31506 wxString result;
31507 void *argp1 = 0 ;
31508 int res1 = 0 ;
31509 PyObject *swig_obj[1] ;
31510
31511 if (!args) SWIG_fail;
31512 swig_obj[0] = args;
31513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31514 if (!SWIG_IsOK(res1)) {
31515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31516 }
31517 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31518 {
31519 PyThreadState* __tstate = wxPyBeginAllowThreads();
31520 result = (arg1)->GetText();
31521 wxPyEndAllowThreads(__tstate);
31522 if (PyErr_Occurred()) SWIG_fail;
31523 }
31524 {
31525 #if wxUSE_UNICODE
31526 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31527 #else
31528 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31529 #endif
31530 }
31531 return resultobj;
31532 fail:
31533 return NULL;
31534 }
31535
31536
31537 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31538 PyObject *resultobj = 0;
31539 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31540 wxString *arg2 = 0 ;
31541 void *argp1 = 0 ;
31542 int res1 = 0 ;
31543 bool temp2 = false ;
31544 PyObject * obj0 = 0 ;
31545 PyObject * obj1 = 0 ;
31546 char * kwnames[] = {
31547 (char *) "self",(char *) "text", NULL
31548 };
31549
31550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
31551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31552 if (!SWIG_IsOK(res1)) {
31553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31554 }
31555 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31556 {
31557 arg2 = wxString_in_helper(obj1);
31558 if (arg2 == NULL) SWIG_fail;
31559 temp2 = true;
31560 }
31561 {
31562 PyThreadState* __tstate = wxPyBeginAllowThreads();
31563 (arg1)->SetText((wxString const &)*arg2);
31564 wxPyEndAllowThreads(__tstate);
31565 if (PyErr_Occurred()) SWIG_fail;
31566 }
31567 resultobj = SWIG_Py_Void();
31568 {
31569 if (temp2)
31570 delete arg2;
31571 }
31572 return resultobj;
31573 fail:
31574 {
31575 if (temp2)
31576 delete arg2;
31577 }
31578 return NULL;
31579 }
31580
31581
31582 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31583 PyObject *obj;
31584 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31585 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
31586 return SWIG_Py_Void();
31587 }
31588
31589 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31590 return SWIG_Python_InitShadowInstance(args);
31591 }
31592
31593 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31594 PyObject *resultobj = 0;
31595 wxString const &arg1_defvalue = wxPyEmptyString ;
31596 wxString *arg1 = (wxString *) &arg1_defvalue ;
31597 wxPyTextDataObject *result = 0 ;
31598 bool temp1 = false ;
31599 PyObject * obj0 = 0 ;
31600 char * kwnames[] = {
31601 (char *) "text", NULL
31602 };
31603
31604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
31605 if (obj0) {
31606 {
31607 arg1 = wxString_in_helper(obj0);
31608 if (arg1 == NULL) SWIG_fail;
31609 temp1 = true;
31610 }
31611 }
31612 {
31613 PyThreadState* __tstate = wxPyBeginAllowThreads();
31614 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
31615 wxPyEndAllowThreads(__tstate);
31616 if (PyErr_Occurred()) SWIG_fail;
31617 }
31618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
31619 {
31620 if (temp1)
31621 delete arg1;
31622 }
31623 return resultobj;
31624 fail:
31625 {
31626 if (temp1)
31627 delete arg1;
31628 }
31629 return NULL;
31630 }
31631
31632
31633 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31634 PyObject *resultobj = 0;
31635 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
31636 PyObject *arg2 = (PyObject *) 0 ;
31637 PyObject *arg3 = (PyObject *) 0 ;
31638 void *argp1 = 0 ;
31639 int res1 = 0 ;
31640 PyObject * obj0 = 0 ;
31641 PyObject * obj1 = 0 ;
31642 PyObject * obj2 = 0 ;
31643 char * kwnames[] = {
31644 (char *) "self",(char *) "self",(char *) "_class", NULL
31645 };
31646
31647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
31649 if (!SWIG_IsOK(res1)) {
31650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
31651 }
31652 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
31653 arg2 = obj1;
31654 arg3 = obj2;
31655 {
31656 PyThreadState* __tstate = wxPyBeginAllowThreads();
31657 (arg1)->_setCallbackInfo(arg2,arg3);
31658 wxPyEndAllowThreads(__tstate);
31659 if (PyErr_Occurred()) SWIG_fail;
31660 }
31661 resultobj = SWIG_Py_Void();
31662 return resultobj;
31663 fail:
31664 return NULL;
31665 }
31666
31667
31668 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31669 PyObject *obj;
31670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31671 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
31672 return SWIG_Py_Void();
31673 }
31674
31675 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31676 return SWIG_Python_InitShadowInstance(args);
31677 }
31678
31679 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31680 PyObject *resultobj = 0;
31681 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31682 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31683 wxBitmapDataObject *result = 0 ;
31684 void *argp1 = 0 ;
31685 int res1 = 0 ;
31686 PyObject * obj0 = 0 ;
31687 char * kwnames[] = {
31688 (char *) "bitmap", NULL
31689 };
31690
31691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
31692 if (obj0) {
31693 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31694 if (!SWIG_IsOK(res1)) {
31695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31696 }
31697 if (!argp1) {
31698 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31699 }
31700 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31701 }
31702 {
31703 PyThreadState* __tstate = wxPyBeginAllowThreads();
31704 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
31705 wxPyEndAllowThreads(__tstate);
31706 if (PyErr_Occurred()) SWIG_fail;
31707 }
31708 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
31709 return resultobj;
31710 fail:
31711 return NULL;
31712 }
31713
31714
31715 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31716 PyObject *resultobj = 0;
31717 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31718 wxBitmap result;
31719 void *argp1 = 0 ;
31720 int res1 = 0 ;
31721 PyObject *swig_obj[1] ;
31722
31723 if (!args) SWIG_fail;
31724 swig_obj[0] = args;
31725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31726 if (!SWIG_IsOK(res1)) {
31727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
31728 }
31729 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31730 {
31731 PyThreadState* __tstate = wxPyBeginAllowThreads();
31732 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
31733 wxPyEndAllowThreads(__tstate);
31734 if (PyErr_Occurred()) SWIG_fail;
31735 }
31736 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
31737 return resultobj;
31738 fail:
31739 return NULL;
31740 }
31741
31742
31743 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31744 PyObject *resultobj = 0;
31745 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31746 wxBitmap *arg2 = 0 ;
31747 void *argp1 = 0 ;
31748 int res1 = 0 ;
31749 void *argp2 = 0 ;
31750 int res2 = 0 ;
31751 PyObject * obj0 = 0 ;
31752 PyObject * obj1 = 0 ;
31753 char * kwnames[] = {
31754 (char *) "self",(char *) "bitmap", NULL
31755 };
31756
31757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
31758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31759 if (!SWIG_IsOK(res1)) {
31760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
31761 }
31762 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31763 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
31764 if (!SWIG_IsOK(res2)) {
31765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31766 }
31767 if (!argp2) {
31768 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31769 }
31770 arg2 = reinterpret_cast< wxBitmap * >(argp2);
31771 {
31772 PyThreadState* __tstate = wxPyBeginAllowThreads();
31773 (arg1)->SetBitmap((wxBitmap const &)*arg2);
31774 wxPyEndAllowThreads(__tstate);
31775 if (PyErr_Occurred()) SWIG_fail;
31776 }
31777 resultobj = SWIG_Py_Void();
31778 return resultobj;
31779 fail:
31780 return NULL;
31781 }
31782
31783
31784 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31785 PyObject *obj;
31786 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31787 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
31788 return SWIG_Py_Void();
31789 }
31790
31791 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31792 return SWIG_Python_InitShadowInstance(args);
31793 }
31794
31795 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31796 PyObject *resultobj = 0;
31797 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31798 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31799 wxPyBitmapDataObject *result = 0 ;
31800 void *argp1 = 0 ;
31801 int res1 = 0 ;
31802 PyObject * obj0 = 0 ;
31803 char * kwnames[] = {
31804 (char *) "bitmap", NULL
31805 };
31806
31807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
31808 if (obj0) {
31809 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31810 if (!SWIG_IsOK(res1)) {
31811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31812 }
31813 if (!argp1) {
31814 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31815 }
31816 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31817 }
31818 {
31819 PyThreadState* __tstate = wxPyBeginAllowThreads();
31820 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
31821 wxPyEndAllowThreads(__tstate);
31822 if (PyErr_Occurred()) SWIG_fail;
31823 }
31824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
31825 return resultobj;
31826 fail:
31827 return NULL;
31828 }
31829
31830
31831 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31832 PyObject *resultobj = 0;
31833 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
31834 PyObject *arg2 = (PyObject *) 0 ;
31835 PyObject *arg3 = (PyObject *) 0 ;
31836 void *argp1 = 0 ;
31837 int res1 = 0 ;
31838 PyObject * obj0 = 0 ;
31839 PyObject * obj1 = 0 ;
31840 PyObject * obj2 = 0 ;
31841 char * kwnames[] = {
31842 (char *) "self",(char *) "self",(char *) "_class", NULL
31843 };
31844
31845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
31847 if (!SWIG_IsOK(res1)) {
31848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
31849 }
31850 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
31851 arg2 = obj1;
31852 arg3 = obj2;
31853 {
31854 PyThreadState* __tstate = wxPyBeginAllowThreads();
31855 (arg1)->_setCallbackInfo(arg2,arg3);
31856 wxPyEndAllowThreads(__tstate);
31857 if (PyErr_Occurred()) SWIG_fail;
31858 }
31859 resultobj = SWIG_Py_Void();
31860 return resultobj;
31861 fail:
31862 return NULL;
31863 }
31864
31865
31866 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31867 PyObject *obj;
31868 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31869 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
31870 return SWIG_Py_Void();
31871 }
31872
31873 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31874 return SWIG_Python_InitShadowInstance(args);
31875 }
31876
31877 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31878 PyObject *resultobj = 0;
31879 wxFileDataObject *result = 0 ;
31880
31881 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
31882 {
31883 PyThreadState* __tstate = wxPyBeginAllowThreads();
31884 result = (wxFileDataObject *)new wxFileDataObject();
31885 wxPyEndAllowThreads(__tstate);
31886 if (PyErr_Occurred()) SWIG_fail;
31887 }
31888 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
31889 return resultobj;
31890 fail:
31891 return NULL;
31892 }
31893
31894
31895 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31896 PyObject *resultobj = 0;
31897 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31898 wxArrayString *result = 0 ;
31899 void *argp1 = 0 ;
31900 int res1 = 0 ;
31901 PyObject *swig_obj[1] ;
31902
31903 if (!args) SWIG_fail;
31904 swig_obj[0] = args;
31905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31906 if (!SWIG_IsOK(res1)) {
31907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31908 }
31909 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31910 {
31911 PyThreadState* __tstate = wxPyBeginAllowThreads();
31912 {
31913 wxArrayString const &_result_ref = (arg1)->GetFilenames();
31914 result = (wxArrayString *) &_result_ref;
31915 }
31916 wxPyEndAllowThreads(__tstate);
31917 if (PyErr_Occurred()) SWIG_fail;
31918 }
31919 {
31920 resultobj = wxArrayString2PyList_helper(*result);
31921 }
31922 return resultobj;
31923 fail:
31924 return NULL;
31925 }
31926
31927
31928 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31929 PyObject *resultobj = 0;
31930 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31931 wxString *arg2 = 0 ;
31932 void *argp1 = 0 ;
31933 int res1 = 0 ;
31934 bool temp2 = false ;
31935 PyObject * obj0 = 0 ;
31936 PyObject * obj1 = 0 ;
31937 char * kwnames[] = {
31938 (char *) "self",(char *) "filename", NULL
31939 };
31940
31941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
31942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31943 if (!SWIG_IsOK(res1)) {
31944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31945 }
31946 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31947 {
31948 arg2 = wxString_in_helper(obj1);
31949 if (arg2 == NULL) SWIG_fail;
31950 temp2 = true;
31951 }
31952 {
31953 PyThreadState* __tstate = wxPyBeginAllowThreads();
31954 (arg1)->AddFile((wxString const &)*arg2);
31955 wxPyEndAllowThreads(__tstate);
31956 if (PyErr_Occurred()) SWIG_fail;
31957 }
31958 resultobj = SWIG_Py_Void();
31959 {
31960 if (temp2)
31961 delete arg2;
31962 }
31963 return resultobj;
31964 fail:
31965 {
31966 if (temp2)
31967 delete arg2;
31968 }
31969 return NULL;
31970 }
31971
31972
31973 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31974 PyObject *obj;
31975 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31976 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
31977 return SWIG_Py_Void();
31978 }
31979
31980 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31981 return SWIG_Python_InitShadowInstance(args);
31982 }
31983
31984 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31985 PyObject *resultobj = 0;
31986 wxDataFormat *arg1 = 0 ;
31987 wxCustomDataObject *result = 0 ;
31988 void *argp1 = 0 ;
31989 int res1 = 0 ;
31990
31991 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31993 if (!SWIG_IsOK(res1)) {
31994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31995 }
31996 if (!argp1) {
31997 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31998 }
31999 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32000 {
32001 PyThreadState* __tstate = wxPyBeginAllowThreads();
32002 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
32003 wxPyEndAllowThreads(__tstate);
32004 if (PyErr_Occurred()) SWIG_fail;
32005 }
32006 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32007 return resultobj;
32008 fail:
32009 return NULL;
32010 }
32011
32012
32013 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
32014 PyObject *resultobj = 0;
32015 wxString *arg1 = 0 ;
32016 wxCustomDataObject *result = 0 ;
32017 bool temp1 = false ;
32018
32019 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
32020 {
32021 arg1 = wxString_in_helper(swig_obj[0]);
32022 if (arg1 == NULL) SWIG_fail;
32023 temp1 = true;
32024 }
32025 {
32026 PyThreadState* __tstate = wxPyBeginAllowThreads();
32027 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
32028 wxPyEndAllowThreads(__tstate);
32029 if (PyErr_Occurred()) SWIG_fail;
32030 }
32031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32032 {
32033 if (temp1)
32034 delete arg1;
32035 }
32036 return resultobj;
32037 fail:
32038 {
32039 if (temp1)
32040 delete arg1;
32041 }
32042 return NULL;
32043 }
32044
32045
32046 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
32047 PyObject *resultobj = 0;
32048 wxCustomDataObject *result = 0 ;
32049
32050 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
32051 {
32052 PyThreadState* __tstate = wxPyBeginAllowThreads();
32053 result = (wxCustomDataObject *)new wxCustomDataObject();
32054 wxPyEndAllowThreads(__tstate);
32055 if (PyErr_Occurred()) SWIG_fail;
32056 }
32057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32058 return resultobj;
32059 fail:
32060 return NULL;
32061 }
32062
32063
32064 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
32065 int argc;
32066 PyObject *argv[2];
32067
32068 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
32069 --argc;
32070 if (argc == 0) {
32071 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
32072 }
32073 if (argc == 1) {
32074 int _v = 0;
32075 {
32076 {
32077 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
32078 }
32079 }
32080 if (!_v) goto check_2;
32081 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
32082 }
32083 check_2:
32084
32085 if (argc == 1) {
32086 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
32087 }
32088
32089 fail:
32090 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
32091 return NULL;
32092 }
32093
32094
32095 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32096 PyObject *resultobj = 0;
32097 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32098 PyObject *arg2 = (PyObject *) 0 ;
32099 bool result;
32100 void *argp1 = 0 ;
32101 int res1 = 0 ;
32102 PyObject * obj0 = 0 ;
32103 PyObject * obj1 = 0 ;
32104 char * kwnames[] = {
32105 (char *) "self",(char *) "data", NULL
32106 };
32107
32108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32110 if (!SWIG_IsOK(res1)) {
32111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32112 }
32113 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32114 arg2 = obj1;
32115 {
32116 PyThreadState* __tstate = wxPyBeginAllowThreads();
32117 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
32118 wxPyEndAllowThreads(__tstate);
32119 if (PyErr_Occurred()) SWIG_fail;
32120 }
32121 {
32122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32123 }
32124 return resultobj;
32125 fail:
32126 return NULL;
32127 }
32128
32129
32130 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32131 PyObject *resultobj = 0;
32132 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32133 size_t result;
32134 void *argp1 = 0 ;
32135 int res1 = 0 ;
32136 PyObject *swig_obj[1] ;
32137
32138 if (!args) SWIG_fail;
32139 swig_obj[0] = args;
32140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32141 if (!SWIG_IsOK(res1)) {
32142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32143 }
32144 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32145 {
32146 PyThreadState* __tstate = wxPyBeginAllowThreads();
32147 result = (size_t)(arg1)->GetSize();
32148 wxPyEndAllowThreads(__tstate);
32149 if (PyErr_Occurred()) SWIG_fail;
32150 }
32151 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32152 return resultobj;
32153 fail:
32154 return NULL;
32155 }
32156
32157
32158 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32159 PyObject *resultobj = 0;
32160 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32161 PyObject *result = 0 ;
32162 void *argp1 = 0 ;
32163 int res1 = 0 ;
32164 PyObject *swig_obj[1] ;
32165
32166 if (!args) SWIG_fail;
32167 swig_obj[0] = args;
32168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32169 if (!SWIG_IsOK(res1)) {
32170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32171 }
32172 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32173 {
32174 PyThreadState* __tstate = wxPyBeginAllowThreads();
32175 result = (PyObject *)wxCustomDataObject_GetData(arg1);
32176 wxPyEndAllowThreads(__tstate);
32177 if (PyErr_Occurred()) SWIG_fail;
32178 }
32179 resultobj = result;
32180 return resultobj;
32181 fail:
32182 return NULL;
32183 }
32184
32185
32186 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32187 PyObject *obj;
32188 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32189 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
32190 return SWIG_Py_Void();
32191 }
32192
32193 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32194 return SWIG_Python_InitShadowInstance(args);
32195 }
32196
32197 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32198 PyObject *resultobj = 0;
32199 wxURLDataObject *result = 0 ;
32200
32201 if (!SWIG_Python_UnpackTuple(args,"new_URLDataObject",0,0,0)) SWIG_fail;
32202 {
32203 PyThreadState* __tstate = wxPyBeginAllowThreads();
32204 result = (wxURLDataObject *)new wxURLDataObject();
32205 wxPyEndAllowThreads(__tstate);
32206 if (PyErr_Occurred()) SWIG_fail;
32207 }
32208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
32209 return resultobj;
32210 fail:
32211 return NULL;
32212 }
32213
32214
32215 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32216 PyObject *resultobj = 0;
32217 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32218 wxString result;
32219 void *argp1 = 0 ;
32220 int res1 = 0 ;
32221 PyObject *swig_obj[1] ;
32222
32223 if (!args) SWIG_fail;
32224 swig_obj[0] = args;
32225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32226 if (!SWIG_IsOK(res1)) {
32227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32228 }
32229 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32230 {
32231 PyThreadState* __tstate = wxPyBeginAllowThreads();
32232 result = (arg1)->GetURL();
32233 wxPyEndAllowThreads(__tstate);
32234 if (PyErr_Occurred()) SWIG_fail;
32235 }
32236 {
32237 #if wxUSE_UNICODE
32238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32239 #else
32240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32241 #endif
32242 }
32243 return resultobj;
32244 fail:
32245 return NULL;
32246 }
32247
32248
32249 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32250 PyObject *resultobj = 0;
32251 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32252 wxString *arg2 = 0 ;
32253 void *argp1 = 0 ;
32254 int res1 = 0 ;
32255 bool temp2 = false ;
32256 PyObject * obj0 = 0 ;
32257 PyObject * obj1 = 0 ;
32258 char * kwnames[] = {
32259 (char *) "self",(char *) "url", NULL
32260 };
32261
32262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
32263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32264 if (!SWIG_IsOK(res1)) {
32265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32266 }
32267 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32268 {
32269 arg2 = wxString_in_helper(obj1);
32270 if (arg2 == NULL) SWIG_fail;
32271 temp2 = true;
32272 }
32273 {
32274 PyThreadState* __tstate = wxPyBeginAllowThreads();
32275 (arg1)->SetURL((wxString const &)*arg2);
32276 wxPyEndAllowThreads(__tstate);
32277 if (PyErr_Occurred()) SWIG_fail;
32278 }
32279 resultobj = SWIG_Py_Void();
32280 {
32281 if (temp2)
32282 delete arg2;
32283 }
32284 return resultobj;
32285 fail:
32286 {
32287 if (temp2)
32288 delete arg2;
32289 }
32290 return NULL;
32291 }
32292
32293
32294 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32295 PyObject *obj;
32296 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32297 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
32298 return SWIG_Py_Void();
32299 }
32300
32301 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32302 return SWIG_Python_InitShadowInstance(args);
32303 }
32304
32305 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32306 PyObject *resultobj = 0;
32307 wxMetafileDataObject *result = 0 ;
32308
32309 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
32310 {
32311 PyThreadState* __tstate = wxPyBeginAllowThreads();
32312 result = (wxMetafileDataObject *)new wxMetafileDataObject();
32313 wxPyEndAllowThreads(__tstate);
32314 if (PyErr_Occurred()) SWIG_fail;
32315 }
32316 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
32317 return resultobj;
32318 fail:
32319 return NULL;
32320 }
32321
32322
32323 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32324 PyObject *obj;
32325 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32326 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
32327 return SWIG_Py_Void();
32328 }
32329
32330 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32331 return SWIG_Python_InitShadowInstance(args);
32332 }
32333
32334 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32335 PyObject *resultobj = 0;
32336 wxDragResult arg1 ;
32337 bool result;
32338 int val1 ;
32339 int ecode1 = 0 ;
32340 PyObject * obj0 = 0 ;
32341 char * kwnames[] = {
32342 (char *) "res", NULL
32343 };
32344
32345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
32346 ecode1 = SWIG_AsVal_int(obj0, &val1);
32347 if (!SWIG_IsOK(ecode1)) {
32348 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
32349 }
32350 arg1 = static_cast< wxDragResult >(val1);
32351 {
32352 PyThreadState* __tstate = wxPyBeginAllowThreads();
32353 result = (bool)wxIsDragResultOk(arg1);
32354 wxPyEndAllowThreads(__tstate);
32355 if (PyErr_Occurred()) SWIG_fail;
32356 }
32357 {
32358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32359 }
32360 return resultobj;
32361 fail:
32362 return NULL;
32363 }
32364
32365
32366 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32367 PyObject *resultobj = 0;
32368 wxWindow *arg1 = (wxWindow *) 0 ;
32369 wxIcon const &arg2_defvalue = wxNullIcon ;
32370 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
32371 wxIcon const &arg3_defvalue = wxNullIcon ;
32372 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
32373 wxIcon const &arg4_defvalue = wxNullIcon ;
32374 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
32375 wxPyDropSource *result = 0 ;
32376 void *argp1 = 0 ;
32377 int res1 = 0 ;
32378 void *argp2 = 0 ;
32379 int res2 = 0 ;
32380 void *argp3 = 0 ;
32381 int res3 = 0 ;
32382 void *argp4 = 0 ;
32383 int res4 = 0 ;
32384 PyObject * obj0 = 0 ;
32385 PyObject * obj1 = 0 ;
32386 PyObject * obj2 = 0 ;
32387 PyObject * obj3 = 0 ;
32388 char * kwnames[] = {
32389 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
32390 };
32391
32392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32394 if (!SWIG_IsOK(res1)) {
32395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
32396 }
32397 arg1 = reinterpret_cast< wxWindow * >(argp1);
32398 if (obj1) {
32399 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
32400 if (!SWIG_IsOK(res2)) {
32401 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
32402 }
32403 if (!argp2) {
32404 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
32405 }
32406 arg2 = reinterpret_cast< wxIcon * >(argp2);
32407 }
32408 if (obj2) {
32409 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
32410 if (!SWIG_IsOK(res3)) {
32411 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
32412 }
32413 if (!argp3) {
32414 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
32415 }
32416 arg3 = reinterpret_cast< wxIcon * >(argp3);
32417 }
32418 if (obj3) {
32419 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
32420 if (!SWIG_IsOK(res4)) {
32421 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
32422 }
32423 if (!argp4) {
32424 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
32425 }
32426 arg4 = reinterpret_cast< wxIcon * >(argp4);
32427 }
32428 {
32429 PyThreadState* __tstate = wxPyBeginAllowThreads();
32430 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
32431 wxPyEndAllowThreads(__tstate);
32432 if (PyErr_Occurred()) SWIG_fail;
32433 }
32434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
32435 return resultobj;
32436 fail:
32437 return NULL;
32438 }
32439
32440
32441 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32442 PyObject *resultobj = 0;
32443 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32444 PyObject *arg2 = (PyObject *) 0 ;
32445 PyObject *arg3 = (PyObject *) 0 ;
32446 int arg4 ;
32447 void *argp1 = 0 ;
32448 int res1 = 0 ;
32449 int val4 ;
32450 int ecode4 = 0 ;
32451 PyObject * obj0 = 0 ;
32452 PyObject * obj1 = 0 ;
32453 PyObject * obj2 = 0 ;
32454 PyObject * obj3 = 0 ;
32455 char * kwnames[] = {
32456 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32457 };
32458
32459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32461 if (!SWIG_IsOK(res1)) {
32462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32463 }
32464 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32465 arg2 = obj1;
32466 arg3 = obj2;
32467 ecode4 = SWIG_AsVal_int(obj3, &val4);
32468 if (!SWIG_IsOK(ecode4)) {
32469 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
32470 }
32471 arg4 = static_cast< int >(val4);
32472 {
32473 PyThreadState* __tstate = wxPyBeginAllowThreads();
32474 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32475 wxPyEndAllowThreads(__tstate);
32476 if (PyErr_Occurred()) SWIG_fail;
32477 }
32478 resultobj = SWIG_Py_Void();
32479 return resultobj;
32480 fail:
32481 return NULL;
32482 }
32483
32484
32485 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32486 PyObject *resultobj = 0;
32487 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32488 void *argp1 = 0 ;
32489 int res1 = 0 ;
32490 PyObject *swig_obj[1] ;
32491
32492 if (!args) SWIG_fail;
32493 swig_obj[0] = args;
32494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
32495 if (!SWIG_IsOK(res1)) {
32496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32497 }
32498 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32499 {
32500 PyThreadState* __tstate = wxPyBeginAllowThreads();
32501 delete arg1;
32502
32503 wxPyEndAllowThreads(__tstate);
32504 if (PyErr_Occurred()) SWIG_fail;
32505 }
32506 resultobj = SWIG_Py_Void();
32507 return resultobj;
32508 fail:
32509 return NULL;
32510 }
32511
32512
32513 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32514 PyObject *resultobj = 0;
32515 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32516 wxDataObject *arg2 = 0 ;
32517 void *argp1 = 0 ;
32518 int res1 = 0 ;
32519 void *argp2 = 0 ;
32520 int res2 = 0 ;
32521 PyObject * obj0 = 0 ;
32522 PyObject * obj1 = 0 ;
32523 char * kwnames[] = {
32524 (char *) "self",(char *) "data", NULL
32525 };
32526
32527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32529 if (!SWIG_IsOK(res1)) {
32530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32531 }
32532 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32533 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
32534 if (!SWIG_IsOK(res2)) {
32535 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32536 }
32537 if (!argp2) {
32538 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32539 }
32540 arg2 = reinterpret_cast< wxDataObject * >(argp2);
32541 {
32542 PyThreadState* __tstate = wxPyBeginAllowThreads();
32543 (arg1)->SetData(*arg2);
32544 wxPyEndAllowThreads(__tstate);
32545 if (PyErr_Occurred()) SWIG_fail;
32546 }
32547 resultobj = SWIG_Py_Void();
32548 return resultobj;
32549 fail:
32550 return NULL;
32551 }
32552
32553
32554 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32555 PyObject *resultobj = 0;
32556 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32557 wxDataObject *result = 0 ;
32558 void *argp1 = 0 ;
32559 int res1 = 0 ;
32560 PyObject *swig_obj[1] ;
32561
32562 if (!args) SWIG_fail;
32563 swig_obj[0] = args;
32564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32565 if (!SWIG_IsOK(res1)) {
32566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32567 }
32568 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32569 {
32570 PyThreadState* __tstate = wxPyBeginAllowThreads();
32571 result = (wxDataObject *)(arg1)->GetDataObject();
32572 wxPyEndAllowThreads(__tstate);
32573 if (PyErr_Occurred()) SWIG_fail;
32574 }
32575 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32576 return resultobj;
32577 fail:
32578 return NULL;
32579 }
32580
32581
32582 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32583 PyObject *resultobj = 0;
32584 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32585 wxDragResult arg2 ;
32586 wxCursor *arg3 = 0 ;
32587 void *argp1 = 0 ;
32588 int res1 = 0 ;
32589 int val2 ;
32590 int ecode2 = 0 ;
32591 void *argp3 = 0 ;
32592 int res3 = 0 ;
32593 PyObject * obj0 = 0 ;
32594 PyObject * obj1 = 0 ;
32595 PyObject * obj2 = 0 ;
32596 char * kwnames[] = {
32597 (char *) "self",(char *) "res",(char *) "cursor", NULL
32598 };
32599
32600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32602 if (!SWIG_IsOK(res1)) {
32603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32604 }
32605 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32606 ecode2 = SWIG_AsVal_int(obj1, &val2);
32607 if (!SWIG_IsOK(ecode2)) {
32608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
32609 }
32610 arg2 = static_cast< wxDragResult >(val2);
32611 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32612 if (!SWIG_IsOK(res3)) {
32613 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32614 }
32615 if (!argp3) {
32616 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32617 }
32618 arg3 = reinterpret_cast< wxCursor * >(argp3);
32619 {
32620 PyThreadState* __tstate = wxPyBeginAllowThreads();
32621 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
32622 wxPyEndAllowThreads(__tstate);
32623 if (PyErr_Occurred()) SWIG_fail;
32624 }
32625 resultobj = SWIG_Py_Void();
32626 return resultobj;
32627 fail:
32628 return NULL;
32629 }
32630
32631
32632 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32633 PyObject *resultobj = 0;
32634 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32635 int arg2 = (int) wxDrag_CopyOnly ;
32636 wxDragResult result;
32637 void *argp1 = 0 ;
32638 int res1 = 0 ;
32639 int val2 ;
32640 int ecode2 = 0 ;
32641 PyObject * obj0 = 0 ;
32642 PyObject * obj1 = 0 ;
32643 char * kwnames[] = {
32644 (char *) "self",(char *) "flags", NULL
32645 };
32646
32647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
32648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32649 if (!SWIG_IsOK(res1)) {
32650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32651 }
32652 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32653 if (obj1) {
32654 ecode2 = SWIG_AsVal_int(obj1, &val2);
32655 if (!SWIG_IsOK(ecode2)) {
32656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
32657 }
32658 arg2 = static_cast< int >(val2);
32659 }
32660 {
32661 PyThreadState* __tstate = wxPyBeginAllowThreads();
32662 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
32663 wxPyEndAllowThreads(__tstate);
32664 if (PyErr_Occurred()) SWIG_fail;
32665 }
32666 resultobj = SWIG_From_int(static_cast< int >(result));
32667 return resultobj;
32668 fail:
32669 return NULL;
32670 }
32671
32672
32673 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32674 PyObject *resultobj = 0;
32675 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32676 wxDragResult arg2 ;
32677 bool result;
32678 void *argp1 = 0 ;
32679 int res1 = 0 ;
32680 int val2 ;
32681 int ecode2 = 0 ;
32682 PyObject * obj0 = 0 ;
32683 PyObject * obj1 = 0 ;
32684 char * kwnames[] = {
32685 (char *) "self",(char *) "effect", NULL
32686 };
32687
32688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
32689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32690 if (!SWIG_IsOK(res1)) {
32691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32692 }
32693 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32694 ecode2 = SWIG_AsVal_int(obj1, &val2);
32695 if (!SWIG_IsOK(ecode2)) {
32696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
32697 }
32698 arg2 = static_cast< wxDragResult >(val2);
32699 {
32700 PyThreadState* __tstate = wxPyBeginAllowThreads();
32701 result = (bool)(arg1)->GiveFeedback(arg2);
32702 wxPyEndAllowThreads(__tstate);
32703 if (PyErr_Occurred()) SWIG_fail;
32704 }
32705 {
32706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32707 }
32708 return resultobj;
32709 fail:
32710 return NULL;
32711 }
32712
32713
32714 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32715 PyObject *obj;
32716 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32717 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
32718 return SWIG_Py_Void();
32719 }
32720
32721 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32722 return SWIG_Python_InitShadowInstance(args);
32723 }
32724
32725 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32726 PyObject *resultobj = 0;
32727 wxDataObject *arg1 = (wxDataObject *) NULL ;
32728 wxPyDropTarget *result = 0 ;
32729 int res1 = 0 ;
32730 PyObject * obj0 = 0 ;
32731 char * kwnames[] = {
32732 (char *) "dataObject", NULL
32733 };
32734
32735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
32736 if (obj0) {
32737 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32738 if (!SWIG_IsOK(res1)) {
32739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
32740 }
32741 }
32742 {
32743 PyThreadState* __tstate = wxPyBeginAllowThreads();
32744 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
32745 wxPyEndAllowThreads(__tstate);
32746 if (PyErr_Occurred()) SWIG_fail;
32747 }
32748 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
32749 return resultobj;
32750 fail:
32751 return NULL;
32752 }
32753
32754
32755 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32756 PyObject *resultobj = 0;
32757 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32758 PyObject *arg2 = (PyObject *) 0 ;
32759 PyObject *arg3 = (PyObject *) 0 ;
32760 void *argp1 = 0 ;
32761 int res1 = 0 ;
32762 PyObject * obj0 = 0 ;
32763 PyObject * obj1 = 0 ;
32764 PyObject * obj2 = 0 ;
32765 char * kwnames[] = {
32766 (char *) "self",(char *) "self",(char *) "_class", NULL
32767 };
32768
32769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32771 if (!SWIG_IsOK(res1)) {
32772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32773 }
32774 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32775 arg2 = obj1;
32776 arg3 = obj2;
32777 {
32778 PyThreadState* __tstate = wxPyBeginAllowThreads();
32779 (arg1)->_setCallbackInfo(arg2,arg3);
32780 wxPyEndAllowThreads(__tstate);
32781 if (PyErr_Occurred()) SWIG_fail;
32782 }
32783 resultobj = SWIG_Py_Void();
32784 return resultobj;
32785 fail:
32786 return NULL;
32787 }
32788
32789
32790 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32791 PyObject *resultobj = 0;
32792 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32793 void *argp1 = 0 ;
32794 int res1 = 0 ;
32795 PyObject *swig_obj[1] ;
32796
32797 if (!args) SWIG_fail;
32798 swig_obj[0] = args;
32799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
32800 if (!SWIG_IsOK(res1)) {
32801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32802 }
32803 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32804 {
32805 PyThreadState* __tstate = wxPyBeginAllowThreads();
32806 delete arg1;
32807
32808 wxPyEndAllowThreads(__tstate);
32809 if (PyErr_Occurred()) SWIG_fail;
32810 }
32811 resultobj = SWIG_Py_Void();
32812 return resultobj;
32813 fail:
32814 return NULL;
32815 }
32816
32817
32818 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32819 PyObject *resultobj = 0;
32820 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32821 wxDataObject *result = 0 ;
32822 void *argp1 = 0 ;
32823 int res1 = 0 ;
32824 PyObject *swig_obj[1] ;
32825
32826 if (!args) SWIG_fail;
32827 swig_obj[0] = args;
32828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32829 if (!SWIG_IsOK(res1)) {
32830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32831 }
32832 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32833 {
32834 PyThreadState* __tstate = wxPyBeginAllowThreads();
32835 result = (wxDataObject *)(arg1)->GetDataObject();
32836 wxPyEndAllowThreads(__tstate);
32837 if (PyErr_Occurred()) SWIG_fail;
32838 }
32839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32840 return resultobj;
32841 fail:
32842 return NULL;
32843 }
32844
32845
32846 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32847 PyObject *resultobj = 0;
32848 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32849 wxDataObject *arg2 = (wxDataObject *) 0 ;
32850 void *argp1 = 0 ;
32851 int res1 = 0 ;
32852 int res2 = 0 ;
32853 PyObject * obj0 = 0 ;
32854 PyObject * obj1 = 0 ;
32855 char * kwnames[] = {
32856 (char *) "self",(char *) "dataObject", NULL
32857 };
32858
32859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
32860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32861 if (!SWIG_IsOK(res1)) {
32862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32863 }
32864 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32865 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32866 if (!SWIG_IsOK(res2)) {
32867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
32868 }
32869 {
32870 PyThreadState* __tstate = wxPyBeginAllowThreads();
32871 (arg1)->SetDataObject(arg2);
32872 wxPyEndAllowThreads(__tstate);
32873 if (PyErr_Occurred()) SWIG_fail;
32874 }
32875 resultobj = SWIG_Py_Void();
32876 return resultobj;
32877 fail:
32878 return NULL;
32879 }
32880
32881
32882 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32883 PyObject *resultobj = 0;
32884 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32885 int arg2 ;
32886 int arg3 ;
32887 wxDragResult arg4 ;
32888 wxDragResult result;
32889 void *argp1 = 0 ;
32890 int res1 = 0 ;
32891 int val2 ;
32892 int ecode2 = 0 ;
32893 int val3 ;
32894 int ecode3 = 0 ;
32895 int val4 ;
32896 int ecode4 = 0 ;
32897 PyObject * obj0 = 0 ;
32898 PyObject * obj1 = 0 ;
32899 PyObject * obj2 = 0 ;
32900 PyObject * obj3 = 0 ;
32901 char * kwnames[] = {
32902 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
32903 };
32904
32905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32907 if (!SWIG_IsOK(res1)) {
32908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32909 }
32910 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32911 ecode2 = SWIG_AsVal_int(obj1, &val2);
32912 if (!SWIG_IsOK(ecode2)) {
32913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
32914 }
32915 arg2 = static_cast< int >(val2);
32916 ecode3 = SWIG_AsVal_int(obj2, &val3);
32917 if (!SWIG_IsOK(ecode3)) {
32918 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
32919 }
32920 arg3 = static_cast< int >(val3);
32921 ecode4 = SWIG_AsVal_int(obj3, &val4);
32922 if (!SWIG_IsOK(ecode4)) {
32923 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
32924 }
32925 arg4 = static_cast< wxDragResult >(val4);
32926 {
32927 PyThreadState* __tstate = wxPyBeginAllowThreads();
32928 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
32929 wxPyEndAllowThreads(__tstate);
32930 if (PyErr_Occurred()) SWIG_fail;
32931 }
32932 resultobj = SWIG_From_int(static_cast< int >(result));
32933 return resultobj;
32934 fail:
32935 return NULL;
32936 }
32937
32938
32939 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32940 PyObject *resultobj = 0;
32941 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32942 int arg2 ;
32943 int arg3 ;
32944 wxDragResult arg4 ;
32945 wxDragResult result;
32946 void *argp1 = 0 ;
32947 int res1 = 0 ;
32948 int val2 ;
32949 int ecode2 = 0 ;
32950 int val3 ;
32951 int ecode3 = 0 ;
32952 int val4 ;
32953 int ecode4 = 0 ;
32954 PyObject * obj0 = 0 ;
32955 PyObject * obj1 = 0 ;
32956 PyObject * obj2 = 0 ;
32957 PyObject * obj3 = 0 ;
32958 char * kwnames[] = {
32959 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
32960 };
32961
32962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32964 if (!SWIG_IsOK(res1)) {
32965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32966 }
32967 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32968 ecode2 = SWIG_AsVal_int(obj1, &val2);
32969 if (!SWIG_IsOK(ecode2)) {
32970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
32971 }
32972 arg2 = static_cast< int >(val2);
32973 ecode3 = SWIG_AsVal_int(obj2, &val3);
32974 if (!SWIG_IsOK(ecode3)) {
32975 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
32976 }
32977 arg3 = static_cast< int >(val3);
32978 ecode4 = SWIG_AsVal_int(obj3, &val4);
32979 if (!SWIG_IsOK(ecode4)) {
32980 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
32981 }
32982 arg4 = static_cast< wxDragResult >(val4);
32983 {
32984 PyThreadState* __tstate = wxPyBeginAllowThreads();
32985 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
32986 wxPyEndAllowThreads(__tstate);
32987 if (PyErr_Occurred()) SWIG_fail;
32988 }
32989 resultobj = SWIG_From_int(static_cast< int >(result));
32990 return resultobj;
32991 fail:
32992 return NULL;
32993 }
32994
32995
32996 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32997 PyObject *resultobj = 0;
32998 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32999 void *argp1 = 0 ;
33000 int res1 = 0 ;
33001 PyObject *swig_obj[1] ;
33002
33003 if (!args) SWIG_fail;
33004 swig_obj[0] = args;
33005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33006 if (!SWIG_IsOK(res1)) {
33007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33008 }
33009 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33010 {
33011 PyThreadState* __tstate = wxPyBeginAllowThreads();
33012 (arg1)->OnLeave();
33013 wxPyEndAllowThreads(__tstate);
33014 if (PyErr_Occurred()) SWIG_fail;
33015 }
33016 resultobj = SWIG_Py_Void();
33017 return resultobj;
33018 fail:
33019 return NULL;
33020 }
33021
33022
33023 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33024 PyObject *resultobj = 0;
33025 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33026 int arg2 ;
33027 int arg3 ;
33028 bool result;
33029 void *argp1 = 0 ;
33030 int res1 = 0 ;
33031 int val2 ;
33032 int ecode2 = 0 ;
33033 int val3 ;
33034 int ecode3 = 0 ;
33035 PyObject * obj0 = 0 ;
33036 PyObject * obj1 = 0 ;
33037 PyObject * obj2 = 0 ;
33038 char * kwnames[] = {
33039 (char *) "self",(char *) "x",(char *) "y", NULL
33040 };
33041
33042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33044 if (!SWIG_IsOK(res1)) {
33045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33046 }
33047 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33048 ecode2 = SWIG_AsVal_int(obj1, &val2);
33049 if (!SWIG_IsOK(ecode2)) {
33050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33051 }
33052 arg2 = static_cast< int >(val2);
33053 ecode3 = SWIG_AsVal_int(obj2, &val3);
33054 if (!SWIG_IsOK(ecode3)) {
33055 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33056 }
33057 arg3 = static_cast< int >(val3);
33058 {
33059 PyThreadState* __tstate = wxPyBeginAllowThreads();
33060 result = (bool)(arg1)->OnDrop(arg2,arg3);
33061 wxPyEndAllowThreads(__tstate);
33062 if (PyErr_Occurred()) SWIG_fail;
33063 }
33064 {
33065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33066 }
33067 return resultobj;
33068 fail:
33069 return NULL;
33070 }
33071
33072
33073 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33074 PyObject *resultobj = 0;
33075 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33076 bool result;
33077 void *argp1 = 0 ;
33078 int res1 = 0 ;
33079 PyObject *swig_obj[1] ;
33080
33081 if (!args) SWIG_fail;
33082 swig_obj[0] = args;
33083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33084 if (!SWIG_IsOK(res1)) {
33085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33086 }
33087 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33088 {
33089 PyThreadState* __tstate = wxPyBeginAllowThreads();
33090 result = (bool)(arg1)->GetData();
33091 wxPyEndAllowThreads(__tstate);
33092 if (PyErr_Occurred()) SWIG_fail;
33093 }
33094 {
33095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33096 }
33097 return resultobj;
33098 fail:
33099 return NULL;
33100 }
33101
33102
33103 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33104 PyObject *resultobj = 0;
33105 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33106 wxDragResult arg2 ;
33107 void *argp1 = 0 ;
33108 int res1 = 0 ;
33109 int val2 ;
33110 int ecode2 = 0 ;
33111 PyObject * obj0 = 0 ;
33112 PyObject * obj1 = 0 ;
33113 char * kwnames[] = {
33114 (char *) "self",(char *) "action", NULL
33115 };
33116
33117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
33118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33119 if (!SWIG_IsOK(res1)) {
33120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33121 }
33122 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33123 ecode2 = SWIG_AsVal_int(obj1, &val2);
33124 if (!SWIG_IsOK(ecode2)) {
33125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
33126 }
33127 arg2 = static_cast< wxDragResult >(val2);
33128 {
33129 PyThreadState* __tstate = wxPyBeginAllowThreads();
33130 (arg1)->SetDefaultAction(arg2);
33131 wxPyEndAllowThreads(__tstate);
33132 if (PyErr_Occurred()) SWIG_fail;
33133 }
33134 resultobj = SWIG_Py_Void();
33135 return resultobj;
33136 fail:
33137 return NULL;
33138 }
33139
33140
33141 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33142 PyObject *resultobj = 0;
33143 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33144 wxDragResult result;
33145 void *argp1 = 0 ;
33146 int res1 = 0 ;
33147 PyObject *swig_obj[1] ;
33148
33149 if (!args) SWIG_fail;
33150 swig_obj[0] = args;
33151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33152 if (!SWIG_IsOK(res1)) {
33153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33154 }
33155 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33156 {
33157 PyThreadState* __tstate = wxPyBeginAllowThreads();
33158 result = (wxDragResult)(arg1)->GetDefaultAction();
33159 wxPyEndAllowThreads(__tstate);
33160 if (PyErr_Occurred()) SWIG_fail;
33161 }
33162 resultobj = SWIG_From_int(static_cast< int >(result));
33163 return resultobj;
33164 fail:
33165 return NULL;
33166 }
33167
33168
33169 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33170 PyObject *obj;
33171 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33172 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
33173 return SWIG_Py_Void();
33174 }
33175
33176 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33177 return SWIG_Python_InitShadowInstance(args);
33178 }
33179
33180 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33181 PyObject *resultobj = 0;
33182 wxPyTextDropTarget *result = 0 ;
33183
33184 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
33185 {
33186 PyThreadState* __tstate = wxPyBeginAllowThreads();
33187 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
33188 wxPyEndAllowThreads(__tstate);
33189 if (PyErr_Occurred()) SWIG_fail;
33190 }
33191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
33192 return resultobj;
33193 fail:
33194 return NULL;
33195 }
33196
33197
33198 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33199 PyObject *resultobj = 0;
33200 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33201 PyObject *arg2 = (PyObject *) 0 ;
33202 PyObject *arg3 = (PyObject *) 0 ;
33203 void *argp1 = 0 ;
33204 int res1 = 0 ;
33205 PyObject * obj0 = 0 ;
33206 PyObject * obj1 = 0 ;
33207 PyObject * obj2 = 0 ;
33208 char * kwnames[] = {
33209 (char *) "self",(char *) "self",(char *) "_class", NULL
33210 };
33211
33212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33214 if (!SWIG_IsOK(res1)) {
33215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33216 }
33217 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33218 arg2 = obj1;
33219 arg3 = obj2;
33220 {
33221 PyThreadState* __tstate = wxPyBeginAllowThreads();
33222 (arg1)->_setCallbackInfo(arg2,arg3);
33223 wxPyEndAllowThreads(__tstate);
33224 if (PyErr_Occurred()) SWIG_fail;
33225 }
33226 resultobj = SWIG_Py_Void();
33227 return resultobj;
33228 fail:
33229 return NULL;
33230 }
33231
33232
33233 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33234 PyObject *resultobj = 0;
33235 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33236 int arg2 ;
33237 int arg3 ;
33238 wxString *arg4 = 0 ;
33239 bool result;
33240 void *argp1 = 0 ;
33241 int res1 = 0 ;
33242 int val2 ;
33243 int ecode2 = 0 ;
33244 int val3 ;
33245 int ecode3 = 0 ;
33246 bool temp4 = false ;
33247 PyObject * obj0 = 0 ;
33248 PyObject * obj1 = 0 ;
33249 PyObject * obj2 = 0 ;
33250 PyObject * obj3 = 0 ;
33251 char * kwnames[] = {
33252 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
33253 };
33254
33255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33257 if (!SWIG_IsOK(res1)) {
33258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33259 }
33260 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33261 ecode2 = SWIG_AsVal_int(obj1, &val2);
33262 if (!SWIG_IsOK(ecode2)) {
33263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
33264 }
33265 arg2 = static_cast< int >(val2);
33266 ecode3 = SWIG_AsVal_int(obj2, &val3);
33267 if (!SWIG_IsOK(ecode3)) {
33268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
33269 }
33270 arg3 = static_cast< int >(val3);
33271 {
33272 arg4 = wxString_in_helper(obj3);
33273 if (arg4 == NULL) SWIG_fail;
33274 temp4 = true;
33275 }
33276 {
33277 PyThreadState* __tstate = wxPyBeginAllowThreads();
33278 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
33279 wxPyEndAllowThreads(__tstate);
33280 if (PyErr_Occurred()) SWIG_fail;
33281 }
33282 {
33283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33284 }
33285 {
33286 if (temp4)
33287 delete arg4;
33288 }
33289 return resultobj;
33290 fail:
33291 {
33292 if (temp4)
33293 delete arg4;
33294 }
33295 return NULL;
33296 }
33297
33298
33299 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33300 PyObject *resultobj = 0;
33301 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33302 int arg2 ;
33303 int arg3 ;
33304 wxDragResult arg4 ;
33305 wxDragResult result;
33306 void *argp1 = 0 ;
33307 int res1 = 0 ;
33308 int val2 ;
33309 int ecode2 = 0 ;
33310 int val3 ;
33311 int ecode3 = 0 ;
33312 int val4 ;
33313 int ecode4 = 0 ;
33314 PyObject * obj0 = 0 ;
33315 PyObject * obj1 = 0 ;
33316 PyObject * obj2 = 0 ;
33317 PyObject * obj3 = 0 ;
33318 char * kwnames[] = {
33319 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33320 };
33321
33322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33324 if (!SWIG_IsOK(res1)) {
33325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33326 }
33327 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33328 ecode2 = SWIG_AsVal_int(obj1, &val2);
33329 if (!SWIG_IsOK(ecode2)) {
33330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33331 }
33332 arg2 = static_cast< int >(val2);
33333 ecode3 = SWIG_AsVal_int(obj2, &val3);
33334 if (!SWIG_IsOK(ecode3)) {
33335 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33336 }
33337 arg3 = static_cast< int >(val3);
33338 ecode4 = SWIG_AsVal_int(obj3, &val4);
33339 if (!SWIG_IsOK(ecode4)) {
33340 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33341 }
33342 arg4 = static_cast< wxDragResult >(val4);
33343 {
33344 PyThreadState* __tstate = wxPyBeginAllowThreads();
33345 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33346 wxPyEndAllowThreads(__tstate);
33347 if (PyErr_Occurred()) SWIG_fail;
33348 }
33349 resultobj = SWIG_From_int(static_cast< int >(result));
33350 return resultobj;
33351 fail:
33352 return NULL;
33353 }
33354
33355
33356 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33357 PyObject *resultobj = 0;
33358 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33359 int arg2 ;
33360 int arg3 ;
33361 wxDragResult arg4 ;
33362 wxDragResult result;
33363 void *argp1 = 0 ;
33364 int res1 = 0 ;
33365 int val2 ;
33366 int ecode2 = 0 ;
33367 int val3 ;
33368 int ecode3 = 0 ;
33369 int val4 ;
33370 int ecode4 = 0 ;
33371 PyObject * obj0 = 0 ;
33372 PyObject * obj1 = 0 ;
33373 PyObject * obj2 = 0 ;
33374 PyObject * obj3 = 0 ;
33375 char * kwnames[] = {
33376 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33377 };
33378
33379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33381 if (!SWIG_IsOK(res1)) {
33382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33383 }
33384 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33385 ecode2 = SWIG_AsVal_int(obj1, &val2);
33386 if (!SWIG_IsOK(ecode2)) {
33387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33388 }
33389 arg2 = static_cast< int >(val2);
33390 ecode3 = SWIG_AsVal_int(obj2, &val3);
33391 if (!SWIG_IsOK(ecode3)) {
33392 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33393 }
33394 arg3 = static_cast< int >(val3);
33395 ecode4 = SWIG_AsVal_int(obj3, &val4);
33396 if (!SWIG_IsOK(ecode4)) {
33397 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33398 }
33399 arg4 = static_cast< wxDragResult >(val4);
33400 {
33401 PyThreadState* __tstate = wxPyBeginAllowThreads();
33402 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33403 wxPyEndAllowThreads(__tstate);
33404 if (PyErr_Occurred()) SWIG_fail;
33405 }
33406 resultobj = SWIG_From_int(static_cast< int >(result));
33407 return resultobj;
33408 fail:
33409 return NULL;
33410 }
33411
33412
33413 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33414 PyObject *resultobj = 0;
33415 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33416 void *argp1 = 0 ;
33417 int res1 = 0 ;
33418 PyObject *swig_obj[1] ;
33419
33420 if (!args) SWIG_fail;
33421 swig_obj[0] = args;
33422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33423 if (!SWIG_IsOK(res1)) {
33424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33425 }
33426 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33427 {
33428 PyThreadState* __tstate = wxPyBeginAllowThreads();
33429 (arg1)->OnLeave();
33430 wxPyEndAllowThreads(__tstate);
33431 if (PyErr_Occurred()) SWIG_fail;
33432 }
33433 resultobj = SWIG_Py_Void();
33434 return resultobj;
33435 fail:
33436 return NULL;
33437 }
33438
33439
33440 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33441 PyObject *resultobj = 0;
33442 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33443 int arg2 ;
33444 int arg3 ;
33445 bool result;
33446 void *argp1 = 0 ;
33447 int res1 = 0 ;
33448 int val2 ;
33449 int ecode2 = 0 ;
33450 int val3 ;
33451 int ecode3 = 0 ;
33452 PyObject * obj0 = 0 ;
33453 PyObject * obj1 = 0 ;
33454 PyObject * obj2 = 0 ;
33455 char * kwnames[] = {
33456 (char *) "self",(char *) "x",(char *) "y", NULL
33457 };
33458
33459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33461 if (!SWIG_IsOK(res1)) {
33462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33463 }
33464 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33465 ecode2 = SWIG_AsVal_int(obj1, &val2);
33466 if (!SWIG_IsOK(ecode2)) {
33467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33468 }
33469 arg2 = static_cast< int >(val2);
33470 ecode3 = SWIG_AsVal_int(obj2, &val3);
33471 if (!SWIG_IsOK(ecode3)) {
33472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33473 }
33474 arg3 = static_cast< int >(val3);
33475 {
33476 PyThreadState* __tstate = wxPyBeginAllowThreads();
33477 result = (bool)(arg1)->OnDrop(arg2,arg3);
33478 wxPyEndAllowThreads(__tstate);
33479 if (PyErr_Occurred()) SWIG_fail;
33480 }
33481 {
33482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33483 }
33484 return resultobj;
33485 fail:
33486 return NULL;
33487 }
33488
33489
33490 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33491 PyObject *resultobj = 0;
33492 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33493 int arg2 ;
33494 int arg3 ;
33495 wxDragResult arg4 ;
33496 wxDragResult result;
33497 void *argp1 = 0 ;
33498 int res1 = 0 ;
33499 int val2 ;
33500 int ecode2 = 0 ;
33501 int val3 ;
33502 int ecode3 = 0 ;
33503 int val4 ;
33504 int ecode4 = 0 ;
33505 PyObject * obj0 = 0 ;
33506 PyObject * obj1 = 0 ;
33507 PyObject * obj2 = 0 ;
33508 PyObject * obj3 = 0 ;
33509 char * kwnames[] = {
33510 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33511 };
33512
33513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33515 if (!SWIG_IsOK(res1)) {
33516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33517 }
33518 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33519 ecode2 = SWIG_AsVal_int(obj1, &val2);
33520 if (!SWIG_IsOK(ecode2)) {
33521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33522 }
33523 arg2 = static_cast< int >(val2);
33524 ecode3 = SWIG_AsVal_int(obj2, &val3);
33525 if (!SWIG_IsOK(ecode3)) {
33526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33527 }
33528 arg3 = static_cast< int >(val3);
33529 ecode4 = SWIG_AsVal_int(obj3, &val4);
33530 if (!SWIG_IsOK(ecode4)) {
33531 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33532 }
33533 arg4 = static_cast< wxDragResult >(val4);
33534 {
33535 PyThreadState* __tstate = wxPyBeginAllowThreads();
33536 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33537 wxPyEndAllowThreads(__tstate);
33538 if (PyErr_Occurred()) SWIG_fail;
33539 }
33540 resultobj = SWIG_From_int(static_cast< int >(result));
33541 return resultobj;
33542 fail:
33543 return NULL;
33544 }
33545
33546
33547 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33548 PyObject *obj;
33549 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33550 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
33551 return SWIG_Py_Void();
33552 }
33553
33554 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33555 return SWIG_Python_InitShadowInstance(args);
33556 }
33557
33558 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33559 PyObject *resultobj = 0;
33560 wxPyFileDropTarget *result = 0 ;
33561
33562 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
33563 {
33564 PyThreadState* __tstate = wxPyBeginAllowThreads();
33565 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
33566 wxPyEndAllowThreads(__tstate);
33567 if (PyErr_Occurred()) SWIG_fail;
33568 }
33569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
33570 return resultobj;
33571 fail:
33572 return NULL;
33573 }
33574
33575
33576 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33577 PyObject *resultobj = 0;
33578 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33579 PyObject *arg2 = (PyObject *) 0 ;
33580 PyObject *arg3 = (PyObject *) 0 ;
33581 void *argp1 = 0 ;
33582 int res1 = 0 ;
33583 PyObject * obj0 = 0 ;
33584 PyObject * obj1 = 0 ;
33585 PyObject * obj2 = 0 ;
33586 char * kwnames[] = {
33587 (char *) "self",(char *) "self",(char *) "_class", NULL
33588 };
33589
33590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33592 if (!SWIG_IsOK(res1)) {
33593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33594 }
33595 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33596 arg2 = obj1;
33597 arg3 = obj2;
33598 {
33599 PyThreadState* __tstate = wxPyBeginAllowThreads();
33600 (arg1)->_setCallbackInfo(arg2,arg3);
33601 wxPyEndAllowThreads(__tstate);
33602 if (PyErr_Occurred()) SWIG_fail;
33603 }
33604 resultobj = SWIG_Py_Void();
33605 return resultobj;
33606 fail:
33607 return NULL;
33608 }
33609
33610
33611 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33612 PyObject *resultobj = 0;
33613 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33614 int arg2 ;
33615 int arg3 ;
33616 wxArrayString *arg4 = 0 ;
33617 bool result;
33618 void *argp1 = 0 ;
33619 int res1 = 0 ;
33620 int val2 ;
33621 int ecode2 = 0 ;
33622 int val3 ;
33623 int ecode3 = 0 ;
33624 bool temp4 = false ;
33625 PyObject * obj0 = 0 ;
33626 PyObject * obj1 = 0 ;
33627 PyObject * obj2 = 0 ;
33628 PyObject * obj3 = 0 ;
33629 char * kwnames[] = {
33630 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
33631 };
33632
33633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33635 if (!SWIG_IsOK(res1)) {
33636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33637 }
33638 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33639 ecode2 = SWIG_AsVal_int(obj1, &val2);
33640 if (!SWIG_IsOK(ecode2)) {
33641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
33642 }
33643 arg2 = static_cast< int >(val2);
33644 ecode3 = SWIG_AsVal_int(obj2, &val3);
33645 if (!SWIG_IsOK(ecode3)) {
33646 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
33647 }
33648 arg3 = static_cast< int >(val3);
33649 {
33650 if (! PySequence_Check(obj3)) {
33651 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
33652 SWIG_fail;
33653 }
33654 arg4 = new wxArrayString;
33655 temp4 = true;
33656 int i, len=PySequence_Length(obj3);
33657 for (i=0; i<len; i++) {
33658 PyObject* item = PySequence_GetItem(obj3, i);
33659 wxString* s = wxString_in_helper(item);
33660 if (PyErr_Occurred()) SWIG_fail;
33661 arg4->Add(*s);
33662 delete s;
33663 Py_DECREF(item);
33664 }
33665 }
33666 {
33667 PyThreadState* __tstate = wxPyBeginAllowThreads();
33668 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
33669 wxPyEndAllowThreads(__tstate);
33670 if (PyErr_Occurred()) SWIG_fail;
33671 }
33672 {
33673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33674 }
33675 {
33676 if (temp4) delete arg4;
33677 }
33678 return resultobj;
33679 fail:
33680 {
33681 if (temp4) delete arg4;
33682 }
33683 return NULL;
33684 }
33685
33686
33687 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33688 PyObject *resultobj = 0;
33689 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33690 int arg2 ;
33691 int arg3 ;
33692 wxDragResult arg4 ;
33693 wxDragResult result;
33694 void *argp1 = 0 ;
33695 int res1 = 0 ;
33696 int val2 ;
33697 int ecode2 = 0 ;
33698 int val3 ;
33699 int ecode3 = 0 ;
33700 int val4 ;
33701 int ecode4 = 0 ;
33702 PyObject * obj0 = 0 ;
33703 PyObject * obj1 = 0 ;
33704 PyObject * obj2 = 0 ;
33705 PyObject * obj3 = 0 ;
33706 char * kwnames[] = {
33707 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33708 };
33709
33710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33712 if (!SWIG_IsOK(res1)) {
33713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33714 }
33715 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33716 ecode2 = SWIG_AsVal_int(obj1, &val2);
33717 if (!SWIG_IsOK(ecode2)) {
33718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33719 }
33720 arg2 = static_cast< int >(val2);
33721 ecode3 = SWIG_AsVal_int(obj2, &val3);
33722 if (!SWIG_IsOK(ecode3)) {
33723 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33724 }
33725 arg3 = static_cast< int >(val3);
33726 ecode4 = SWIG_AsVal_int(obj3, &val4);
33727 if (!SWIG_IsOK(ecode4)) {
33728 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33729 }
33730 arg4 = static_cast< wxDragResult >(val4);
33731 {
33732 PyThreadState* __tstate = wxPyBeginAllowThreads();
33733 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33734 wxPyEndAllowThreads(__tstate);
33735 if (PyErr_Occurred()) SWIG_fail;
33736 }
33737 resultobj = SWIG_From_int(static_cast< int >(result));
33738 return resultobj;
33739 fail:
33740 return NULL;
33741 }
33742
33743
33744 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33745 PyObject *resultobj = 0;
33746 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33747 int arg2 ;
33748 int arg3 ;
33749 wxDragResult arg4 ;
33750 wxDragResult result;
33751 void *argp1 = 0 ;
33752 int res1 = 0 ;
33753 int val2 ;
33754 int ecode2 = 0 ;
33755 int val3 ;
33756 int ecode3 = 0 ;
33757 int val4 ;
33758 int ecode4 = 0 ;
33759 PyObject * obj0 = 0 ;
33760 PyObject * obj1 = 0 ;
33761 PyObject * obj2 = 0 ;
33762 PyObject * obj3 = 0 ;
33763 char * kwnames[] = {
33764 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33765 };
33766
33767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33769 if (!SWIG_IsOK(res1)) {
33770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33771 }
33772 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33773 ecode2 = SWIG_AsVal_int(obj1, &val2);
33774 if (!SWIG_IsOK(ecode2)) {
33775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33776 }
33777 arg2 = static_cast< int >(val2);
33778 ecode3 = SWIG_AsVal_int(obj2, &val3);
33779 if (!SWIG_IsOK(ecode3)) {
33780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33781 }
33782 arg3 = static_cast< int >(val3);
33783 ecode4 = SWIG_AsVal_int(obj3, &val4);
33784 if (!SWIG_IsOK(ecode4)) {
33785 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33786 }
33787 arg4 = static_cast< wxDragResult >(val4);
33788 {
33789 PyThreadState* __tstate = wxPyBeginAllowThreads();
33790 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33791 wxPyEndAllowThreads(__tstate);
33792 if (PyErr_Occurred()) SWIG_fail;
33793 }
33794 resultobj = SWIG_From_int(static_cast< int >(result));
33795 return resultobj;
33796 fail:
33797 return NULL;
33798 }
33799
33800
33801 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33802 PyObject *resultobj = 0;
33803 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33804 void *argp1 = 0 ;
33805 int res1 = 0 ;
33806 PyObject *swig_obj[1] ;
33807
33808 if (!args) SWIG_fail;
33809 swig_obj[0] = args;
33810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33811 if (!SWIG_IsOK(res1)) {
33812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33813 }
33814 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33815 {
33816 PyThreadState* __tstate = wxPyBeginAllowThreads();
33817 (arg1)->OnLeave();
33818 wxPyEndAllowThreads(__tstate);
33819 if (PyErr_Occurred()) SWIG_fail;
33820 }
33821 resultobj = SWIG_Py_Void();
33822 return resultobj;
33823 fail:
33824 return NULL;
33825 }
33826
33827
33828 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33829 PyObject *resultobj = 0;
33830 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33831 int arg2 ;
33832 int arg3 ;
33833 bool result;
33834 void *argp1 = 0 ;
33835 int res1 = 0 ;
33836 int val2 ;
33837 int ecode2 = 0 ;
33838 int val3 ;
33839 int ecode3 = 0 ;
33840 PyObject * obj0 = 0 ;
33841 PyObject * obj1 = 0 ;
33842 PyObject * obj2 = 0 ;
33843 char * kwnames[] = {
33844 (char *) "self",(char *) "x",(char *) "y", NULL
33845 };
33846
33847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33849 if (!SWIG_IsOK(res1)) {
33850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33851 }
33852 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33853 ecode2 = SWIG_AsVal_int(obj1, &val2);
33854 if (!SWIG_IsOK(ecode2)) {
33855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33856 }
33857 arg2 = static_cast< int >(val2);
33858 ecode3 = SWIG_AsVal_int(obj2, &val3);
33859 if (!SWIG_IsOK(ecode3)) {
33860 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33861 }
33862 arg3 = static_cast< int >(val3);
33863 {
33864 PyThreadState* __tstate = wxPyBeginAllowThreads();
33865 result = (bool)(arg1)->OnDrop(arg2,arg3);
33866 wxPyEndAllowThreads(__tstate);
33867 if (PyErr_Occurred()) SWIG_fail;
33868 }
33869 {
33870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33871 }
33872 return resultobj;
33873 fail:
33874 return NULL;
33875 }
33876
33877
33878 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33879 PyObject *resultobj = 0;
33880 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33881 int arg2 ;
33882 int arg3 ;
33883 wxDragResult arg4 ;
33884 wxDragResult result;
33885 void *argp1 = 0 ;
33886 int res1 = 0 ;
33887 int val2 ;
33888 int ecode2 = 0 ;
33889 int val3 ;
33890 int ecode3 = 0 ;
33891 int val4 ;
33892 int ecode4 = 0 ;
33893 PyObject * obj0 = 0 ;
33894 PyObject * obj1 = 0 ;
33895 PyObject * obj2 = 0 ;
33896 PyObject * obj3 = 0 ;
33897 char * kwnames[] = {
33898 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33899 };
33900
33901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33903 if (!SWIG_IsOK(res1)) {
33904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33905 }
33906 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33907 ecode2 = SWIG_AsVal_int(obj1, &val2);
33908 if (!SWIG_IsOK(ecode2)) {
33909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33910 }
33911 arg2 = static_cast< int >(val2);
33912 ecode3 = SWIG_AsVal_int(obj2, &val3);
33913 if (!SWIG_IsOK(ecode3)) {
33914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33915 }
33916 arg3 = static_cast< int >(val3);
33917 ecode4 = SWIG_AsVal_int(obj3, &val4);
33918 if (!SWIG_IsOK(ecode4)) {
33919 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33920 }
33921 arg4 = static_cast< wxDragResult >(val4);
33922 {
33923 PyThreadState* __tstate = wxPyBeginAllowThreads();
33924 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33925 wxPyEndAllowThreads(__tstate);
33926 if (PyErr_Occurred()) SWIG_fail;
33927 }
33928 resultobj = SWIG_From_int(static_cast< int >(result));
33929 return resultobj;
33930 fail:
33931 return NULL;
33932 }
33933
33934
33935 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33936 PyObject *obj;
33937 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33938 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
33939 return SWIG_Py_Void();
33940 }
33941
33942 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33943 return SWIG_Python_InitShadowInstance(args);
33944 }
33945
33946 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33947 PyObject *resultobj = 0;
33948 wxClipboard *result = 0 ;
33949
33950 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
33951 {
33952 PyThreadState* __tstate = wxPyBeginAllowThreads();
33953 result = (wxClipboard *)new wxClipboard();
33954 wxPyEndAllowThreads(__tstate);
33955 if (PyErr_Occurred()) SWIG_fail;
33956 }
33957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
33958 return resultobj;
33959 fail:
33960 return NULL;
33961 }
33962
33963
33964 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33965 PyObject *resultobj = 0;
33966 wxClipboard *arg1 = (wxClipboard *) 0 ;
33967 void *argp1 = 0 ;
33968 int res1 = 0 ;
33969 PyObject *swig_obj[1] ;
33970
33971 if (!args) SWIG_fail;
33972 swig_obj[0] = args;
33973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
33974 if (!SWIG_IsOK(res1)) {
33975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
33976 }
33977 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33978 {
33979 PyThreadState* __tstate = wxPyBeginAllowThreads();
33980 delete arg1;
33981
33982 wxPyEndAllowThreads(__tstate);
33983 if (PyErr_Occurred()) SWIG_fail;
33984 }
33985 resultobj = SWIG_Py_Void();
33986 return resultobj;
33987 fail:
33988 return NULL;
33989 }
33990
33991
33992 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33993 PyObject *resultobj = 0;
33994 wxClipboard *arg1 = (wxClipboard *) 0 ;
33995 bool result;
33996 void *argp1 = 0 ;
33997 int res1 = 0 ;
33998 PyObject *swig_obj[1] ;
33999
34000 if (!args) SWIG_fail;
34001 swig_obj[0] = args;
34002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34003 if (!SWIG_IsOK(res1)) {
34004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
34005 }
34006 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34007 {
34008 PyThreadState* __tstate = wxPyBeginAllowThreads();
34009 result = (bool)(arg1)->Open();
34010 wxPyEndAllowThreads(__tstate);
34011 if (PyErr_Occurred()) SWIG_fail;
34012 }
34013 {
34014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34015 }
34016 return resultobj;
34017 fail:
34018 return NULL;
34019 }
34020
34021
34022 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34023 PyObject *resultobj = 0;
34024 wxClipboard *arg1 = (wxClipboard *) 0 ;
34025 void *argp1 = 0 ;
34026 int res1 = 0 ;
34027 PyObject *swig_obj[1] ;
34028
34029 if (!args) SWIG_fail;
34030 swig_obj[0] = args;
34031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34032 if (!SWIG_IsOK(res1)) {
34033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
34034 }
34035 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34036 {
34037 PyThreadState* __tstate = wxPyBeginAllowThreads();
34038 (arg1)->Close();
34039 wxPyEndAllowThreads(__tstate);
34040 if (PyErr_Occurred()) SWIG_fail;
34041 }
34042 resultobj = SWIG_Py_Void();
34043 return resultobj;
34044 fail:
34045 return NULL;
34046 }
34047
34048
34049 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34050 PyObject *resultobj = 0;
34051 wxClipboard *arg1 = (wxClipboard *) 0 ;
34052 bool result;
34053 void *argp1 = 0 ;
34054 int res1 = 0 ;
34055 PyObject *swig_obj[1] ;
34056
34057 if (!args) SWIG_fail;
34058 swig_obj[0] = args;
34059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34060 if (!SWIG_IsOK(res1)) {
34061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
34062 }
34063 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34064 {
34065 PyThreadState* __tstate = wxPyBeginAllowThreads();
34066 result = (bool)((wxClipboard const *)arg1)->IsOpened();
34067 wxPyEndAllowThreads(__tstate);
34068 if (PyErr_Occurred()) SWIG_fail;
34069 }
34070 {
34071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34072 }
34073 return resultobj;
34074 fail:
34075 return NULL;
34076 }
34077
34078
34079 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34080 PyObject *resultobj = 0;
34081 wxClipboard *arg1 = (wxClipboard *) 0 ;
34082 wxDataObject *arg2 = (wxDataObject *) 0 ;
34083 bool result;
34084 void *argp1 = 0 ;
34085 int res1 = 0 ;
34086 int res2 = 0 ;
34087 PyObject * obj0 = 0 ;
34088 PyObject * obj1 = 0 ;
34089 char * kwnames[] = {
34090 (char *) "self",(char *) "data", NULL
34091 };
34092
34093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
34094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34095 if (!SWIG_IsOK(res1)) {
34096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34097 }
34098 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34099 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34100 if (!SWIG_IsOK(res2)) {
34101 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34102 }
34103 {
34104 PyThreadState* __tstate = wxPyBeginAllowThreads();
34105 result = (bool)(arg1)->AddData(arg2);
34106 wxPyEndAllowThreads(__tstate);
34107 if (PyErr_Occurred()) SWIG_fail;
34108 }
34109 {
34110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34111 }
34112 return resultobj;
34113 fail:
34114 return NULL;
34115 }
34116
34117
34118 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34119 PyObject *resultobj = 0;
34120 wxClipboard *arg1 = (wxClipboard *) 0 ;
34121 wxDataObject *arg2 = (wxDataObject *) 0 ;
34122 bool result;
34123 void *argp1 = 0 ;
34124 int res1 = 0 ;
34125 int res2 = 0 ;
34126 PyObject * obj0 = 0 ;
34127 PyObject * obj1 = 0 ;
34128 char * kwnames[] = {
34129 (char *) "self",(char *) "data", NULL
34130 };
34131
34132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
34133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34134 if (!SWIG_IsOK(res1)) {
34135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34136 }
34137 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34138 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34139 if (!SWIG_IsOK(res2)) {
34140 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34141 }
34142 {
34143 PyThreadState* __tstate = wxPyBeginAllowThreads();
34144 result = (bool)(arg1)->SetData(arg2);
34145 wxPyEndAllowThreads(__tstate);
34146 if (PyErr_Occurred()) SWIG_fail;
34147 }
34148 {
34149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34150 }
34151 return resultobj;
34152 fail:
34153 return NULL;
34154 }
34155
34156
34157 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34158 PyObject *resultobj = 0;
34159 wxClipboard *arg1 = (wxClipboard *) 0 ;
34160 wxDataFormat *arg2 = 0 ;
34161 bool result;
34162 void *argp1 = 0 ;
34163 int res1 = 0 ;
34164 void *argp2 = 0 ;
34165 int res2 = 0 ;
34166 PyObject * obj0 = 0 ;
34167 PyObject * obj1 = 0 ;
34168 char * kwnames[] = {
34169 (char *) "self",(char *) "format", NULL
34170 };
34171
34172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
34173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34174 if (!SWIG_IsOK(res1)) {
34175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
34176 }
34177 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34178 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
34179 if (!SWIG_IsOK(res2)) {
34180 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34181 }
34182 if (!argp2) {
34183 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34184 }
34185 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
34186 {
34187 PyThreadState* __tstate = wxPyBeginAllowThreads();
34188 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
34189 wxPyEndAllowThreads(__tstate);
34190 if (PyErr_Occurred()) SWIG_fail;
34191 }
34192 {
34193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34194 }
34195 return resultobj;
34196 fail:
34197 return NULL;
34198 }
34199
34200
34201 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34202 PyObject *resultobj = 0;
34203 wxClipboard *arg1 = (wxClipboard *) 0 ;
34204 wxDataObject *arg2 = 0 ;
34205 bool result;
34206 void *argp1 = 0 ;
34207 int res1 = 0 ;
34208 void *argp2 = 0 ;
34209 int res2 = 0 ;
34210 PyObject * obj0 = 0 ;
34211 PyObject * obj1 = 0 ;
34212 char * kwnames[] = {
34213 (char *) "self",(char *) "data", NULL
34214 };
34215
34216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
34217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34218 if (!SWIG_IsOK(res1)) {
34219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34220 }
34221 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34222 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34223 if (!SWIG_IsOK(res2)) {
34224 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34225 }
34226 if (!argp2) {
34227 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34228 }
34229 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34230 {
34231 PyThreadState* __tstate = wxPyBeginAllowThreads();
34232 result = (bool)(arg1)->GetData(*arg2);
34233 wxPyEndAllowThreads(__tstate);
34234 if (PyErr_Occurred()) SWIG_fail;
34235 }
34236 {
34237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34238 }
34239 return resultobj;
34240 fail:
34241 return NULL;
34242 }
34243
34244
34245 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34246 PyObject *resultobj = 0;
34247 wxClipboard *arg1 = (wxClipboard *) 0 ;
34248 void *argp1 = 0 ;
34249 int res1 = 0 ;
34250 PyObject *swig_obj[1] ;
34251
34252 if (!args) SWIG_fail;
34253 swig_obj[0] = args;
34254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34255 if (!SWIG_IsOK(res1)) {
34256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
34257 }
34258 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34259 {
34260 PyThreadState* __tstate = wxPyBeginAllowThreads();
34261 (arg1)->Clear();
34262 wxPyEndAllowThreads(__tstate);
34263 if (PyErr_Occurred()) SWIG_fail;
34264 }
34265 resultobj = SWIG_Py_Void();
34266 return resultobj;
34267 fail:
34268 return NULL;
34269 }
34270
34271
34272 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34273 PyObject *resultobj = 0;
34274 wxClipboard *arg1 = (wxClipboard *) 0 ;
34275 bool result;
34276 void *argp1 = 0 ;
34277 int res1 = 0 ;
34278 PyObject *swig_obj[1] ;
34279
34280 if (!args) SWIG_fail;
34281 swig_obj[0] = args;
34282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34283 if (!SWIG_IsOK(res1)) {
34284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
34285 }
34286 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34287 {
34288 PyThreadState* __tstate = wxPyBeginAllowThreads();
34289 result = (bool)(arg1)->Flush();
34290 wxPyEndAllowThreads(__tstate);
34291 if (PyErr_Occurred()) SWIG_fail;
34292 }
34293 {
34294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34295 }
34296 return resultobj;
34297 fail:
34298 return NULL;
34299 }
34300
34301
34302 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34303 PyObject *resultobj = 0;
34304 wxClipboard *arg1 = (wxClipboard *) 0 ;
34305 bool arg2 = (bool) true ;
34306 void *argp1 = 0 ;
34307 int res1 = 0 ;
34308 bool val2 ;
34309 int ecode2 = 0 ;
34310 PyObject * obj0 = 0 ;
34311 PyObject * obj1 = 0 ;
34312 char * kwnames[] = {
34313 (char *) "self",(char *) "primary", NULL
34314 };
34315
34316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
34317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34318 if (!SWIG_IsOK(res1)) {
34319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
34320 }
34321 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34322 if (obj1) {
34323 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34324 if (!SWIG_IsOK(ecode2)) {
34325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
34326 }
34327 arg2 = static_cast< bool >(val2);
34328 }
34329 {
34330 PyThreadState* __tstate = wxPyBeginAllowThreads();
34331 (arg1)->UsePrimarySelection(arg2);
34332 wxPyEndAllowThreads(__tstate);
34333 if (PyErr_Occurred()) SWIG_fail;
34334 }
34335 resultobj = SWIG_Py_Void();
34336 return resultobj;
34337 fail:
34338 return NULL;
34339 }
34340
34341
34342 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34343 PyObject *resultobj = 0;
34344 wxClipboard *result = 0 ;
34345
34346 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
34347 {
34348 PyThreadState* __tstate = wxPyBeginAllowThreads();
34349 result = (wxClipboard *)wxClipboard::Get();
34350 wxPyEndAllowThreads(__tstate);
34351 if (PyErr_Occurred()) SWIG_fail;
34352 }
34353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
34354 return resultobj;
34355 fail:
34356 return NULL;
34357 }
34358
34359
34360 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34361 PyObject *obj;
34362 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34363 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
34364 return SWIG_Py_Void();
34365 }
34366
34367 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34368 return SWIG_Python_InitShadowInstance(args);
34369 }
34370
34371 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34372 PyObject *resultobj = 0;
34373 wxClipboard *arg1 = (wxClipboard *) NULL ;
34374 wxClipboardLocker *result = 0 ;
34375 void *argp1 = 0 ;
34376 int res1 = 0 ;
34377 PyObject * obj0 = 0 ;
34378 char * kwnames[] = {
34379 (char *) "clipboard", NULL
34380 };
34381
34382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
34383 if (obj0) {
34384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34385 if (!SWIG_IsOK(res1)) {
34386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
34387 }
34388 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34389 }
34390 {
34391 PyThreadState* __tstate = wxPyBeginAllowThreads();
34392 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
34393 wxPyEndAllowThreads(__tstate);
34394 if (PyErr_Occurred()) SWIG_fail;
34395 }
34396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
34397 return resultobj;
34398 fail:
34399 return NULL;
34400 }
34401
34402
34403 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34404 PyObject *resultobj = 0;
34405 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34406 void *argp1 = 0 ;
34407 int res1 = 0 ;
34408 PyObject *swig_obj[1] ;
34409
34410 if (!args) SWIG_fail;
34411 swig_obj[0] = args;
34412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
34413 if (!SWIG_IsOK(res1)) {
34414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34415 }
34416 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34417 {
34418 PyThreadState* __tstate = wxPyBeginAllowThreads();
34419 delete arg1;
34420
34421 wxPyEndAllowThreads(__tstate);
34422 if (PyErr_Occurred()) SWIG_fail;
34423 }
34424 resultobj = SWIG_Py_Void();
34425 return resultobj;
34426 fail:
34427 return NULL;
34428 }
34429
34430
34431 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34432 PyObject *resultobj = 0;
34433 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34434 bool result;
34435 void *argp1 = 0 ;
34436 int res1 = 0 ;
34437 PyObject *swig_obj[1] ;
34438
34439 if (!args) SWIG_fail;
34440 swig_obj[0] = args;
34441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
34442 if (!SWIG_IsOK(res1)) {
34443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34444 }
34445 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34446 {
34447 PyThreadState* __tstate = wxPyBeginAllowThreads();
34448 result = (bool)wxClipboardLocker___nonzero__(arg1);
34449 wxPyEndAllowThreads(__tstate);
34450 if (PyErr_Occurred()) SWIG_fail;
34451 }
34452 {
34453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34454 }
34455 return resultobj;
34456 fail:
34457 return NULL;
34458 }
34459
34460
34461 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34462 PyObject *obj;
34463 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34464 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
34465 return SWIG_Py_Void();
34466 }
34467
34468 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34469 return SWIG_Python_InitShadowInstance(args);
34470 }
34471
34472 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34473 PyObject *resultobj = 0;
34474 int arg1 = (int) 0 ;
34475 int arg2 = (int) 0 ;
34476 int arg3 = (int) 0 ;
34477 int arg4 = (int) 0 ;
34478 wxVideoMode *result = 0 ;
34479 int val1 ;
34480 int ecode1 = 0 ;
34481 int val2 ;
34482 int ecode2 = 0 ;
34483 int val3 ;
34484 int ecode3 = 0 ;
34485 int val4 ;
34486 int ecode4 = 0 ;
34487 PyObject * obj0 = 0 ;
34488 PyObject * obj1 = 0 ;
34489 PyObject * obj2 = 0 ;
34490 PyObject * obj3 = 0 ;
34491 char * kwnames[] = {
34492 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
34493 };
34494
34495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34496 if (obj0) {
34497 ecode1 = SWIG_AsVal_int(obj0, &val1);
34498 if (!SWIG_IsOK(ecode1)) {
34499 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
34500 }
34501 arg1 = static_cast< int >(val1);
34502 }
34503 if (obj1) {
34504 ecode2 = SWIG_AsVal_int(obj1, &val2);
34505 if (!SWIG_IsOK(ecode2)) {
34506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
34507 }
34508 arg2 = static_cast< int >(val2);
34509 }
34510 if (obj2) {
34511 ecode3 = SWIG_AsVal_int(obj2, &val3);
34512 if (!SWIG_IsOK(ecode3)) {
34513 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
34514 }
34515 arg3 = static_cast< int >(val3);
34516 }
34517 if (obj3) {
34518 ecode4 = SWIG_AsVal_int(obj3, &val4);
34519 if (!SWIG_IsOK(ecode4)) {
34520 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
34521 }
34522 arg4 = static_cast< int >(val4);
34523 }
34524 {
34525 PyThreadState* __tstate = wxPyBeginAllowThreads();
34526 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
34527 wxPyEndAllowThreads(__tstate);
34528 if (PyErr_Occurred()) SWIG_fail;
34529 }
34530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
34531 return resultobj;
34532 fail:
34533 return NULL;
34534 }
34535
34536
34537 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34538 PyObject *resultobj = 0;
34539 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34540 void *argp1 = 0 ;
34541 int res1 = 0 ;
34542 PyObject *swig_obj[1] ;
34543
34544 if (!args) SWIG_fail;
34545 swig_obj[0] = args;
34546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
34547 if (!SWIG_IsOK(res1)) {
34548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34549 }
34550 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34551 {
34552 PyThreadState* __tstate = wxPyBeginAllowThreads();
34553 delete arg1;
34554
34555 wxPyEndAllowThreads(__tstate);
34556 if (PyErr_Occurred()) SWIG_fail;
34557 }
34558 resultobj = SWIG_Py_Void();
34559 return resultobj;
34560 fail:
34561 return NULL;
34562 }
34563
34564
34565 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34566 PyObject *resultobj = 0;
34567 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34568 wxVideoMode *arg2 = 0 ;
34569 bool result;
34570 void *argp1 = 0 ;
34571 int res1 = 0 ;
34572 void *argp2 = 0 ;
34573 int res2 = 0 ;
34574 PyObject * obj0 = 0 ;
34575 PyObject * obj1 = 0 ;
34576 char * kwnames[] = {
34577 (char *) "self",(char *) "other", NULL
34578 };
34579
34580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
34581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34582 if (!SWIG_IsOK(res1)) {
34583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34584 }
34585 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34586 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
34587 if (!SWIG_IsOK(res2)) {
34588 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34589 }
34590 if (!argp2) {
34591 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34592 }
34593 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34594 {
34595 PyThreadState* __tstate = wxPyBeginAllowThreads();
34596 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
34597 wxPyEndAllowThreads(__tstate);
34598 if (PyErr_Occurred()) SWIG_fail;
34599 }
34600 {
34601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34602 }
34603 return resultobj;
34604 fail:
34605 return NULL;
34606 }
34607
34608
34609 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34610 PyObject *resultobj = 0;
34611 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34612 int result;
34613 void *argp1 = 0 ;
34614 int res1 = 0 ;
34615 PyObject *swig_obj[1] ;
34616
34617 if (!args) SWIG_fail;
34618 swig_obj[0] = args;
34619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34620 if (!SWIG_IsOK(res1)) {
34621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34622 }
34623 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34624 {
34625 PyThreadState* __tstate = wxPyBeginAllowThreads();
34626 result = (int)((wxVideoMode const *)arg1)->GetWidth();
34627 wxPyEndAllowThreads(__tstate);
34628 if (PyErr_Occurred()) SWIG_fail;
34629 }
34630 resultobj = SWIG_From_int(static_cast< int >(result));
34631 return resultobj;
34632 fail:
34633 return NULL;
34634 }
34635
34636
34637 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34638 PyObject *resultobj = 0;
34639 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34640 int result;
34641 void *argp1 = 0 ;
34642 int res1 = 0 ;
34643 PyObject *swig_obj[1] ;
34644
34645 if (!args) SWIG_fail;
34646 swig_obj[0] = args;
34647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34648 if (!SWIG_IsOK(res1)) {
34649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34650 }
34651 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34652 {
34653 PyThreadState* __tstate = wxPyBeginAllowThreads();
34654 result = (int)((wxVideoMode const *)arg1)->GetHeight();
34655 wxPyEndAllowThreads(__tstate);
34656 if (PyErr_Occurred()) SWIG_fail;
34657 }
34658 resultobj = SWIG_From_int(static_cast< int >(result));
34659 return resultobj;
34660 fail:
34661 return NULL;
34662 }
34663
34664
34665 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34666 PyObject *resultobj = 0;
34667 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34668 int result;
34669 void *argp1 = 0 ;
34670 int res1 = 0 ;
34671 PyObject *swig_obj[1] ;
34672
34673 if (!args) SWIG_fail;
34674 swig_obj[0] = args;
34675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34676 if (!SWIG_IsOK(res1)) {
34677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34678 }
34679 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34680 {
34681 PyThreadState* __tstate = wxPyBeginAllowThreads();
34682 result = (int)((wxVideoMode const *)arg1)->GetDepth();
34683 wxPyEndAllowThreads(__tstate);
34684 if (PyErr_Occurred()) SWIG_fail;
34685 }
34686 resultobj = SWIG_From_int(static_cast< int >(result));
34687 return resultobj;
34688 fail:
34689 return NULL;
34690 }
34691
34692
34693 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34694 PyObject *resultobj = 0;
34695 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34696 bool result;
34697 void *argp1 = 0 ;
34698 int res1 = 0 ;
34699 PyObject *swig_obj[1] ;
34700
34701 if (!args) SWIG_fail;
34702 swig_obj[0] = args;
34703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34704 if (!SWIG_IsOK(res1)) {
34705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34706 }
34707 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34708 {
34709 PyThreadState* __tstate = wxPyBeginAllowThreads();
34710 result = (bool)((wxVideoMode const *)arg1)->IsOk();
34711 wxPyEndAllowThreads(__tstate);
34712 if (PyErr_Occurred()) SWIG_fail;
34713 }
34714 {
34715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34716 }
34717 return resultobj;
34718 fail:
34719 return NULL;
34720 }
34721
34722
34723 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34724 PyObject *resultobj = 0;
34725 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34726 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34727 bool result;
34728 void *argp1 = 0 ;
34729 int res1 = 0 ;
34730 void *argp2 = 0 ;
34731 int res2 = 0 ;
34732 PyObject * obj0 = 0 ;
34733 PyObject * obj1 = 0 ;
34734 char * kwnames[] = {
34735 (char *) "self",(char *) "other", NULL
34736 };
34737
34738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
34739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34740 if (!SWIG_IsOK(res1)) {
34741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34742 }
34743 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34744 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34745 if (!SWIG_IsOK(res2)) {
34746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34747 }
34748 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34749 {
34750 PyThreadState* __tstate = wxPyBeginAllowThreads();
34751 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
34752 wxPyEndAllowThreads(__tstate);
34753 if (PyErr_Occurred()) SWIG_fail;
34754 }
34755 {
34756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34757 }
34758 return resultobj;
34759 fail:
34760 return NULL;
34761 }
34762
34763
34764 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34765 PyObject *resultobj = 0;
34766 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34767 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34768 bool result;
34769 void *argp1 = 0 ;
34770 int res1 = 0 ;
34771 void *argp2 = 0 ;
34772 int res2 = 0 ;
34773 PyObject * obj0 = 0 ;
34774 PyObject * obj1 = 0 ;
34775 char * kwnames[] = {
34776 (char *) "self",(char *) "other", NULL
34777 };
34778
34779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
34780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34781 if (!SWIG_IsOK(res1)) {
34782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34783 }
34784 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34785 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34786 if (!SWIG_IsOK(res2)) {
34787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34788 }
34789 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34790 {
34791 PyThreadState* __tstate = wxPyBeginAllowThreads();
34792 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
34793 wxPyEndAllowThreads(__tstate);
34794 if (PyErr_Occurred()) SWIG_fail;
34795 }
34796 {
34797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34798 }
34799 return resultobj;
34800 fail:
34801 return NULL;
34802 }
34803
34804
34805 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34806 PyObject *resultobj = 0;
34807 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34808 int arg2 ;
34809 void *argp1 = 0 ;
34810 int res1 = 0 ;
34811 int val2 ;
34812 int ecode2 = 0 ;
34813 PyObject *swig_obj[2] ;
34814
34815 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
34816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34817 if (!SWIG_IsOK(res1)) {
34818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34819 }
34820 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34821 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34822 if (!SWIG_IsOK(ecode2)) {
34823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
34824 }
34825 arg2 = static_cast< int >(val2);
34826 if (arg1) (arg1)->w = arg2;
34827
34828 resultobj = SWIG_Py_Void();
34829 return resultobj;
34830 fail:
34831 return NULL;
34832 }
34833
34834
34835 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34836 PyObject *resultobj = 0;
34837 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34838 int result;
34839 void *argp1 = 0 ;
34840 int res1 = 0 ;
34841 PyObject *swig_obj[1] ;
34842
34843 if (!args) SWIG_fail;
34844 swig_obj[0] = args;
34845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34846 if (!SWIG_IsOK(res1)) {
34847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34848 }
34849 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34850 result = (int) ((arg1)->w);
34851 resultobj = SWIG_From_int(static_cast< int >(result));
34852 return resultobj;
34853 fail:
34854 return NULL;
34855 }
34856
34857
34858 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34859 PyObject *resultobj = 0;
34860 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34861 int arg2 ;
34862 void *argp1 = 0 ;
34863 int res1 = 0 ;
34864 int val2 ;
34865 int ecode2 = 0 ;
34866 PyObject *swig_obj[2] ;
34867
34868 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
34869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34870 if (!SWIG_IsOK(res1)) {
34871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34872 }
34873 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34874 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34875 if (!SWIG_IsOK(ecode2)) {
34876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
34877 }
34878 arg2 = static_cast< int >(val2);
34879 if (arg1) (arg1)->h = arg2;
34880
34881 resultobj = SWIG_Py_Void();
34882 return resultobj;
34883 fail:
34884 return NULL;
34885 }
34886
34887
34888 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34889 PyObject *resultobj = 0;
34890 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34891 int result;
34892 void *argp1 = 0 ;
34893 int res1 = 0 ;
34894 PyObject *swig_obj[1] ;
34895
34896 if (!args) SWIG_fail;
34897 swig_obj[0] = args;
34898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34899 if (!SWIG_IsOK(res1)) {
34900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34901 }
34902 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34903 result = (int) ((arg1)->h);
34904 resultobj = SWIG_From_int(static_cast< int >(result));
34905 return resultobj;
34906 fail:
34907 return NULL;
34908 }
34909
34910
34911 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34912 PyObject *resultobj = 0;
34913 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34914 int arg2 ;
34915 void *argp1 = 0 ;
34916 int res1 = 0 ;
34917 int val2 ;
34918 int ecode2 = 0 ;
34919 PyObject *swig_obj[2] ;
34920
34921 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
34922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34923 if (!SWIG_IsOK(res1)) {
34924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34925 }
34926 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34927 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34928 if (!SWIG_IsOK(ecode2)) {
34929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
34930 }
34931 arg2 = static_cast< int >(val2);
34932 if (arg1) (arg1)->bpp = arg2;
34933
34934 resultobj = SWIG_Py_Void();
34935 return resultobj;
34936 fail:
34937 return NULL;
34938 }
34939
34940
34941 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34942 PyObject *resultobj = 0;
34943 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34944 int result;
34945 void *argp1 = 0 ;
34946 int res1 = 0 ;
34947 PyObject *swig_obj[1] ;
34948
34949 if (!args) SWIG_fail;
34950 swig_obj[0] = args;
34951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34952 if (!SWIG_IsOK(res1)) {
34953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34954 }
34955 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34956 result = (int) ((arg1)->bpp);
34957 resultobj = SWIG_From_int(static_cast< int >(result));
34958 return resultobj;
34959 fail:
34960 return NULL;
34961 }
34962
34963
34964 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34965 PyObject *resultobj = 0;
34966 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34967 int arg2 ;
34968 void *argp1 = 0 ;
34969 int res1 = 0 ;
34970 int val2 ;
34971 int ecode2 = 0 ;
34972 PyObject *swig_obj[2] ;
34973
34974 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
34975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34976 if (!SWIG_IsOK(res1)) {
34977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34978 }
34979 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34980 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34981 if (!SWIG_IsOK(ecode2)) {
34982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
34983 }
34984 arg2 = static_cast< int >(val2);
34985 if (arg1) (arg1)->refresh = arg2;
34986
34987 resultobj = SWIG_Py_Void();
34988 return resultobj;
34989 fail:
34990 return NULL;
34991 }
34992
34993
34994 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34995 PyObject *resultobj = 0;
34996 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34997 int result;
34998 void *argp1 = 0 ;
34999 int res1 = 0 ;
35000 PyObject *swig_obj[1] ;
35001
35002 if (!args) SWIG_fail;
35003 swig_obj[0] = args;
35004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35005 if (!SWIG_IsOK(res1)) {
35006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35007 }
35008 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35009 result = (int) ((arg1)->refresh);
35010 resultobj = SWIG_From_int(static_cast< int >(result));
35011 return resultobj;
35012 fail:
35013 return NULL;
35014 }
35015
35016
35017 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35018 PyObject *obj;
35019 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35020 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
35021 return SWIG_Py_Void();
35022 }
35023
35024 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35025 return SWIG_Python_InitShadowInstance(args);
35026 }
35027
35028 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
35029 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
35030 return 1;
35031 }
35032
35033
35034 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
35035 PyObject *pyobj = 0;
35036
35037 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
35038 return pyobj;
35039 }
35040
35041
35042 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35043 PyObject *resultobj = 0;
35044 size_t arg1 = (size_t) 0 ;
35045 wxDisplay *result = 0 ;
35046 size_t val1 ;
35047 int ecode1 = 0 ;
35048 PyObject * obj0 = 0 ;
35049 char * kwnames[] = {
35050 (char *) "index", NULL
35051 };
35052
35053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
35054 if (obj0) {
35055 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
35056 if (!SWIG_IsOK(ecode1)) {
35057 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
35058 }
35059 arg1 = static_cast< size_t >(val1);
35060 }
35061 {
35062 PyThreadState* __tstate = wxPyBeginAllowThreads();
35063 result = (wxDisplay *)new wxDisplay(arg1);
35064 wxPyEndAllowThreads(__tstate);
35065 if (PyErr_Occurred()) SWIG_fail;
35066 }
35067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
35068 return resultobj;
35069 fail:
35070 return NULL;
35071 }
35072
35073
35074 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35075 PyObject *resultobj = 0;
35076 wxDisplay *arg1 = (wxDisplay *) 0 ;
35077 void *argp1 = 0 ;
35078 int res1 = 0 ;
35079 PyObject *swig_obj[1] ;
35080
35081 if (!args) SWIG_fail;
35082 swig_obj[0] = args;
35083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
35084 if (!SWIG_IsOK(res1)) {
35085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
35086 }
35087 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35088 {
35089 PyThreadState* __tstate = wxPyBeginAllowThreads();
35090 delete arg1;
35091
35092 wxPyEndAllowThreads(__tstate);
35093 if (PyErr_Occurred()) SWIG_fail;
35094 }
35095 resultobj = SWIG_Py_Void();
35096 return resultobj;
35097 fail:
35098 return NULL;
35099 }
35100
35101
35102 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35103 PyObject *resultobj = 0;
35104 size_t result;
35105
35106 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
35107 {
35108 PyThreadState* __tstate = wxPyBeginAllowThreads();
35109 result = (size_t)wxDisplay::GetCount();
35110 wxPyEndAllowThreads(__tstate);
35111 if (PyErr_Occurred()) SWIG_fail;
35112 }
35113 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
35114 return resultobj;
35115 fail:
35116 return NULL;
35117 }
35118
35119
35120 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35121 PyObject *resultobj = 0;
35122 wxPoint *arg1 = 0 ;
35123 int result;
35124 wxPoint temp1 ;
35125 PyObject * obj0 = 0 ;
35126 char * kwnames[] = {
35127 (char *) "pt", NULL
35128 };
35129
35130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
35131 {
35132 arg1 = &temp1;
35133 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
35134 }
35135 {
35136 PyThreadState* __tstate = wxPyBeginAllowThreads();
35137 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
35138 wxPyEndAllowThreads(__tstate);
35139 if (PyErr_Occurred()) SWIG_fail;
35140 }
35141 resultobj = SWIG_From_int(static_cast< int >(result));
35142 return resultobj;
35143 fail:
35144 return NULL;
35145 }
35146
35147
35148 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35149 PyObject *resultobj = 0;
35150 wxWindow *arg1 = (wxWindow *) 0 ;
35151 int result;
35152 void *argp1 = 0 ;
35153 int res1 = 0 ;
35154 PyObject * obj0 = 0 ;
35155 char * kwnames[] = {
35156 (char *) "window", NULL
35157 };
35158
35159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
35160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35161 if (!SWIG_IsOK(res1)) {
35162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
35163 }
35164 arg1 = reinterpret_cast< wxWindow * >(argp1);
35165 {
35166 PyThreadState* __tstate = wxPyBeginAllowThreads();
35167 result = (int)wxDisplay::GetFromWindow(arg1);
35168 wxPyEndAllowThreads(__tstate);
35169 if (PyErr_Occurred()) SWIG_fail;
35170 }
35171 resultobj = SWIG_From_int(static_cast< int >(result));
35172 return resultobj;
35173 fail:
35174 return NULL;
35175 }
35176
35177
35178 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35179 PyObject *resultobj = 0;
35180 wxDisplay *arg1 = (wxDisplay *) 0 ;
35181 bool result;
35182 void *argp1 = 0 ;
35183 int res1 = 0 ;
35184 PyObject *swig_obj[1] ;
35185
35186 if (!args) SWIG_fail;
35187 swig_obj[0] = args;
35188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35189 if (!SWIG_IsOK(res1)) {
35190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35191 }
35192 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35193 {
35194 PyThreadState* __tstate = wxPyBeginAllowThreads();
35195 result = (bool)((wxDisplay const *)arg1)->IsOk();
35196 wxPyEndAllowThreads(__tstate);
35197 if (PyErr_Occurred()) SWIG_fail;
35198 }
35199 {
35200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35201 }
35202 return resultobj;
35203 fail:
35204 return NULL;
35205 }
35206
35207
35208 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35209 PyObject *resultobj = 0;
35210 wxDisplay *arg1 = (wxDisplay *) 0 ;
35211 wxRect result;
35212 void *argp1 = 0 ;
35213 int res1 = 0 ;
35214 PyObject *swig_obj[1] ;
35215
35216 if (!args) SWIG_fail;
35217 swig_obj[0] = args;
35218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35219 if (!SWIG_IsOK(res1)) {
35220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35221 }
35222 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35223 {
35224 PyThreadState* __tstate = wxPyBeginAllowThreads();
35225 result = ((wxDisplay const *)arg1)->GetGeometry();
35226 wxPyEndAllowThreads(__tstate);
35227 if (PyErr_Occurred()) SWIG_fail;
35228 }
35229 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35230 return resultobj;
35231 fail:
35232 return NULL;
35233 }
35234
35235
35236 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35237 PyObject *resultobj = 0;
35238 wxDisplay *arg1 = (wxDisplay *) 0 ;
35239 wxRect result;
35240 void *argp1 = 0 ;
35241 int res1 = 0 ;
35242 PyObject *swig_obj[1] ;
35243
35244 if (!args) SWIG_fail;
35245 swig_obj[0] = args;
35246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35247 if (!SWIG_IsOK(res1)) {
35248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35249 }
35250 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35251 {
35252 PyThreadState* __tstate = wxPyBeginAllowThreads();
35253 result = ((wxDisplay const *)arg1)->GetClientArea();
35254 wxPyEndAllowThreads(__tstate);
35255 if (PyErr_Occurred()) SWIG_fail;
35256 }
35257 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35258 return resultobj;
35259 fail:
35260 return NULL;
35261 }
35262
35263
35264 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35265 PyObject *resultobj = 0;
35266 wxDisplay *arg1 = (wxDisplay *) 0 ;
35267 wxString result;
35268 void *argp1 = 0 ;
35269 int res1 = 0 ;
35270 PyObject *swig_obj[1] ;
35271
35272 if (!args) SWIG_fail;
35273 swig_obj[0] = args;
35274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35275 if (!SWIG_IsOK(res1)) {
35276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35277 }
35278 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35279 {
35280 PyThreadState* __tstate = wxPyBeginAllowThreads();
35281 result = ((wxDisplay const *)arg1)->GetName();
35282 wxPyEndAllowThreads(__tstate);
35283 if (PyErr_Occurred()) SWIG_fail;
35284 }
35285 {
35286 #if wxUSE_UNICODE
35287 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35288 #else
35289 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35290 #endif
35291 }
35292 return resultobj;
35293 fail:
35294 return NULL;
35295 }
35296
35297
35298 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35299 PyObject *resultobj = 0;
35300 wxDisplay *arg1 = (wxDisplay *) 0 ;
35301 bool result;
35302 void *argp1 = 0 ;
35303 int res1 = 0 ;
35304 PyObject *swig_obj[1] ;
35305
35306 if (!args) SWIG_fail;
35307 swig_obj[0] = args;
35308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35309 if (!SWIG_IsOK(res1)) {
35310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35311 }
35312 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35313 {
35314 PyThreadState* __tstate = wxPyBeginAllowThreads();
35315 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
35316 wxPyEndAllowThreads(__tstate);
35317 if (PyErr_Occurred()) SWIG_fail;
35318 }
35319 {
35320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35321 }
35322 return resultobj;
35323 fail:
35324 return NULL;
35325 }
35326
35327
35328 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35329 PyObject *resultobj = 0;
35330 wxDisplay *arg1 = (wxDisplay *) 0 ;
35331 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35332 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35333 PyObject *result = 0 ;
35334 void *argp1 = 0 ;
35335 int res1 = 0 ;
35336 void *argp2 = 0 ;
35337 int res2 = 0 ;
35338 PyObject * obj0 = 0 ;
35339 PyObject * obj1 = 0 ;
35340 char * kwnames[] = {
35341 (char *) "self",(char *) "mode", NULL
35342 };
35343
35344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
35345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35346 if (!SWIG_IsOK(res1)) {
35347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
35348 }
35349 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35350 if (obj1) {
35351 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35352 if (!SWIG_IsOK(res2)) {
35353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35354 }
35355 if (!argp2) {
35356 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35357 }
35358 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35359 }
35360 {
35361 PyThreadState* __tstate = wxPyBeginAllowThreads();
35362 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
35363 wxPyEndAllowThreads(__tstate);
35364 if (PyErr_Occurred()) SWIG_fail;
35365 }
35366 resultobj = result;
35367 return resultobj;
35368 fail:
35369 return NULL;
35370 }
35371
35372
35373 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35374 PyObject *resultobj = 0;
35375 wxDisplay *arg1 = (wxDisplay *) 0 ;
35376 wxVideoMode result;
35377 void *argp1 = 0 ;
35378 int res1 = 0 ;
35379 PyObject *swig_obj[1] ;
35380
35381 if (!args) SWIG_fail;
35382 swig_obj[0] = args;
35383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35384 if (!SWIG_IsOK(res1)) {
35385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35386 }
35387 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35388 {
35389 PyThreadState* __tstate = wxPyBeginAllowThreads();
35390 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
35391 wxPyEndAllowThreads(__tstate);
35392 if (PyErr_Occurred()) SWIG_fail;
35393 }
35394 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
35395 return resultobj;
35396 fail:
35397 return NULL;
35398 }
35399
35400
35401 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35402 PyObject *resultobj = 0;
35403 wxDisplay *arg1 = (wxDisplay *) 0 ;
35404 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35405 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35406 bool result;
35407 void *argp1 = 0 ;
35408 int res1 = 0 ;
35409 void *argp2 = 0 ;
35410 int res2 = 0 ;
35411 PyObject * obj0 = 0 ;
35412 PyObject * obj1 = 0 ;
35413 char * kwnames[] = {
35414 (char *) "self",(char *) "mode", NULL
35415 };
35416
35417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
35418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35419 if (!SWIG_IsOK(res1)) {
35420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35421 }
35422 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35423 if (obj1) {
35424 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35425 if (!SWIG_IsOK(res2)) {
35426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35427 }
35428 if (!argp2) {
35429 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35430 }
35431 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35432 }
35433 {
35434 PyThreadState* __tstate = wxPyBeginAllowThreads();
35435 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
35436 wxPyEndAllowThreads(__tstate);
35437 if (PyErr_Occurred()) SWIG_fail;
35438 }
35439 {
35440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35441 }
35442 return resultobj;
35443 fail:
35444 return NULL;
35445 }
35446
35447
35448 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35449 PyObject *resultobj = 0;
35450 wxDisplay *arg1 = (wxDisplay *) 0 ;
35451 void *argp1 = 0 ;
35452 int res1 = 0 ;
35453 PyObject *swig_obj[1] ;
35454
35455 if (!args) SWIG_fail;
35456 swig_obj[0] = args;
35457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35458 if (!SWIG_IsOK(res1)) {
35459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35460 }
35461 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35462 {
35463 PyThreadState* __tstate = wxPyBeginAllowThreads();
35464 wxDisplay_ResetMode(arg1);
35465 wxPyEndAllowThreads(__tstate);
35466 if (PyErr_Occurred()) SWIG_fail;
35467 }
35468 resultobj = SWIG_Py_Void();
35469 return resultobj;
35470 fail:
35471 return NULL;
35472 }
35473
35474
35475 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35476 PyObject *obj;
35477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35478 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
35479 return SWIG_Py_Void();
35480 }
35481
35482 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35483 return SWIG_Python_InitShadowInstance(args);
35484 }
35485
35486 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35487 PyObject *resultobj = 0;
35488 wxStandardPaths *result = 0 ;
35489
35490 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
35491 {
35492 PyThreadState* __tstate = wxPyBeginAllowThreads();
35493 result = (wxStandardPaths *)wxStandardPaths_Get();
35494 wxPyEndAllowThreads(__tstate);
35495 if (PyErr_Occurred()) SWIG_fail;
35496 }
35497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35498 return resultobj;
35499 fail:
35500 return NULL;
35501 }
35502
35503
35504 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35505 PyObject *resultobj = 0;
35506 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35507 wxString result;
35508 void *argp1 = 0 ;
35509 int res1 = 0 ;
35510 PyObject *swig_obj[1] ;
35511
35512 if (!args) SWIG_fail;
35513 swig_obj[0] = args;
35514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35515 if (!SWIG_IsOK(res1)) {
35516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35517 }
35518 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35519 {
35520 PyThreadState* __tstate = wxPyBeginAllowThreads();
35521 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
35522 wxPyEndAllowThreads(__tstate);
35523 if (PyErr_Occurred()) SWIG_fail;
35524 }
35525 {
35526 #if wxUSE_UNICODE
35527 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35528 #else
35529 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35530 #endif
35531 }
35532 return resultobj;
35533 fail:
35534 return NULL;
35535 }
35536
35537
35538 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35539 PyObject *resultobj = 0;
35540 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35541 wxString result;
35542 void *argp1 = 0 ;
35543 int res1 = 0 ;
35544 PyObject *swig_obj[1] ;
35545
35546 if (!args) SWIG_fail;
35547 swig_obj[0] = args;
35548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35549 if (!SWIG_IsOK(res1)) {
35550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35551 }
35552 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35553 {
35554 PyThreadState* __tstate = wxPyBeginAllowThreads();
35555 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
35556 wxPyEndAllowThreads(__tstate);
35557 if (PyErr_Occurred()) SWIG_fail;
35558 }
35559 {
35560 #if wxUSE_UNICODE
35561 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35562 #else
35563 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35564 #endif
35565 }
35566 return resultobj;
35567 fail:
35568 return NULL;
35569 }
35570
35571
35572 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35573 PyObject *resultobj = 0;
35574 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35575 wxString result;
35576 void *argp1 = 0 ;
35577 int res1 = 0 ;
35578 PyObject *swig_obj[1] ;
35579
35580 if (!args) SWIG_fail;
35581 swig_obj[0] = args;
35582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35583 if (!SWIG_IsOK(res1)) {
35584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35585 }
35586 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35587 {
35588 PyThreadState* __tstate = wxPyBeginAllowThreads();
35589 result = ((wxStandardPaths const *)arg1)->GetDataDir();
35590 wxPyEndAllowThreads(__tstate);
35591 if (PyErr_Occurred()) SWIG_fail;
35592 }
35593 {
35594 #if wxUSE_UNICODE
35595 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35596 #else
35597 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35598 #endif
35599 }
35600 return resultobj;
35601 fail:
35602 return NULL;
35603 }
35604
35605
35606 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35607 PyObject *resultobj = 0;
35608 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35609 wxString result;
35610 void *argp1 = 0 ;
35611 int res1 = 0 ;
35612 PyObject *swig_obj[1] ;
35613
35614 if (!args) SWIG_fail;
35615 swig_obj[0] = args;
35616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35617 if (!SWIG_IsOK(res1)) {
35618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35619 }
35620 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35621 {
35622 PyThreadState* __tstate = wxPyBeginAllowThreads();
35623 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
35624 wxPyEndAllowThreads(__tstate);
35625 if (PyErr_Occurred()) SWIG_fail;
35626 }
35627 {
35628 #if wxUSE_UNICODE
35629 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35630 #else
35631 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35632 #endif
35633 }
35634 return resultobj;
35635 fail:
35636 return NULL;
35637 }
35638
35639
35640 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35641 PyObject *resultobj = 0;
35642 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35643 wxString result;
35644 void *argp1 = 0 ;
35645 int res1 = 0 ;
35646 PyObject *swig_obj[1] ;
35647
35648 if (!args) SWIG_fail;
35649 swig_obj[0] = args;
35650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35651 if (!SWIG_IsOK(res1)) {
35652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35653 }
35654 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35655 {
35656 PyThreadState* __tstate = wxPyBeginAllowThreads();
35657 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
35658 wxPyEndAllowThreads(__tstate);
35659 if (PyErr_Occurred()) SWIG_fail;
35660 }
35661 {
35662 #if wxUSE_UNICODE
35663 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35664 #else
35665 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35666 #endif
35667 }
35668 return resultobj;
35669 fail:
35670 return NULL;
35671 }
35672
35673
35674 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35675 PyObject *resultobj = 0;
35676 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35677 wxString result;
35678 void *argp1 = 0 ;
35679 int res1 = 0 ;
35680 PyObject *swig_obj[1] ;
35681
35682 if (!args) SWIG_fail;
35683 swig_obj[0] = args;
35684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35685 if (!SWIG_IsOK(res1)) {
35686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35687 }
35688 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35689 {
35690 PyThreadState* __tstate = wxPyBeginAllowThreads();
35691 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
35692 wxPyEndAllowThreads(__tstate);
35693 if (PyErr_Occurred()) SWIG_fail;
35694 }
35695 {
35696 #if wxUSE_UNICODE
35697 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35698 #else
35699 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35700 #endif
35701 }
35702 return resultobj;
35703 fail:
35704 return NULL;
35705 }
35706
35707
35708 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35709 PyObject *resultobj = 0;
35710 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35711 wxString result;
35712 void *argp1 = 0 ;
35713 int res1 = 0 ;
35714 PyObject *swig_obj[1] ;
35715
35716 if (!args) SWIG_fail;
35717 swig_obj[0] = args;
35718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35719 if (!SWIG_IsOK(res1)) {
35720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35721 }
35722 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35723 {
35724 PyThreadState* __tstate = wxPyBeginAllowThreads();
35725 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
35726 wxPyEndAllowThreads(__tstate);
35727 if (PyErr_Occurred()) SWIG_fail;
35728 }
35729 {
35730 #if wxUSE_UNICODE
35731 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35732 #else
35733 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35734 #endif
35735 }
35736 return resultobj;
35737 fail:
35738 return NULL;
35739 }
35740
35741
35742 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35743 PyObject *resultobj = 0;
35744 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35745 wxString result;
35746 void *argp1 = 0 ;
35747 int res1 = 0 ;
35748 PyObject *swig_obj[1] ;
35749
35750 if (!args) SWIG_fail;
35751 swig_obj[0] = args;
35752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35753 if (!SWIG_IsOK(res1)) {
35754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35755 }
35756 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35757 {
35758 PyThreadState* __tstate = wxPyBeginAllowThreads();
35759 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
35760 wxPyEndAllowThreads(__tstate);
35761 if (PyErr_Occurred()) SWIG_fail;
35762 }
35763 {
35764 #if wxUSE_UNICODE
35765 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35766 #else
35767 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35768 #endif
35769 }
35770 return resultobj;
35771 fail:
35772 return NULL;
35773 }
35774
35775
35776 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35777 PyObject *resultobj = 0;
35778 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35779 wxString *arg2 = 0 ;
35780 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
35781 wxString result;
35782 void *argp1 = 0 ;
35783 int res1 = 0 ;
35784 bool temp2 = false ;
35785 int val3 ;
35786 int ecode3 = 0 ;
35787 PyObject * obj0 = 0 ;
35788 PyObject * obj1 = 0 ;
35789 PyObject * obj2 = 0 ;
35790 char * kwnames[] = {
35791 (char *) "self",(char *) "lang",(char *) "category", NULL
35792 };
35793
35794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35796 if (!SWIG_IsOK(res1)) {
35797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35798 }
35799 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35800 {
35801 arg2 = wxString_in_helper(obj1);
35802 if (arg2 == NULL) SWIG_fail;
35803 temp2 = true;
35804 }
35805 if (obj2) {
35806 ecode3 = SWIG_AsVal_int(obj2, &val3);
35807 if (!SWIG_IsOK(ecode3)) {
35808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
35809 }
35810 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
35811 }
35812 {
35813 PyThreadState* __tstate = wxPyBeginAllowThreads();
35814 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
35815 wxPyEndAllowThreads(__tstate);
35816 if (PyErr_Occurred()) SWIG_fail;
35817 }
35818 {
35819 #if wxUSE_UNICODE
35820 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35821 #else
35822 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35823 #endif
35824 }
35825 {
35826 if (temp2)
35827 delete arg2;
35828 }
35829 return resultobj;
35830 fail:
35831 {
35832 if (temp2)
35833 delete arg2;
35834 }
35835 return NULL;
35836 }
35837
35838
35839 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35840 PyObject *resultobj = 0;
35841 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35842 wxString result;
35843 void *argp1 = 0 ;
35844 int res1 = 0 ;
35845 PyObject *swig_obj[1] ;
35846
35847 if (!args) SWIG_fail;
35848 swig_obj[0] = args;
35849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35850 if (!SWIG_IsOK(res1)) {
35851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35852 }
35853 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35854 {
35855 PyThreadState* __tstate = wxPyBeginAllowThreads();
35856 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
35857 wxPyEndAllowThreads(__tstate);
35858 if (PyErr_Occurred()) SWIG_fail;
35859 }
35860 {
35861 #if wxUSE_UNICODE
35862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35863 #else
35864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35865 #endif
35866 }
35867 return resultobj;
35868 fail:
35869 return NULL;
35870 }
35871
35872
35873 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35874 PyObject *resultobj = 0;
35875 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35876 wxString *arg2 = 0 ;
35877 void *argp1 = 0 ;
35878 int res1 = 0 ;
35879 bool temp2 = false ;
35880 PyObject * obj0 = 0 ;
35881 PyObject * obj1 = 0 ;
35882 char * kwnames[] = {
35883 (char *) "self",(char *) "prefix", NULL
35884 };
35885
35886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
35887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35888 if (!SWIG_IsOK(res1)) {
35889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
35890 }
35891 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35892 {
35893 arg2 = wxString_in_helper(obj1);
35894 if (arg2 == NULL) SWIG_fail;
35895 temp2 = true;
35896 }
35897 {
35898 PyThreadState* __tstate = wxPyBeginAllowThreads();
35899 (arg1)->SetInstallPrefix((wxString const &)*arg2);
35900 wxPyEndAllowThreads(__tstate);
35901 if (PyErr_Occurred()) SWIG_fail;
35902 }
35903 resultobj = SWIG_Py_Void();
35904 {
35905 if (temp2)
35906 delete arg2;
35907 }
35908 return resultobj;
35909 fail:
35910 {
35911 if (temp2)
35912 delete arg2;
35913 }
35914 return NULL;
35915 }
35916
35917
35918 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35919 PyObject *resultobj = 0;
35920 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35921 wxString result;
35922 void *argp1 = 0 ;
35923 int res1 = 0 ;
35924 PyObject *swig_obj[1] ;
35925
35926 if (!args) SWIG_fail;
35927 swig_obj[0] = args;
35928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35929 if (!SWIG_IsOK(res1)) {
35930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35931 }
35932 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35933 {
35934 PyThreadState* __tstate = wxPyBeginAllowThreads();
35935 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
35936 wxPyEndAllowThreads(__tstate);
35937 if (PyErr_Occurred()) SWIG_fail;
35938 }
35939 {
35940 #if wxUSE_UNICODE
35941 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35942 #else
35943 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35944 #endif
35945 }
35946 return resultobj;
35947 fail:
35948 return NULL;
35949 }
35950
35951
35952 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35953 PyObject *obj;
35954 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35955 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
35956 return SWIG_Py_Void();
35957 }
35958
35959 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35960 PyObject *resultobj = 0;
35961 wxEventType arg1 ;
35962 wxPowerEvent *result = 0 ;
35963 int val1 ;
35964 int ecode1 = 0 ;
35965 PyObject * obj0 = 0 ;
35966 char * kwnames[] = {
35967 (char *) "evtType", NULL
35968 };
35969
35970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
35971 ecode1 = SWIG_AsVal_int(obj0, &val1);
35972 if (!SWIG_IsOK(ecode1)) {
35973 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
35974 }
35975 arg1 = static_cast< wxEventType >(val1);
35976 {
35977 PyThreadState* __tstate = wxPyBeginAllowThreads();
35978 result = (wxPowerEvent *)new wxPowerEvent(arg1);
35979 wxPyEndAllowThreads(__tstate);
35980 if (PyErr_Occurred()) SWIG_fail;
35981 }
35982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
35983 return resultobj;
35984 fail:
35985 return NULL;
35986 }
35987
35988
35989 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35990 PyObject *resultobj = 0;
35991 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
35992 void *argp1 = 0 ;
35993 int res1 = 0 ;
35994 PyObject *swig_obj[1] ;
35995
35996 if (!args) SWIG_fail;
35997 swig_obj[0] = args;
35998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
35999 if (!SWIG_IsOK(res1)) {
36000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
36001 }
36002 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36003 {
36004 PyThreadState* __tstate = wxPyBeginAllowThreads();
36005 (arg1)->Veto();
36006 wxPyEndAllowThreads(__tstate);
36007 if (PyErr_Occurred()) SWIG_fail;
36008 }
36009 resultobj = SWIG_Py_Void();
36010 return resultobj;
36011 fail:
36012 return NULL;
36013 }
36014
36015
36016 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36017 PyObject *resultobj = 0;
36018 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36019 bool result;
36020 void *argp1 = 0 ;
36021 int res1 = 0 ;
36022 PyObject *swig_obj[1] ;
36023
36024 if (!args) SWIG_fail;
36025 swig_obj[0] = args;
36026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36027 if (!SWIG_IsOK(res1)) {
36028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
36029 }
36030 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36031 {
36032 PyThreadState* __tstate = wxPyBeginAllowThreads();
36033 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
36034 wxPyEndAllowThreads(__tstate);
36035 if (PyErr_Occurred()) SWIG_fail;
36036 }
36037 {
36038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36039 }
36040 return resultobj;
36041 fail:
36042 return NULL;
36043 }
36044
36045
36046 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36047 PyObject *obj;
36048 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36049 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
36050 return SWIG_Py_Void();
36051 }
36052
36053 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36054 return SWIG_Python_InitShadowInstance(args);
36055 }
36056
36057 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36058 PyObject *resultobj = 0;
36059 wxPowerType result;
36060
36061 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
36062 {
36063 PyThreadState* __tstate = wxPyBeginAllowThreads();
36064 result = (wxPowerType)wxGetPowerType();
36065 wxPyEndAllowThreads(__tstate);
36066 if (PyErr_Occurred()) SWIG_fail;
36067 }
36068 resultobj = SWIG_From_int(static_cast< int >(result));
36069 return resultobj;
36070 fail:
36071 return NULL;
36072 }
36073
36074
36075 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36076 PyObject *resultobj = 0;
36077 wxBatteryState result;
36078
36079 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
36080 {
36081 PyThreadState* __tstate = wxPyBeginAllowThreads();
36082 result = (wxBatteryState)wxGetBatteryState();
36083 wxPyEndAllowThreads(__tstate);
36084 if (PyErr_Occurred()) SWIG_fail;
36085 }
36086 resultobj = SWIG_From_int(static_cast< int >(result));
36087 return resultobj;
36088 fail:
36089 return NULL;
36090 }
36091
36092
36093 static PyMethodDef SwigMethods[] = {
36094 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
36095 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
36096 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
36097 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
36098 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
36099 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
36100 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
36101 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
36102 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36103 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36104 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36105 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36106 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
36107 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
36108 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
36109 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
36110 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
36111 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
36112 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
36113 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
36114 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36115 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36116 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
36117 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
36118 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
36119 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
36120 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
36121 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
36122 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
36123 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
36124 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
36125 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
36126 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
36127 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
36128 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36129 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36130 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
36131 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
36132 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
36133 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
36134 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
36135 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
36136 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
36137 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
36138 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
36139 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
36140 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
36141 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36142 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36143 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36144 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36145 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36146 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36147 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
36148 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
36149 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
36150 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
36151 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
36152 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
36153 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
36154 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
36155 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
36156 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
36157 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
36158 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
36159 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36160 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
36161 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36162 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
36163 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
36164 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
36165 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36166 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36167 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
36168 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
36169 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
36170 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
36171 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
36172 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
36173 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
36174 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
36175 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
36176 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
36177 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
36178 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
36179 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
36180 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
36181 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
36182 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
36183 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
36184 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36185 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
36186 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
36187 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
36188 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36189 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
36190 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
36191 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
36192 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
36193 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
36194 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
36195 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
36196 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
36197 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
36198 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
36199 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
36200 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
36201 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
36202 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
36203 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
36204 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
36205 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
36206 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
36207 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
36208 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
36209 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
36210 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
36211 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
36212 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
36213 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
36214 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
36215 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
36216 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
36217 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
36218 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
36219 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
36220 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
36221 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
36222 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
36223 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
36224 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
36225 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36226 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
36227 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
36228 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
36229 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
36230 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
36231 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36232 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
36233 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
36234 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
36235 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
36236 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
36237 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
36238 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
36239 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36240 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
36241 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
36242 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
36243 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
36244 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36245 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
36246 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
36247 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
36248 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
36249 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
36250 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36251 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
36252 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36253 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36254 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
36255 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36256 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36257 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
36258 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
36259 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
36260 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36261 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
36262 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
36263 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
36264 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
36265 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
36266 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
36267 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
36268 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36269 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
36270 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
36271 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
36272 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
36273 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
36274 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
36275 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
36276 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
36277 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
36278 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36279 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36280 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
36281 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
36282 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
36283 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36284 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
36285 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
36286 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36287 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
36288 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
36289 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36290 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
36291 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
36292 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
36293 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
36294 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
36295 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
36296 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
36297 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
36298 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36299 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
36300 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
36301 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
36302 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
36303 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
36304 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36305 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
36306 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
36307 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
36308 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
36309 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
36310 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
36311 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
36312 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
36313 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
36314 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
36315 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36316 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
36317 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
36318 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36319 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
36320 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
36321 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36322 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36323 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36324 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
36325 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
36326 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
36327 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
36328 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
36329 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36330 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
36331 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
36332 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
36333 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
36334 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
36335 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
36336 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
36337 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
36338 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
36339 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
36340 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
36341 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
36342 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
36343 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
36344 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
36345 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36346 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36347 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
36348 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
36349 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
36350 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36351 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
36352 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
36353 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
36354 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
36355 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36356 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
36357 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
36358 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
36359 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
36360 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
36361 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
36362 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
36363 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
36364 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
36365 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
36366 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
36367 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
36368 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
36369 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36370 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36371 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
36372 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36373 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
36374 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
36375 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
36376 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
36377 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
36378 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36379 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
36380 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
36381 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
36382 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
36383 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
36384 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36385 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
36386 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
36387 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36388 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36389 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
36390 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
36391 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36392 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
36393 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
36394 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
36395 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
36396 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
36397 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
36398 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
36399 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
36400 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
36401 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
36402 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
36403 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
36404 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
36405 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36406 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
36407 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
36408 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
36409 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
36410 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
36411 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
36412 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
36413 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
36414 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
36415 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36416 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
36417 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
36418 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
36419 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
36420 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
36421 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
36422 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
36423 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
36424 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
36425 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
36426 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
36427 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
36428 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
36429 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
36430 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
36431 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
36432 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
36433 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
36434 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
36435 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
36436 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
36437 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
36438 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
36439 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
36440 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
36441 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
36442 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
36443 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
36444 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
36445 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
36446 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
36447 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
36448 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
36449 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
36450 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
36451 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
36452 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
36453 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
36454 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
36455 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
36456 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
36457 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
36458 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
36459 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
36460 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
36461 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
36462 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36463 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
36464 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
36465 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
36466 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
36467 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
36468 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
36469 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
36470 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
36471 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36472 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36473 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
36474 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
36475 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
36476 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
36477 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
36478 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
36479 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
36480 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
36481 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
36482 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36483 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
36484 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36485 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36486 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
36487 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
36488 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
36489 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
36490 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
36491 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
36492 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36493 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
36494 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
36495 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
36496 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36497 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
36498 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
36499 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
36500 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
36501 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
36502 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
36503 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
36504 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
36505 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
36506 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
36507 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
36508 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
36509 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
36510 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
36511 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
36512 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
36513 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
36514 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
36515 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
36516 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
36517 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36518 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36519 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
36520 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36521 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36522 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
36523 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36524 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
36525 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
36526 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
36527 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
36528 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
36529 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
36530 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
36531 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
36532 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
36533 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
36534 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
36535 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
36536 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
36537 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
36538 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
36539 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
36540 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
36541 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
36542 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
36543 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36544 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36545 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
36546 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36547 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36548 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36549 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
36550 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
36551 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
36552 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
36553 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
36554 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36555 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
36556 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
36557 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
36558 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
36559 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
36560 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
36561 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36562 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
36563 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36564 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
36565 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
36566 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36567 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36568 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36569 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
36570 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
36571 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
36572 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36573 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
36574 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
36575 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
36576 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36577 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
36578 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
36579 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36580 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36581 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36582 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36583 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
36584 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36585 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
36586 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
36587 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
36588 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36589 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
36590 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
36591 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
36592 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
36593 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
36594 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
36595 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
36596 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
36597 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
36598 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
36599 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
36600 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
36601 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
36602 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
36603 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
36604 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
36605 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
36606 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
36607 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
36608 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
36609 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36610 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36611 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
36612 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36613 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
36614 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
36615 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36616 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
36617 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
36618 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
36619 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36620 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
36621 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
36622 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
36623 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
36624 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
36625 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
36626 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
36627 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
36628 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
36629 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
36630 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36631 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36632 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36633 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
36634 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36635 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
36636 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
36637 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36638 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36639 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36640 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36641 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
36642 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36643 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36644 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36645 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36646 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36647 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36648 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36649 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36650 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36651 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36652 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36653 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36654 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36655 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36656 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36657 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36658 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36659 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36660 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36661 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36662 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36663 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36664 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36665 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
36666 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
36667 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
36668 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
36669 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
36670 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36671 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36672 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36673 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36674 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36675 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36676 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36677 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36678 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36679 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36680 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
36681 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
36682 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
36683 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36684 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36685 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36686 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36687 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36688 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36689 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36690 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36691 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36692 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36693 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36694 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
36695 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36696 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
36697 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36698 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36699 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36700 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
36701 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
36702 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
36703 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
36704 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
36705 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
36706 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
36707 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36708 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
36709 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
36710 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
36711 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
36712 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36713 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36714 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36715 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36716 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36717 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36718 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
36719 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36720 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36721 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
36722 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
36723 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36724 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
36725 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
36726 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
36727 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
36728 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
36729 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
36730 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
36731 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
36732 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
36733 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
36734 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
36735 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
36736 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
36737 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
36738 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36739 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
36740 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36741 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
36742 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36743 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
36744 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36745 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36746 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36747 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
36748 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
36749 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36750 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36751 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36752 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
36753 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36754 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36755 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36756 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36757 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36758 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36759 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36760 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36761 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36762 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36763 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
36764 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
36765 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
36766 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36767 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
36768 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36769 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
36770 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
36771 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
36772 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
36773 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
36774 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
36775 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36776 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
36777 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
36778 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36779 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
36780 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36781 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
36782 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36783 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
36784 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
36785 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
36786 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
36787 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
36788 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
36789 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
36790 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
36791 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
36792 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
36793 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
36794 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
36795 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
36796 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
36797 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36798 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36799 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
36800 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36801 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36802 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36803 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
36804 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36805 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36806 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36807 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36808 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36809 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36810 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36811 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
36812 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
36813 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
36814 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
36815 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
36816 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
36817 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36818 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36819 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
36820 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
36821 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
36822 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
36823 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
36824 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
36825 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
36826 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
36827 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
36828 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
36829 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36830 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
36831 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36832 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
36833 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
36834 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
36835 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36836 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
36837 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36838 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
36839 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36840 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
36841 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
36842 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36843 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
36844 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
36845 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36846 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36847 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
36848 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
36849 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
36850 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36851 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
36852 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
36853 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
36854 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36855 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
36856 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
36857 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
36858 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
36859 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
36860 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36861 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36862 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
36863 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
36864 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36865 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
36866 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36867 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
36868 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
36869 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36870 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36871 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
36872 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
36873 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
36874 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
36875 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
36876 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
36877 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
36878 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
36879 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36880 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
36881 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
36882 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
36883 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
36884 { (char *)"new_URLDataObject", (PyCFunction)_wrap_new_URLDataObject, METH_NOARGS, NULL},
36885 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
36886 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
36887 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
36888 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
36889 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
36890 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
36891 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
36892 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
36893 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
36894 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36895 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
36896 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36897 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
36898 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36899 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36900 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
36901 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
36902 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
36903 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36904 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36905 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
36906 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
36907 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36908 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36909 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36910 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
36911 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36912 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
36913 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
36914 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
36915 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
36916 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
36917 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
36918 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36919 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
36920 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36921 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36922 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
36923 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36924 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36925 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
36926 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
36927 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
36928 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36929 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
36930 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36931 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36932 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
36933 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36934 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36935 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
36936 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
36937 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
36938 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
36939 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
36940 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
36941 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
36942 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
36943 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36944 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36945 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
36946 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
36947 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
36948 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
36949 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
36950 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
36951 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
36952 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
36953 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
36954 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
36955 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
36956 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
36957 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
36958 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
36959 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
36960 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
36961 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
36962 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
36963 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
36964 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36965 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36966 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
36967 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
36968 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
36969 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
36970 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
36971 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
36972 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
36973 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
36974 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
36975 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
36976 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
36977 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
36978 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
36979 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36980 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36981 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
36982 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
36983 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
36984 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
36985 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
36986 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
36987 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
36988 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
36989 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
36990 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
36991 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
36992 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
36993 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
36994 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
36995 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
36996 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
36997 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
36998 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
36999 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
37000 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
37001 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
37002 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
37003 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
37004 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
37005 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
37006 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37007 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
37008 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
37009 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
37010 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
37011 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
37012 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
37013 { NULL, NULL, 0, NULL }
37014 };
37015
37016
37017 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
37018
37019 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
37020 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
37021 }
37022 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
37023 return (void *)((wxEvent *) ((wxMenuEvent *) x));
37024 }
37025 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
37026 return (void *)((wxEvent *) ((wxCloseEvent *) x));
37027 }
37028 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
37029 return (void *)((wxEvent *) ((wxMouseEvent *) x));
37030 }
37031 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
37032 return (void *)((wxEvent *) ((wxEraseEvent *) x));
37033 }
37034 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
37035 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
37036 }
37037 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
37038 return (void *)((wxEvent *) ((wxTimerEvent *) x));
37039 }
37040 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
37041 return (void *)((wxEvent *) ((wxPowerEvent *) x));
37042 }
37043 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
37044 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
37045 }
37046 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
37047 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
37048 }
37049 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
37050 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
37051 }
37052 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
37053 return (void *)((wxEvent *) ((wxPyEvent *) x));
37054 }
37055 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
37056 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
37057 }
37058 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
37059 return (void *)((wxEvent *) ((wxIdleEvent *) x));
37060 }
37061 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
37062 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
37063 }
37064 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
37065 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
37066 }
37067 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
37068 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
37069 }
37070 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
37071 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
37072 }
37073 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
37074 return (void *)((wxEvent *) ((wxActivateEvent *) x));
37075 }
37076 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
37077 return (void *)((wxEvent *) ((wxSizeEvent *) x));
37078 }
37079 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
37080 return (void *)((wxEvent *) ((wxMoveEvent *) x));
37081 }
37082 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
37083 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
37084 }
37085 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
37086 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
37087 }
37088 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
37089 return (void *)((wxEvent *) ((wxPaintEvent *) x));
37090 }
37091 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
37092 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
37093 }
37094 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
37095 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
37096 }
37097 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
37098 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
37099 }
37100 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
37101 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
37102 }
37103 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
37104 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37105 }
37106 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
37107 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
37108 }
37109 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
37110 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
37111 }
37112 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
37113 return (void *)((wxEvent *) ((wxFocusEvent *) x));
37114 }
37115 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
37116 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
37117 }
37118 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
37119 return (void *)((wxEvent *) ((wxProcessEvent *) x));
37120 }
37121 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
37122 return (void *)((wxEvent *) ((wxShowEvent *) x));
37123 }
37124 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
37125 return (void *)((wxEvent *) ((wxCommandEvent *) x));
37126 }
37127 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
37128 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
37129 }
37130 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
37131 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37132 }
37133 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
37134 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
37135 }
37136 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
37137 return (void *)((wxEvent *) ((wxKeyEvent *) x));
37138 }
37139 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
37140 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
37141 }
37142 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
37143 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
37144 }
37145 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
37146 return (void *)((wxConfigBase *) ((wxConfig *) x));
37147 }
37148 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
37149 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37150 }
37151 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
37152 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
37153 }
37154 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
37155 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
37156 }
37157 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
37158 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37159 }
37160 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
37161 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
37162 }
37163 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
37164 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
37165 }
37166 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
37167 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
37168 }
37169 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
37170 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37171 }
37172 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
37173 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37174 }
37175 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
37176 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
37177 }
37178 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
37179 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
37180 }
37181 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
37182 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
37183 }
37184 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
37185 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37186 }
37187 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
37188 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37189 }
37190 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37191 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
37192 }
37193 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37194 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
37195 }
37196 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37197 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37198 }
37199 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37200 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37201 }
37202 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
37203 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
37204 }
37205 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
37206 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
37207 }
37208 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
37209 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37210 }
37211 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
37212 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
37213 }
37214 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
37215 return (void *)((wxEvtHandler *) ((wxWindow *) x));
37216 }
37217 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
37218 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37219 }
37220 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
37221 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
37222 }
37223 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
37224 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
37225 }
37226 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
37227 return (void *)((wxEvtHandler *) ((wxValidator *) x));
37228 }
37229 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
37230 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
37231 }
37232 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
37233 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
37234 }
37235 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
37236 return (void *)((wxEvtHandler *) ((wxMenu *) x));
37237 }
37238 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
37239 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
37240 }
37241 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
37242 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
37243 }
37244 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
37245 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
37246 }
37247 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
37248 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
37249 }
37250 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
37251 return (void *)((wxObject *) ((wxSizerItem *) x));
37252 }
37253 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
37254 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
37255 }
37256 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
37257 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
37258 }
37259 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
37260 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
37261 }
37262 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
37263 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
37264 }
37265 static void *_p_wxSizerTo_p_wxObject(void *x) {
37266 return (void *)((wxObject *) ((wxSizer *) x));
37267 }
37268 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
37269 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
37270 }
37271 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
37272 return (void *)((wxObject *) ((wxFileHistory *) x));
37273 }
37274 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
37275 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
37276 }
37277 static void *_p_wxEventTo_p_wxObject(void *x) {
37278 return (void *)((wxObject *) ((wxEvent *) x));
37279 }
37280 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
37281 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
37282 }
37283 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
37284 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
37285 }
37286 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
37287 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
37288 }
37289 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
37290 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
37291 }
37292 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
37293 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
37294 }
37295 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
37296 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
37297 }
37298 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
37299 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
37300 }
37301 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
37302 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
37303 }
37304 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
37305 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37306 }
37307 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
37308 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
37309 }
37310 static void *_p_wxControlTo_p_wxObject(void *x) {
37311 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
37312 }
37313 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
37314 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
37315 }
37316 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
37317 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
37318 }
37319 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
37320 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
37321 }
37322 static void *_p_wxFSFileTo_p_wxObject(void *x) {
37323 return (void *)((wxObject *) ((wxFSFile *) x));
37324 }
37325 static void *_p_wxClipboardTo_p_wxObject(void *x) {
37326 return (void *)((wxObject *) ((wxClipboard *) x));
37327 }
37328 static void *_p_wxPySizerTo_p_wxObject(void *x) {
37329 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
37330 }
37331 static void *_p_wxPyEventTo_p_wxObject(void *x) {
37332 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
37333 }
37334 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
37335 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
37336 }
37337 static void *_p_wxShowEventTo_p_wxObject(void *x) {
37338 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
37339 }
37340 static void *_p_wxToolTipTo_p_wxObject(void *x) {
37341 return (void *)((wxObject *) ((wxToolTip *) x));
37342 }
37343 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
37344 return (void *)((wxObject *) ((wxMenuItem *) x));
37345 }
37346 static void *_p_wxDateEventTo_p_wxObject(void *x) {
37347 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
37348 }
37349 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
37350 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
37351 }
37352 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
37353 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
37354 }
37355 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
37356 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
37357 }
37358 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
37359 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
37360 }
37361 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
37362 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
37363 }
37364 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
37365 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
37366 }
37367 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
37368 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
37369 }
37370 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
37371 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
37372 }
37373 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
37374 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
37375 }
37376 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
37377 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
37378 }
37379 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
37380 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
37381 }
37382 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
37383 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
37384 }
37385 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
37386 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
37387 }
37388 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
37389 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
37390 }
37391 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
37392 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
37393 }
37394 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
37395 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
37396 }
37397 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
37398 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
37399 }
37400 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
37401 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
37402 }
37403 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
37404 return (void *)((wxObject *) ((wxImageHandler *) x));
37405 }
37406 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
37407 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
37408 }
37409 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
37410 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
37411 }
37412 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
37413 return (void *)((wxObject *) ((wxEvtHandler *) x));
37414 }
37415 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
37416 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
37417 }
37418 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
37419 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
37420 }
37421 static void *_p_wxImageTo_p_wxObject(void *x) {
37422 return (void *)((wxObject *) ((wxImage *) x));
37423 }
37424 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
37425 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
37426 }
37427 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
37428 return (void *)((wxObject *) ((wxSystemOptions *) x));
37429 }
37430 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
37431 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
37432 }
37433 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
37434 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37435 }
37436 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
37437 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
37438 }
37439 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
37440 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
37441 }
37442 static void *_p_wxWindowTo_p_wxObject(void *x) {
37443 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
37444 }
37445 static void *_p_wxMenuTo_p_wxObject(void *x) {
37446 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
37447 }
37448 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
37449 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
37450 }
37451 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
37452 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
37453 }
37454 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
37455 return (void *)((wxObject *) ((wxFileSystem *) x));
37456 }
37457 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
37458 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
37459 }
37460 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
37461 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
37462 }
37463 static void *_p_wxPyAppTo_p_wxObject(void *x) {
37464 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
37465 }
37466 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
37467 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
37468 }
37469 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
37470 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
37471 }
37472 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
37473 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
37474 }
37475 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
37476 return (void *)((wxObject *) ((wxBusyInfo *) x));
37477 }
37478 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
37479 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
37480 }
37481 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
37482 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
37483 }
37484 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
37485 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
37486 }
37487 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
37488 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
37489 }
37490 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
37491 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
37492 }
37493 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
37494 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
37495 }
37496 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
37497 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37498 }
37499 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
37500 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
37501 }
37502 static void *_p_wxValidatorTo_p_wxObject(void *x) {
37503 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
37504 }
37505 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
37506 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
37507 }
37508 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
37509 return (void *)((wxLog *) ((wxLogBuffer *) x));
37510 }
37511 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
37512 return (void *)((wxLog *) ((wxLogStderr *) x));
37513 }
37514 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
37515 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
37516 }
37517 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
37518 return (void *)((wxLog *) ((wxLogWindow *) x));
37519 }
37520 static void *_p_wxLogChainTo_p_wxLog(void *x) {
37521 return (void *)((wxLog *) ((wxLogChain *) x));
37522 }
37523 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
37524 return (void *)((wxLog *) ((wxLogGui *) x));
37525 }
37526 static void *_p_wxPyLogTo_p_wxLog(void *x) {
37527 return (void *)((wxLog *) ((wxPyLog *) x));
37528 }
37529 static void *_p_wxControlTo_p_wxWindow(void *x) {
37530 return (void *)((wxWindow *) ((wxControl *) x));
37531 }
37532 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
37533 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
37534 }
37535 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
37536 return (void *)((wxWindow *) ((wxMenuBar *) x));
37537 }
37538 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
37539 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
37540 }
37541 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
37542 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
37543 }
37544 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
37545 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};
37546 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
37547 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
37548 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
37549 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
37550 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
37551 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
37552 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
37553 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
37554 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
37555 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
37556 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
37557 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
37558 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
37559 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
37560 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
37561 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
37562 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
37563 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
37564 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
37565 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
37566 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
37567 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
37568 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
37569 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
37570 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
37571 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
37572 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
37573 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
37574 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
37575 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
37576 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
37577 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
37578 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
37579 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
37580 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
37581 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
37582 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
37583 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
37584 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
37585 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
37586 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
37587 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
37588 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
37589 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
37590 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
37591 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
37592 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
37593 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
37594 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
37595 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
37596 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
37597 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
37598 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
37599 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
37600 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
37601 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
37602 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
37603 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
37604 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
37605 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
37606 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
37607 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
37608 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
37609 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
37610 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
37611 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
37612 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
37613 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
37614 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
37615 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
37616 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
37617 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
37618 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
37619 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
37620 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
37621 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
37622 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
37623 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
37624 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
37625 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
37626 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
37627 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
37628 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
37629 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
37630 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
37631 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
37632 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
37633 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
37634 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
37635 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
37636 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
37637 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
37638 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
37639 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
37640 static swig_type_info _swigt__p_wxMemorySize = {"_p_wxMemorySize", "wxMemorySize *", 0, 0, (void*)0, 0};
37641 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
37642 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
37643 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
37644 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
37645 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
37646 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
37647 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
37648 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
37649 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
37650 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
37651 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
37652 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
37653 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
37654 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
37655 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
37656 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
37657 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
37658 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
37659 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
37660 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
37661 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
37662 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
37663 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
37664 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
37665 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
37666 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
37667 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
37668 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
37669 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
37670 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
37671 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
37672 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
37673 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
37674 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
37675 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
37676 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
37677 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
37678 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
37679 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
37680 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
37681 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
37682 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
37683 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
37684 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
37685 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
37686 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
37687 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
37688 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
37689 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
37690 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
37691 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
37692 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
37693 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
37694 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
37695 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
37696 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
37697 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
37698 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
37699 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
37700 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
37701 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
37702 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
37703 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
37704 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
37705 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
37706 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
37707 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
37708 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
37709 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
37710 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
37711 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
37712 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
37713 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
37714 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
37715
37716 static swig_type_info *swig_type_initial[] = {
37717 &_swigt__p_char,
37718 &_swigt__p_form_ops_t,
37719 &_swigt__p_int,
37720 &_swigt__p_unsigned_char,
37721 &_swigt__p_unsigned_int,
37722 &_swigt__p_unsigned_long,
37723 &_swigt__p_void,
37724 &_swigt__p_wxANIHandler,
37725 &_swigt__p_wxAcceleratorTable,
37726 &_swigt__p_wxActivateEvent,
37727 &_swigt__p_wxArrayString,
37728 &_swigt__p_wxBMPHandler,
37729 &_swigt__p_wxBitmap,
37730 &_swigt__p_wxBitmapDataObject,
37731 &_swigt__p_wxBoxSizer,
37732 &_swigt__p_wxBusyCursor,
37733 &_swigt__p_wxBusyInfo,
37734 &_swigt__p_wxCURHandler,
37735 &_swigt__p_wxCaret,
37736 &_swigt__p_wxChar,
37737 &_swigt__p_wxChildFocusEvent,
37738 &_swigt__p_wxClipboard,
37739 &_swigt__p_wxClipboardLocker,
37740 &_swigt__p_wxClipboardTextEvent,
37741 &_swigt__p_wxCloseEvent,
37742 &_swigt__p_wxColour,
37743 &_swigt__p_wxCommandEvent,
37744 &_swigt__p_wxConfig,
37745 &_swigt__p_wxConfigBase,
37746 &_swigt__p_wxConfigPathChanger,
37747 &_swigt__p_wxContextMenuEvent,
37748 &_swigt__p_wxControl,
37749 &_swigt__p_wxControlWithItems,
37750 &_swigt__p_wxCursor,
37751 &_swigt__p_wxCustomDataObject,
37752 &_swigt__p_wxDC,
37753 &_swigt__p_wxDataFormat,
37754 &_swigt__p_wxDataObject,
37755 &_swigt__p_wxDataObjectComposite,
37756 &_swigt__p_wxDataObjectSimple,
37757 &_swigt__p_wxDateEvent,
37758 &_swigt__p_wxDateSpan,
37759 &_swigt__p_wxDateTime,
37760 &_swigt__p_wxDateTime__TimeZone,
37761 &_swigt__p_wxDisplay,
37762 &_swigt__p_wxDisplayChangedEvent,
37763 &_swigt__p_wxDropFilesEvent,
37764 &_swigt__p_wxDuplexMode,
37765 &_swigt__p_wxEraseEvent,
37766 &_swigt__p_wxEvent,
37767 &_swigt__p_wxEvtHandler,
37768 &_swigt__p_wxFSFile,
37769 &_swigt__p_wxFileConfig,
37770 &_swigt__p_wxFileDataObject,
37771 &_swigt__p_wxFileHistory,
37772 &_swigt__p_wxFileSystem,
37773 &_swigt__p_wxFileType,
37774 &_swigt__p_wxFileTypeInfo,
37775 &_swigt__p_wxFlexGridSizer,
37776 &_swigt__p_wxFocusEvent,
37777 &_swigt__p_wxFont,
37778 &_swigt__p_wxFrame,
37779 &_swigt__p_wxGBSizerItem,
37780 &_swigt__p_wxGIFHandler,
37781 &_swigt__p_wxGridBagSizer,
37782 &_swigt__p_wxGridSizer,
37783 &_swigt__p_wxICOHandler,
37784 &_swigt__p_wxIcon,
37785 &_swigt__p_wxIconizeEvent,
37786 &_swigt__p_wxIdleEvent,
37787 &_swigt__p_wxImage,
37788 &_swigt__p_wxImageHandler,
37789 &_swigt__p_wxIndividualLayoutConstraint,
37790 &_swigt__p_wxInitDialogEvent,
37791 &_swigt__p_wxJPEGHandler,
37792 &_swigt__p_wxJoystick,
37793 &_swigt__p_wxJoystickEvent,
37794 &_swigt__p_wxKeyEvent,
37795 &_swigt__p_wxKillError,
37796 &_swigt__p_wxLayoutConstraints,
37797 &_swigt__p_wxLog,
37798 &_swigt__p_wxLogBuffer,
37799 &_swigt__p_wxLogChain,
37800 &_swigt__p_wxLogGui,
37801 &_swigt__p_wxLogNull,
37802 &_swigt__p_wxLogStderr,
37803 &_swigt__p_wxLogTextCtrl,
37804 &_swigt__p_wxLogWindow,
37805 &_swigt__p_wxMaximizeEvent,
37806 &_swigt__p_wxMemorySize,
37807 &_swigt__p_wxMenu,
37808 &_swigt__p_wxMenuBar,
37809 &_swigt__p_wxMenuEvent,
37810 &_swigt__p_wxMenuItem,
37811 &_swigt__p_wxMetafileDataObject,
37812 &_swigt__p_wxMimeTypesManager,
37813 &_swigt__p_wxMouseCaptureChangedEvent,
37814 &_swigt__p_wxMouseEvent,
37815 &_swigt__p_wxMouseState,
37816 &_swigt__p_wxMoveEvent,
37817 &_swigt__p_wxMutexGuiLocker,
37818 &_swigt__p_wxNavigationKeyEvent,
37819 &_swigt__p_wxNcPaintEvent,
37820 &_swigt__p_wxNotifyEvent,
37821 &_swigt__p_wxObject,
37822 &_swigt__p_wxOutputStream,
37823 &_swigt__p_wxPCXHandler,
37824 &_swigt__p_wxPNGHandler,
37825 &_swigt__p_wxPNMHandler,
37826 &_swigt__p_wxPaintEvent,
37827 &_swigt__p_wxPaletteChangedEvent,
37828 &_swigt__p_wxPaperSize,
37829 &_swigt__p_wxPoint,
37830 &_swigt__p_wxPowerEvent,
37831 &_swigt__p_wxProcessEvent,
37832 &_swigt__p_wxPyApp,
37833 &_swigt__p_wxPyArtProvider,
37834 &_swigt__p_wxPyBitmapDataObject,
37835 &_swigt__p_wxPyCommandEvent,
37836 &_swigt__p_wxPyDataObjectSimple,
37837 &_swigt__p_wxPyDropSource,
37838 &_swigt__p_wxPyDropTarget,
37839 &_swigt__p_wxPyEvent,
37840 &_swigt__p_wxPyFileDropTarget,
37841 &_swigt__p_wxPyImageHandler,
37842 &_swigt__p_wxPyLog,
37843 &_swigt__p_wxPyProcess,
37844 &_swigt__p_wxPySizer,
37845 &_swigt__p_wxPyTextDataObject,
37846 &_swigt__p_wxPyTextDropTarget,
37847 &_swigt__p_wxPyTimer,
37848 &_swigt__p_wxPyTipProvider,
37849 &_swigt__p_wxPyValidator,
37850 &_swigt__p_wxQueryNewPaletteEvent,
37851 &_swigt__p_wxRect,
37852 &_swigt__p_wxScrollEvent,
37853 &_swigt__p_wxScrollWinEvent,
37854 &_swigt__p_wxSetCursorEvent,
37855 &_swigt__p_wxShowEvent,
37856 &_swigt__p_wxSingleInstanceChecker,
37857 &_swigt__p_wxSize,
37858 &_swigt__p_wxSizeEvent,
37859 &_swigt__p_wxSizer,
37860 &_swigt__p_wxSizerItem,
37861 &_swigt__p_wxSound,
37862 &_swigt__p_wxStandardPaths,
37863 &_swigt__p_wxStaticBoxSizer,
37864 &_swigt__p_wxStdDialogButtonSizer,
37865 &_swigt__p_wxStopWatch,
37866 &_swigt__p_wxString,
37867 &_swigt__p_wxSysColourChangedEvent,
37868 &_swigt__p_wxSystemOptions,
37869 &_swigt__p_wxSystemSettings,
37870 &_swigt__p_wxTIFFHandler,
37871 &_swigt__p_wxTextCtrl,
37872 &_swigt__p_wxTextDataObject,
37873 &_swigt__p_wxTimeSpan,
37874 &_swigt__p_wxTimer,
37875 &_swigt__p_wxTimerEvent,
37876 &_swigt__p_wxTimerRunner,
37877 &_swigt__p_wxTipProvider,
37878 &_swigt__p_wxToolTip,
37879 &_swigt__p_wxURLDataObject,
37880 &_swigt__p_wxUpdateUIEvent,
37881 &_swigt__p_wxValidator,
37882 &_swigt__p_wxVideoMode,
37883 &_swigt__p_wxWindow,
37884 &_swigt__p_wxWindowCreateEvent,
37885 &_swigt__p_wxWindowDestroyEvent,
37886 &_swigt__p_wxWindowDisabler,
37887 &_swigt__p_wxXPMHandler,
37888 };
37889
37890 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
37891 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
37892 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
37893 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
37894 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
37895 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
37896 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
37897 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
37898 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
37899 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}};
37900 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
37901 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
37902 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
37903 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
37904 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
37905 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
37906 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
37907 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
37908 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}};
37909 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
37910 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
37911 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
37912 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
37913 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
37914 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}};
37915 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
37916 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}};
37917 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
37918 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
37919 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
37920 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
37921 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
37922 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37923 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37924 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
37925 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
37926 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
37927 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
37928 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
37929 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
37930 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
37931 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
37932 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
37933 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
37934 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
37935 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37936 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37937 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
37938 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37939 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
37940 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
37941 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
37942 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37943 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37944 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
37945 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37946 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37947 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37948 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37949 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
37950 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37951 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37952 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
37953 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37954 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37955 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
37956 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37957 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37958 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
37959 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_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_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
37960 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
37961 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
37962 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
37963 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
37964 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
37965 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
37966 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}};
37967 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
37968 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37969 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
37970 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
37971 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
37972 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
37973 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
37974 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
37975 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
37976 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
37977 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
37978 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}};
37979 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
37980 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
37981 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
37982 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
37983 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
37984 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
37985 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
37986 static swig_cast_info _swigc__p_wxMemorySize[] = { {&_swigt__p_wxMemorySize, 0, 0, 0},{0, 0, 0, 0}};
37987 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
37988 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37989 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
37990 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
37991 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
37992 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
37993 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37994 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37995 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
37996 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37997 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37998 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
37999 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
38000 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38001 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38002 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
38003 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
38004 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
38005 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38006 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38007 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
38008 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
38009 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
38010 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
38011 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
38012 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
38013 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
38014 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
38015 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
38016 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
38017 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
38018 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
38019 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
38020 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
38021 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
38022 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_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_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_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_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_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}};
38023 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
38024 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
38025 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
38026 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
38027 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
38028 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
38029 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
38030 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
38031 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
38032 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}};
38033 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38034 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
38035 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
38036 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
38037 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38038 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
38039 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
38040 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
38041 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
38042 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
38043 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
38044 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
38045 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
38046 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
38047 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
38048 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
38049 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38050 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}};
38051 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
38052 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
38053 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
38054 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
38055 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}};
38056 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
38057 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
38058 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
38059 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}};
38060 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
38061
38062 static swig_cast_info *swig_cast_initial[] = {
38063 _swigc__p_char,
38064 _swigc__p_form_ops_t,
38065 _swigc__p_int,
38066 _swigc__p_unsigned_char,
38067 _swigc__p_unsigned_int,
38068 _swigc__p_unsigned_long,
38069 _swigc__p_void,
38070 _swigc__p_wxANIHandler,
38071 _swigc__p_wxAcceleratorTable,
38072 _swigc__p_wxActivateEvent,
38073 _swigc__p_wxArrayString,
38074 _swigc__p_wxBMPHandler,
38075 _swigc__p_wxBitmap,
38076 _swigc__p_wxBitmapDataObject,
38077 _swigc__p_wxBoxSizer,
38078 _swigc__p_wxBusyCursor,
38079 _swigc__p_wxBusyInfo,
38080 _swigc__p_wxCURHandler,
38081 _swigc__p_wxCaret,
38082 _swigc__p_wxChar,
38083 _swigc__p_wxChildFocusEvent,
38084 _swigc__p_wxClipboard,
38085 _swigc__p_wxClipboardLocker,
38086 _swigc__p_wxClipboardTextEvent,
38087 _swigc__p_wxCloseEvent,
38088 _swigc__p_wxColour,
38089 _swigc__p_wxCommandEvent,
38090 _swigc__p_wxConfig,
38091 _swigc__p_wxConfigBase,
38092 _swigc__p_wxConfigPathChanger,
38093 _swigc__p_wxContextMenuEvent,
38094 _swigc__p_wxControl,
38095 _swigc__p_wxControlWithItems,
38096 _swigc__p_wxCursor,
38097 _swigc__p_wxCustomDataObject,
38098 _swigc__p_wxDC,
38099 _swigc__p_wxDataFormat,
38100 _swigc__p_wxDataObject,
38101 _swigc__p_wxDataObjectComposite,
38102 _swigc__p_wxDataObjectSimple,
38103 _swigc__p_wxDateEvent,
38104 _swigc__p_wxDateSpan,
38105 _swigc__p_wxDateTime,
38106 _swigc__p_wxDateTime__TimeZone,
38107 _swigc__p_wxDisplay,
38108 _swigc__p_wxDisplayChangedEvent,
38109 _swigc__p_wxDropFilesEvent,
38110 _swigc__p_wxDuplexMode,
38111 _swigc__p_wxEraseEvent,
38112 _swigc__p_wxEvent,
38113 _swigc__p_wxEvtHandler,
38114 _swigc__p_wxFSFile,
38115 _swigc__p_wxFileConfig,
38116 _swigc__p_wxFileDataObject,
38117 _swigc__p_wxFileHistory,
38118 _swigc__p_wxFileSystem,
38119 _swigc__p_wxFileType,
38120 _swigc__p_wxFileTypeInfo,
38121 _swigc__p_wxFlexGridSizer,
38122 _swigc__p_wxFocusEvent,
38123 _swigc__p_wxFont,
38124 _swigc__p_wxFrame,
38125 _swigc__p_wxGBSizerItem,
38126 _swigc__p_wxGIFHandler,
38127 _swigc__p_wxGridBagSizer,
38128 _swigc__p_wxGridSizer,
38129 _swigc__p_wxICOHandler,
38130 _swigc__p_wxIcon,
38131 _swigc__p_wxIconizeEvent,
38132 _swigc__p_wxIdleEvent,
38133 _swigc__p_wxImage,
38134 _swigc__p_wxImageHandler,
38135 _swigc__p_wxIndividualLayoutConstraint,
38136 _swigc__p_wxInitDialogEvent,
38137 _swigc__p_wxJPEGHandler,
38138 _swigc__p_wxJoystick,
38139 _swigc__p_wxJoystickEvent,
38140 _swigc__p_wxKeyEvent,
38141 _swigc__p_wxKillError,
38142 _swigc__p_wxLayoutConstraints,
38143 _swigc__p_wxLog,
38144 _swigc__p_wxLogBuffer,
38145 _swigc__p_wxLogChain,
38146 _swigc__p_wxLogGui,
38147 _swigc__p_wxLogNull,
38148 _swigc__p_wxLogStderr,
38149 _swigc__p_wxLogTextCtrl,
38150 _swigc__p_wxLogWindow,
38151 _swigc__p_wxMaximizeEvent,
38152 _swigc__p_wxMemorySize,
38153 _swigc__p_wxMenu,
38154 _swigc__p_wxMenuBar,
38155 _swigc__p_wxMenuEvent,
38156 _swigc__p_wxMenuItem,
38157 _swigc__p_wxMetafileDataObject,
38158 _swigc__p_wxMimeTypesManager,
38159 _swigc__p_wxMouseCaptureChangedEvent,
38160 _swigc__p_wxMouseEvent,
38161 _swigc__p_wxMouseState,
38162 _swigc__p_wxMoveEvent,
38163 _swigc__p_wxMutexGuiLocker,
38164 _swigc__p_wxNavigationKeyEvent,
38165 _swigc__p_wxNcPaintEvent,
38166 _swigc__p_wxNotifyEvent,
38167 _swigc__p_wxObject,
38168 _swigc__p_wxOutputStream,
38169 _swigc__p_wxPCXHandler,
38170 _swigc__p_wxPNGHandler,
38171 _swigc__p_wxPNMHandler,
38172 _swigc__p_wxPaintEvent,
38173 _swigc__p_wxPaletteChangedEvent,
38174 _swigc__p_wxPaperSize,
38175 _swigc__p_wxPoint,
38176 _swigc__p_wxPowerEvent,
38177 _swigc__p_wxProcessEvent,
38178 _swigc__p_wxPyApp,
38179 _swigc__p_wxPyArtProvider,
38180 _swigc__p_wxPyBitmapDataObject,
38181 _swigc__p_wxPyCommandEvent,
38182 _swigc__p_wxPyDataObjectSimple,
38183 _swigc__p_wxPyDropSource,
38184 _swigc__p_wxPyDropTarget,
38185 _swigc__p_wxPyEvent,
38186 _swigc__p_wxPyFileDropTarget,
38187 _swigc__p_wxPyImageHandler,
38188 _swigc__p_wxPyLog,
38189 _swigc__p_wxPyProcess,
38190 _swigc__p_wxPySizer,
38191 _swigc__p_wxPyTextDataObject,
38192 _swigc__p_wxPyTextDropTarget,
38193 _swigc__p_wxPyTimer,
38194 _swigc__p_wxPyTipProvider,
38195 _swigc__p_wxPyValidator,
38196 _swigc__p_wxQueryNewPaletteEvent,
38197 _swigc__p_wxRect,
38198 _swigc__p_wxScrollEvent,
38199 _swigc__p_wxScrollWinEvent,
38200 _swigc__p_wxSetCursorEvent,
38201 _swigc__p_wxShowEvent,
38202 _swigc__p_wxSingleInstanceChecker,
38203 _swigc__p_wxSize,
38204 _swigc__p_wxSizeEvent,
38205 _swigc__p_wxSizer,
38206 _swigc__p_wxSizerItem,
38207 _swigc__p_wxSound,
38208 _swigc__p_wxStandardPaths,
38209 _swigc__p_wxStaticBoxSizer,
38210 _swigc__p_wxStdDialogButtonSizer,
38211 _swigc__p_wxStopWatch,
38212 _swigc__p_wxString,
38213 _swigc__p_wxSysColourChangedEvent,
38214 _swigc__p_wxSystemOptions,
38215 _swigc__p_wxSystemSettings,
38216 _swigc__p_wxTIFFHandler,
38217 _swigc__p_wxTextCtrl,
38218 _swigc__p_wxTextDataObject,
38219 _swigc__p_wxTimeSpan,
38220 _swigc__p_wxTimer,
38221 _swigc__p_wxTimerEvent,
38222 _swigc__p_wxTimerRunner,
38223 _swigc__p_wxTipProvider,
38224 _swigc__p_wxToolTip,
38225 _swigc__p_wxURLDataObject,
38226 _swigc__p_wxUpdateUIEvent,
38227 _swigc__p_wxValidator,
38228 _swigc__p_wxVideoMode,
38229 _swigc__p_wxWindow,
38230 _swigc__p_wxWindowCreateEvent,
38231 _swigc__p_wxWindowDestroyEvent,
38232 _swigc__p_wxWindowDisabler,
38233 _swigc__p_wxXPMHandler,
38234 };
38235
38236
38237 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
38238
38239 static swig_const_info swig_const_table[] = {
38240 {0, 0, 0, 0.0, 0, 0}};
38241
38242 #ifdef __cplusplus
38243 }
38244 #endif
38245 /* -----------------------------------------------------------------------------
38246 * Type initialization:
38247 * This problem is tough by the requirement that no dynamic
38248 * memory is used. Also, since swig_type_info structures store pointers to
38249 * swig_cast_info structures and swig_cast_info structures store pointers back
38250 * to swig_type_info structures, we need some lookup code at initialization.
38251 * The idea is that swig generates all the structures that are needed.
38252 * The runtime then collects these partially filled structures.
38253 * The SWIG_InitializeModule function takes these initial arrays out of
38254 * swig_module, and does all the lookup, filling in the swig_module.types
38255 * array with the correct data and linking the correct swig_cast_info
38256 * structures together.
38257 *
38258 * The generated swig_type_info structures are assigned staticly to an initial
38259 * array. We just loop though that array, and handle each type individually.
38260 * First we lookup if this type has been already loaded, and if so, use the
38261 * loaded structure instead of the generated one. Then we have to fill in the
38262 * cast linked list. The cast data is initially stored in something like a
38263 * two-dimensional array. Each row corresponds to a type (there are the same
38264 * number of rows as there are in the swig_type_initial array). Each entry in
38265 * a column is one of the swig_cast_info structures for that type.
38266 * The cast_initial array is actually an array of arrays, because each row has
38267 * a variable number of columns. So to actually build the cast linked list,
38268 * we find the array of casts associated with the type, and loop through it
38269 * adding the casts to the list. The one last trick we need to do is making
38270 * sure the type pointer in the swig_cast_info struct is correct.
38271 *
38272 * First off, we lookup the cast->type name to see if it is already loaded.
38273 * There are three cases to handle:
38274 * 1) If the cast->type has already been loaded AND the type we are adding
38275 * casting info to has not been loaded (it is in this module), THEN we
38276 * replace the cast->type pointer with the type pointer that has already
38277 * been loaded.
38278 * 2) If BOTH types (the one we are adding casting info to, and the
38279 * cast->type) are loaded, THEN the cast info has already been loaded by
38280 * the previous module so we just ignore it.
38281 * 3) Finally, if cast->type has not already been loaded, then we add that
38282 * swig_cast_info to the linked list (because the cast->type) pointer will
38283 * be correct.
38284 * ----------------------------------------------------------------------------- */
38285
38286 #ifdef __cplusplus
38287 extern "C" {
38288 #if 0
38289 } /* c-mode */
38290 #endif
38291 #endif
38292
38293 #if 0
38294 #define SWIGRUNTIME_DEBUG
38295 #endif
38296
38297 SWIGRUNTIME void
38298 SWIG_InitializeModule(void *clientdata) {
38299 size_t i;
38300 swig_module_info *module_head;
38301 static int init_run = 0;
38302
38303 clientdata = clientdata;
38304
38305 if (init_run) return;
38306 init_run = 1;
38307
38308 /* Initialize the swig_module */
38309 swig_module.type_initial = swig_type_initial;
38310 swig_module.cast_initial = swig_cast_initial;
38311
38312 /* Try and load any already created modules */
38313 module_head = SWIG_GetModule(clientdata);
38314 if (module_head) {
38315 swig_module.next = module_head->next;
38316 module_head->next = &swig_module;
38317 } else {
38318 /* This is the first module loaded */
38319 swig_module.next = &swig_module;
38320 SWIG_SetModule(clientdata, &swig_module);
38321 }
38322
38323 /* Now work on filling in swig_module.types */
38324 #ifdef SWIGRUNTIME_DEBUG
38325 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
38326 #endif
38327 for (i = 0; i < swig_module.size; ++i) {
38328 swig_type_info *type = 0;
38329 swig_type_info *ret;
38330 swig_cast_info *cast;
38331
38332 #ifdef SWIGRUNTIME_DEBUG
38333 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38334 #endif
38335
38336 /* if there is another module already loaded */
38337 if (swig_module.next != &swig_module) {
38338 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
38339 }
38340 if (type) {
38341 /* Overwrite clientdata field */
38342 #ifdef SWIGRUNTIME_DEBUG
38343 printf("SWIG_InitializeModule: found type %s\n", type->name);
38344 #endif
38345 if (swig_module.type_initial[i]->clientdata) {
38346 type->clientdata = swig_module.type_initial[i]->clientdata;
38347 #ifdef SWIGRUNTIME_DEBUG
38348 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
38349 #endif
38350 }
38351 } else {
38352 type = swig_module.type_initial[i];
38353 }
38354
38355 /* Insert casting types */
38356 cast = swig_module.cast_initial[i];
38357 while (cast->type) {
38358 /* Don't need to add information already in the list */
38359 ret = 0;
38360 #ifdef SWIGRUNTIME_DEBUG
38361 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
38362 #endif
38363 if (swig_module.next != &swig_module) {
38364 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
38365 #ifdef SWIGRUNTIME_DEBUG
38366 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
38367 #endif
38368 }
38369 if (ret) {
38370 if (type == swig_module.type_initial[i]) {
38371 #ifdef SWIGRUNTIME_DEBUG
38372 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
38373 #endif
38374 cast->type = ret;
38375 ret = 0;
38376 } else {
38377 /* Check for casting already in the list */
38378 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
38379 #ifdef SWIGRUNTIME_DEBUG
38380 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
38381 #endif
38382 if (!ocast) ret = 0;
38383 }
38384 }
38385
38386 if (!ret) {
38387 #ifdef SWIGRUNTIME_DEBUG
38388 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
38389 #endif
38390 if (type->cast) {
38391 type->cast->prev = cast;
38392 cast->next = type->cast;
38393 }
38394 type->cast = cast;
38395 }
38396 cast++;
38397 }
38398 /* Set entry in modules->types array equal to the type */
38399 swig_module.types[i] = type;
38400 }
38401 swig_module.types[i] = 0;
38402
38403 #ifdef SWIGRUNTIME_DEBUG
38404 printf("**** SWIG_InitializeModule: Cast List ******\n");
38405 for (i = 0; i < swig_module.size; ++i) {
38406 int j = 0;
38407 swig_cast_info *cast = swig_module.cast_initial[i];
38408 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38409 while (cast->type) {
38410 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
38411 cast++;
38412 ++j;
38413 }
38414 printf("---- Total casts: %d\n",j);
38415 }
38416 printf("**** SWIG_InitializeModule: Cast List ******\n");
38417 #endif
38418 }
38419
38420 /* This function will propagate the clientdata field of type to
38421 * any new swig_type_info structures that have been added into the list
38422 * of equivalent types. It is like calling
38423 * SWIG_TypeClientData(type, clientdata) a second time.
38424 */
38425 SWIGRUNTIME void
38426 SWIG_PropagateClientData(void) {
38427 size_t i;
38428 swig_cast_info *equiv;
38429 static int init_run = 0;
38430
38431 if (init_run) return;
38432 init_run = 1;
38433
38434 for (i = 0; i < swig_module.size; i++) {
38435 if (swig_module.types[i]->clientdata) {
38436 equiv = swig_module.types[i]->cast;
38437 while (equiv) {
38438 if (!equiv->converter) {
38439 if (equiv->type && !equiv->type->clientdata)
38440 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
38441 }
38442 equiv = equiv->next;
38443 }
38444 }
38445 }
38446 }
38447
38448 #ifdef __cplusplus
38449 #if 0
38450 {
38451 /* c-mode */
38452 #endif
38453 }
38454 #endif
38455
38456
38457
38458 #ifdef __cplusplus
38459 extern "C" {
38460 #endif
38461
38462 /* Python-specific SWIG API */
38463 #define SWIG_newvarlink() SWIG_Python_newvarlink()
38464 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
38465 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
38466
38467 /* -----------------------------------------------------------------------------
38468 * global variable support code.
38469 * ----------------------------------------------------------------------------- */
38470
38471 typedef struct swig_globalvar {
38472 char *name; /* Name of global variable */
38473 PyObject *(*get_attr)(void); /* Return the current value */
38474 int (*set_attr)(PyObject *); /* Set the value */
38475 struct swig_globalvar *next;
38476 } swig_globalvar;
38477
38478 typedef struct swig_varlinkobject {
38479 PyObject_HEAD
38480 swig_globalvar *vars;
38481 } swig_varlinkobject;
38482
38483 SWIGINTERN PyObject *
38484 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
38485 return PyString_FromString("<Swig global variables>");
38486 }
38487
38488 SWIGINTERN PyObject *
38489 swig_varlink_str(swig_varlinkobject *v) {
38490 PyObject *str = PyString_FromString("(");
38491 swig_globalvar *var;
38492 for (var = v->vars; var; var=var->next) {
38493 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
38494 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
38495 }
38496 PyString_ConcatAndDel(&str,PyString_FromString(")"));
38497 return str;
38498 }
38499
38500 SWIGINTERN int
38501 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
38502 PyObject *str = swig_varlink_str(v);
38503 fprintf(fp,"Swig global variables ");
38504 fprintf(fp,"%s\n", PyString_AsString(str));
38505 Py_DECREF(str);
38506 return 0;
38507 }
38508
38509 SWIGINTERN void
38510 swig_varlink_dealloc(swig_varlinkobject *v) {
38511 swig_globalvar *var = v->vars;
38512 while (var) {
38513 swig_globalvar *n = var->next;
38514 free(var->name);
38515 free(var);
38516 var = n;
38517 }
38518 }
38519
38520 SWIGINTERN PyObject *
38521 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
38522 PyObject *res = NULL;
38523 swig_globalvar *var = v->vars;
38524 while (var) {
38525 if (strcmp(var->name,n) == 0) {
38526 res = (*var->get_attr)();
38527 break;
38528 }
38529 var = var->next;
38530 }
38531 if (res == NULL && !PyErr_Occurred()) {
38532 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38533 }
38534 return res;
38535 }
38536
38537 SWIGINTERN int
38538 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
38539 int res = 1;
38540 swig_globalvar *var = v->vars;
38541 while (var) {
38542 if (strcmp(var->name,n) == 0) {
38543 res = (*var->set_attr)(p);
38544 break;
38545 }
38546 var = var->next;
38547 }
38548 if (res == 1 && !PyErr_Occurred()) {
38549 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38550 }
38551 return res;
38552 }
38553
38554 SWIGINTERN PyTypeObject*
38555 swig_varlink_type(void) {
38556 static char varlink__doc__[] = "Swig var link object";
38557 static PyTypeObject varlink_type;
38558 static int type_init = 0;
38559 if (!type_init) {
38560 const PyTypeObject tmp
38561 = {
38562 PyObject_HEAD_INIT(NULL)
38563 0, /* Number of items in variable part (ob_size) */
38564 (char *)"swigvarlink", /* Type name (tp_name) */
38565 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
38566 0, /* Itemsize (tp_itemsize) */
38567 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
38568 (printfunc) swig_varlink_print, /* Print (tp_print) */
38569 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
38570 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
38571 0, /* tp_compare */
38572 (reprfunc) swig_varlink_repr, /* tp_repr */
38573 0, /* tp_as_number */
38574 0, /* tp_as_sequence */
38575 0, /* tp_as_mapping */
38576 0, /* tp_hash */
38577 0, /* tp_call */
38578 (reprfunc)swig_varlink_str, /* tp_str */
38579 0, /* tp_getattro */
38580 0, /* tp_setattro */
38581 0, /* tp_as_buffer */
38582 0, /* tp_flags */
38583 varlink__doc__, /* tp_doc */
38584 0, /* tp_traverse */
38585 0, /* tp_clear */
38586 0, /* tp_richcompare */
38587 0, /* tp_weaklistoffset */
38588 #if PY_VERSION_HEX >= 0x02020000
38589 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
38590 #endif
38591 #if PY_VERSION_HEX >= 0x02030000
38592 0, /* tp_del */
38593 #endif
38594 #ifdef COUNT_ALLOCS
38595 0,0,0,0 /* tp_alloc -> tp_next */
38596 #endif
38597 };
38598 varlink_type = tmp;
38599 varlink_type.ob_type = &PyType_Type;
38600 type_init = 1;
38601 }
38602 return &varlink_type;
38603 }
38604
38605 /* Create a variable linking object for use later */
38606 SWIGINTERN PyObject *
38607 SWIG_Python_newvarlink(void) {
38608 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
38609 if (result) {
38610 result->vars = 0;
38611 }
38612 return ((PyObject*) result);
38613 }
38614
38615 SWIGINTERN void
38616 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
38617 swig_varlinkobject *v = (swig_varlinkobject *) p;
38618 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
38619 if (gv) {
38620 size_t size = strlen(name)+1;
38621 gv->name = (char *)malloc(size);
38622 if (gv->name) {
38623 strncpy(gv->name,name,size);
38624 gv->get_attr = get_attr;
38625 gv->set_attr = set_attr;
38626 gv->next = v->vars;
38627 }
38628 }
38629 v->vars = gv;
38630 }
38631
38632 SWIGINTERN PyObject *
38633 SWIG_globals() {
38634 static PyObject *_SWIG_globals = 0;
38635 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
38636 return _SWIG_globals;
38637 }
38638
38639 /* -----------------------------------------------------------------------------
38640 * constants/methods manipulation
38641 * ----------------------------------------------------------------------------- */
38642
38643 /* Install Constants */
38644 SWIGINTERN void
38645 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
38646 PyObject *obj = 0;
38647 size_t i;
38648 for (i = 0; constants[i].type; ++i) {
38649 switch(constants[i].type) {
38650 case SWIG_PY_POINTER:
38651 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
38652 break;
38653 case SWIG_PY_BINARY:
38654 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
38655 break;
38656 default:
38657 obj = 0;
38658 break;
38659 }
38660 if (obj) {
38661 PyDict_SetItemString(d, constants[i].name, obj);
38662 Py_DECREF(obj);
38663 }
38664 }
38665 }
38666
38667 /* -----------------------------------------------------------------------------*/
38668 /* Fix SwigMethods to carry the callback ptrs when needed */
38669 /* -----------------------------------------------------------------------------*/
38670
38671 SWIGINTERN void
38672 SWIG_Python_FixMethods(PyMethodDef *methods,
38673 swig_const_info *const_table,
38674 swig_type_info **types,
38675 swig_type_info **types_initial) {
38676 size_t i;
38677 for (i = 0; methods[i].ml_name; ++i) {
38678 char *c = methods[i].ml_doc;
38679 if (c && (c = strstr(c, "swig_ptr: "))) {
38680 int j;
38681 swig_const_info *ci = 0;
38682 char *name = c + 10;
38683 for (j = 0; const_table[j].type; ++j) {
38684 if (strncmp(const_table[j].name, name,
38685 strlen(const_table[j].name)) == 0) {
38686 ci = &(const_table[j]);
38687 break;
38688 }
38689 }
38690 if (ci) {
38691 size_t shift = (ci->ptype) - types;
38692 swig_type_info *ty = types_initial[shift];
38693 size_t ldoc = (c - methods[i].ml_doc);
38694 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
38695 char *ndoc = (char*)malloc(ldoc + lptr + 10);
38696 if (ndoc) {
38697 char *buff = ndoc;
38698 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
38699 if (ptr) {
38700 strncpy(buff, methods[i].ml_doc, ldoc);
38701 buff += ldoc;
38702 strncpy(buff, "swig_ptr: ", 10);
38703 buff += 10;
38704 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
38705 methods[i].ml_doc = ndoc;
38706 }
38707 }
38708 }
38709 }
38710 }
38711 }
38712
38713 #ifdef __cplusplus
38714 }
38715 #endif
38716
38717 /* -----------------------------------------------------------------------------*
38718 * Partial Init method
38719 * -----------------------------------------------------------------------------*/
38720
38721 #ifdef __cplusplus
38722 extern "C"
38723 #endif
38724 SWIGEXPORT void SWIG_init(void) {
38725 PyObject *m, *d;
38726
38727 /* Fix SwigMethods to carry the callback ptrs when needed */
38728 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
38729
38730 m = Py_InitModule((char *) SWIG_name, SwigMethods);
38731 d = PyModule_GetDict(m);
38732
38733 SWIG_InitializeModule(0);
38734 SWIG_InstallConstants(d,swig_const_table);
38735
38736
38737 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
38738 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
38739 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
38740 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
38741 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
38742 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
38743 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
38744 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
38745 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
38746 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
38747 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
38748 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
38749 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
38750 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
38751 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
38752 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
38753 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
38754 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
38755 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
38756 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
38757 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
38758 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
38759 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
38760 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
38761 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
38762 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
38763 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
38764 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
38765 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
38766 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
38767 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
38768 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
38769 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
38770 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
38771 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
38772 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
38773 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
38774 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
38775 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
38776 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
38777 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
38778 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
38779 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
38780 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
38781 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
38782 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
38783 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
38784 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
38785 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
38786 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
38787 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
38788 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
38789 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
38790 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
38791 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
38792 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
38793 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
38794 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
38795 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
38796 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
38797 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
38798 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
38799 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
38800 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
38801 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
38802 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
38803 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
38804 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
38805 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
38806 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
38807 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
38808 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
38809 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
38810 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
38811 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
38812 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
38813 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
38814 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
38815 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
38816 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
38817 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
38818 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
38819 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
38820 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
38821 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
38822 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
38823 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
38824 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
38825 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
38826 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
38827 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
38828 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
38829 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
38830 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
38831 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
38832 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
38833 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
38834 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
38835 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
38836 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
38837 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
38838 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
38839
38840 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
38841
38842 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
38843 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
38844 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
38845 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
38846 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
38847 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
38848 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
38849 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
38850 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
38851 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
38852 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
38853 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
38854 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
38855 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
38856 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
38857 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
38858 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
38859 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
38860 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
38861 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
38862 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
38863 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
38864 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
38865 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
38866 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
38867 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
38868 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
38869 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
38870 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
38871 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
38872 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
38873 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
38874 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
38875 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
38876 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
38877 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
38878 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
38879 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
38880 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
38881 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
38882 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
38883 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
38884 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
38885 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
38886 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
38887 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
38888 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
38889 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
38890 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
38891 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
38892 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
38893 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
38894 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
38895
38896 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
38897
38898 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
38899 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
38900 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
38901 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
38902 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
38903 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
38904 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
38905 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
38906 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
38907 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
38908 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
38909 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
38910 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
38911 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
38912 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
38913 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
38914 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
38915 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
38916 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
38917 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
38918 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
38919 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
38920 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
38921 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
38922 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
38923 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
38924 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
38925 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
38926 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
38927 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
38928 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
38929 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
38930 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
38931 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
38932 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
38933 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
38934 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
38935 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
38936 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
38937 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
38938 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
38939 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
38940 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
38941 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
38942 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
38943 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
38944 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
38945 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
38946 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
38947 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
38948 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
38949 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
38950 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
38951 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
38952 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
38953 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
38954 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
38955 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
38956 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
38957 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
38958 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
38959 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
38960 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
38961 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
38962 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
38963 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
38964 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
38965 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
38966 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
38967 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
38968 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
38969 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
38970 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
38971 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
38972 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
38973 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
38974
38975 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
38976
38977 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
38978 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
38979 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
38980 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
38981 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
38982 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
38983 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
38984 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
38985 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
38986 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
38987 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
38988 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
38989 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
38990 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
38991 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
38992 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
38993 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
38994 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
38995 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
38996 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
38997 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
38998 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
38999 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
39000 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
39001 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
39002 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
39003 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
39004 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
39005 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
39006 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
39007 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
39008 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
39009 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
39010 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
39011 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
39012 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
39013 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
39014 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
39015 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
39016 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
39017 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
39018 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
39019 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
39020 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
39021 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
39022 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
39023 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
39024 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
39025 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
39026 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
39027 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
39028 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
39029 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
39030 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
39031 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
39032 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
39033 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
39034 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
39035 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
39036 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
39037 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
39038 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
39039 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
39040 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
39041 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
39042 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
39043 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
39044 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
39045 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
39046 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
39047 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
39048 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
39049 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
39050 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
39051 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
39052 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
39053 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
39054 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
39055 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
39056 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
39057 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
39058 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
39059 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
39060 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
39061 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
39062 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
39063 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
39064 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
39065 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
39066 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
39067 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
39068 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
39069 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
39070 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
39071 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
39072 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
39073 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
39074 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
39075 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
39076 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
39077 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
39078 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
39079 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
39080 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
39081 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
39082 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
39083 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
39084 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
39085 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
39086 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
39087 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
39088 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
39089 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
39090 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
39091 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
39092 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
39093 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
39094 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
39095 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
39096 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
39097 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
39098 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
39099 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
39100 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
39101 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
39102 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
39103 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
39104 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
39105 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
39106 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
39107 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
39108 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
39109 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
39110 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
39111 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
39112 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
39113 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
39114 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
39115 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
39116 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
39117 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
39118 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
39119 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
39120 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
39121 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
39122 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
39123 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
39124 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
39125 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
39126 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
39127 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
39128 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
39129 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
39130 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
39131 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
39132 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
39133 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
39134 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
39135 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
39136 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
39137 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
39138 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
39139 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
39140 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
39141 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
39142 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
39143 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
39144 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
39145 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
39146 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
39147 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
39148 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
39149 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
39150 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
39151 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
39152 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
39153 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
39154 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
39155 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
39156 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
39157 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
39158 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
39159 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
39160 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
39161 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
39162 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
39163 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
39164 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
39165 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
39166 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
39167 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
39168 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
39169 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
39170 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
39171 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
39172 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
39173 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
39174 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
39175 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
39176 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
39177
39178 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
39179 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
39180 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
39181 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
39182
39183 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
39184 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
39185 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
39186 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
39187 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
39188 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
39189 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
39190 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
39191 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
39192 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
39193 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
39194 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
39195 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
39196 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
39197 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
39198 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
39199 }
39200
wxWidgets (Impactor)