]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Use correct DLL import/export specifier for multi-lib builds
[wxWidgets.git] / wxPython / src / msw / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_char swig_types[0]
2463 #define SWIGTYPE_p_form_ops_t swig_types[1]
2464 #define SWIGTYPE_p_int swig_types[2]
2465 #define SWIGTYPE_p_unsigned_char swig_types[3]
2466 #define SWIGTYPE_p_unsigned_int swig_types[4]
2467 #define SWIGTYPE_p_unsigned_long swig_types[5]
2468 #define SWIGTYPE_p_void swig_types[6]
2469 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2470 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2471 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2472 #define SWIGTYPE_p_wxArrayString swig_types[10]
2473 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2474 #define SWIGTYPE_p_wxBitmap swig_types[12]
2475 #define SWIGTYPE_p_wxBitmapDataObject swig_types[13]
2476 #define SWIGTYPE_p_wxBoxSizer swig_types[14]
2477 #define SWIGTYPE_p_wxBusyCursor swig_types[15]
2478 #define SWIGTYPE_p_wxBusyInfo swig_types[16]
2479 #define SWIGTYPE_p_wxCURHandler swig_types[17]
2480 #define SWIGTYPE_p_wxCaret swig_types[18]
2481 #define SWIGTYPE_p_wxChar swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxClipboard swig_types[21]
2484 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
2485 #define SWIGTYPE_p_wxCloseEvent swig_types[23]
2486 #define SWIGTYPE_p_wxColour swig_types[24]
2487 #define SWIGTYPE_p_wxCommandEvent swig_types[25]
2488 #define SWIGTYPE_p_wxConfig swig_types[26]
2489 #define SWIGTYPE_p_wxConfigBase swig_types[27]
2490 #define SWIGTYPE_p_wxConfigPathChanger swig_types[28]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[29]
2492 #define SWIGTYPE_p_wxControl swig_types[30]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[31]
2494 #define SWIGTYPE_p_wxCursor swig_types[32]
2495 #define SWIGTYPE_p_wxCustomDataObject swig_types[33]
2496 #define SWIGTYPE_p_wxDC swig_types[34]
2497 #define SWIGTYPE_p_wxDataFormat swig_types[35]
2498 #define SWIGTYPE_p_wxDataObject swig_types[36]
2499 #define SWIGTYPE_p_wxDataObjectComposite swig_types[37]
2500 #define SWIGTYPE_p_wxDataObjectSimple swig_types[38]
2501 #define SWIGTYPE_p_wxDateEvent swig_types[39]
2502 #define SWIGTYPE_p_wxDateSpan swig_types[40]
2503 #define SWIGTYPE_p_wxDateTime swig_types[41]
2504 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[42]
2505 #define SWIGTYPE_p_wxDisplay swig_types[43]
2506 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[44]
2507 #define SWIGTYPE_p_wxDropFilesEvent swig_types[45]
2508 #define SWIGTYPE_p_wxDuplexMode swig_types[46]
2509 #define SWIGTYPE_p_wxEraseEvent swig_types[47]
2510 #define SWIGTYPE_p_wxEvent swig_types[48]
2511 #define SWIGTYPE_p_wxEvtHandler swig_types[49]
2512 #define SWIGTYPE_p_wxFSFile swig_types[50]
2513 #define SWIGTYPE_p_wxFileConfig swig_types[51]
2514 #define SWIGTYPE_p_wxFileDataObject swig_types[52]
2515 #define SWIGTYPE_p_wxFileHistory swig_types[53]
2516 #define SWIGTYPE_p_wxFileSystem swig_types[54]
2517 #define SWIGTYPE_p_wxFileType swig_types[55]
2518 #define SWIGTYPE_p_wxFileTypeInfo swig_types[56]
2519 #define SWIGTYPE_p_wxFlexGridSizer swig_types[57]
2520 #define SWIGTYPE_p_wxFocusEvent swig_types[58]
2521 #define SWIGTYPE_p_wxFont swig_types[59]
2522 #define SWIGTYPE_p_wxFrame swig_types[60]
2523 #define SWIGTYPE_p_wxGBSizerItem swig_types[61]
2524 #define SWIGTYPE_p_wxGIFHandler swig_types[62]
2525 #define SWIGTYPE_p_wxGridBagSizer swig_types[63]
2526 #define SWIGTYPE_p_wxGridSizer swig_types[64]
2527 #define SWIGTYPE_p_wxICOHandler swig_types[65]
2528 #define SWIGTYPE_p_wxIcon swig_types[66]
2529 #define SWIGTYPE_p_wxIconizeEvent swig_types[67]
2530 #define SWIGTYPE_p_wxIdleEvent swig_types[68]
2531 #define SWIGTYPE_p_wxImage swig_types[69]
2532 #define SWIGTYPE_p_wxImageHandler swig_types[70]
2533 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[71]
2534 #define SWIGTYPE_p_wxInitDialogEvent swig_types[72]
2535 #define SWIGTYPE_p_wxJPEGHandler swig_types[73]
2536 #define SWIGTYPE_p_wxJoystick swig_types[74]
2537 #define SWIGTYPE_p_wxJoystickEvent swig_types[75]
2538 #define SWIGTYPE_p_wxKeyEvent swig_types[76]
2539 #define SWIGTYPE_p_wxKillError swig_types[77]
2540 #define SWIGTYPE_p_wxLayoutConstraints swig_types[78]
2541 #define SWIGTYPE_p_wxLog swig_types[79]
2542 #define SWIGTYPE_p_wxLogBuffer swig_types[80]
2543 #define SWIGTYPE_p_wxLogChain swig_types[81]
2544 #define SWIGTYPE_p_wxLogGui swig_types[82]
2545 #define SWIGTYPE_p_wxLogNull swig_types[83]
2546 #define SWIGTYPE_p_wxLogStderr swig_types[84]
2547 #define SWIGTYPE_p_wxLogTextCtrl swig_types[85]
2548 #define SWIGTYPE_p_wxLogWindow swig_types[86]
2549 #define SWIGTYPE_p_wxMaximizeEvent swig_types[87]
2550 #define SWIGTYPE_p_wxMemorySize swig_types[88]
2551 #define SWIGTYPE_p_wxMenu swig_types[89]
2552 #define SWIGTYPE_p_wxMenuBar swig_types[90]
2553 #define SWIGTYPE_p_wxMenuEvent swig_types[91]
2554 #define SWIGTYPE_p_wxMenuItem swig_types[92]
2555 #define SWIGTYPE_p_wxMetafile swig_types[93]
2556 #define SWIGTYPE_p_wxMetafileDataObject swig_types[94]
2557 #define SWIGTYPE_p_wxMimeTypesManager swig_types[95]
2558 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[96]
2559 #define SWIGTYPE_p_wxMouseEvent swig_types[97]
2560 #define SWIGTYPE_p_wxMouseState swig_types[98]
2561 #define SWIGTYPE_p_wxMoveEvent swig_types[99]
2562 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[100]
2563 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
2564 #define SWIGTYPE_p_wxNcPaintEvent swig_types[102]
2565 #define SWIGTYPE_p_wxNotifyEvent swig_types[103]
2566 #define SWIGTYPE_p_wxObject swig_types[104]
2567 #define SWIGTYPE_p_wxOutputStream swig_types[105]
2568 #define SWIGTYPE_p_wxPCXHandler swig_types[106]
2569 #define SWIGTYPE_p_wxPNGHandler swig_types[107]
2570 #define SWIGTYPE_p_wxPNMHandler swig_types[108]
2571 #define SWIGTYPE_p_wxPaintEvent swig_types[109]
2572 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[110]
2573 #define SWIGTYPE_p_wxPaperSize swig_types[111]
2574 #define SWIGTYPE_p_wxPoint swig_types[112]
2575 #define SWIGTYPE_p_wxProcessEvent swig_types[113]
2576 #define SWIGTYPE_p_wxPyApp swig_types[114]
2577 #define SWIGTYPE_p_wxPyArtProvider swig_types[115]
2578 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[116]
2579 #define SWIGTYPE_p_wxPyCommandEvent swig_types[117]
2580 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[118]
2581 #define SWIGTYPE_p_wxPyDropSource swig_types[119]
2582 #define SWIGTYPE_p_wxPyDropTarget swig_types[120]
2583 #define SWIGTYPE_p_wxPyEvent swig_types[121]
2584 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[122]
2585 #define SWIGTYPE_p_wxPyImageHandler swig_types[123]
2586 #define SWIGTYPE_p_wxPyLog swig_types[124]
2587 #define SWIGTYPE_p_wxPyProcess swig_types[125]
2588 #define SWIGTYPE_p_wxPySizer swig_types[126]
2589 #define SWIGTYPE_p_wxPyTextDataObject swig_types[127]
2590 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[128]
2591 #define SWIGTYPE_p_wxPyTimer swig_types[129]
2592 #define SWIGTYPE_p_wxPyTipProvider swig_types[130]
2593 #define SWIGTYPE_p_wxPyValidator swig_types[131]
2594 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[132]
2595 #define SWIGTYPE_p_wxRect swig_types[133]
2596 #define SWIGTYPE_p_wxScrollEvent swig_types[134]
2597 #define SWIGTYPE_p_wxScrollWinEvent swig_types[135]
2598 #define SWIGTYPE_p_wxSetCursorEvent swig_types[136]
2599 #define SWIGTYPE_p_wxShowEvent swig_types[137]
2600 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[138]
2601 #define SWIGTYPE_p_wxSize swig_types[139]
2602 #define SWIGTYPE_p_wxSizeEvent swig_types[140]
2603 #define SWIGTYPE_p_wxSizer swig_types[141]
2604 #define SWIGTYPE_p_wxSizerItem swig_types[142]
2605 #define SWIGTYPE_p_wxSound swig_types[143]
2606 #define SWIGTYPE_p_wxStandardPaths swig_types[144]
2607 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[145]
2608 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[146]
2609 #define SWIGTYPE_p_wxStopWatch swig_types[147]
2610 #define SWIGTYPE_p_wxString swig_types[148]
2611 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[149]
2612 #define SWIGTYPE_p_wxSystemOptions swig_types[150]
2613 #define SWIGTYPE_p_wxSystemSettings swig_types[151]
2614 #define SWIGTYPE_p_wxTIFFHandler swig_types[152]
2615 #define SWIGTYPE_p_wxTextCtrl swig_types[153]
2616 #define SWIGTYPE_p_wxTextDataObject swig_types[154]
2617 #define SWIGTYPE_p_wxTimeSpan swig_types[155]
2618 #define SWIGTYPE_p_wxTimer swig_types[156]
2619 #define SWIGTYPE_p_wxTimerEvent swig_types[157]
2620 #define SWIGTYPE_p_wxTimerRunner swig_types[158]
2621 #define SWIGTYPE_p_wxTipProvider swig_types[159]
2622 #define SWIGTYPE_p_wxToolTip swig_types[160]
2623 #define SWIGTYPE_p_wxURLDataObject swig_types[161]
2624 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[162]
2625 #define SWIGTYPE_p_wxValidator swig_types[163]
2626 #define SWIGTYPE_p_wxVideoMode swig_types[164]
2627 #define SWIGTYPE_p_wxWindow swig_types[165]
2628 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[166]
2629 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[167]
2630 #define SWIGTYPE_p_wxWindowDisabler swig_types[168]
2631 #define SWIGTYPE_p_wxXPMHandler swig_types[169]
2632 static swig_type_info *swig_types[171];
2633 static swig_module_info swig_module = {swig_types, 170, 0, 0, 0, 0};
2634 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2635 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2636
2637 /* -------- TYPES TABLE (END) -------- */
2638
2639 #if (PY_VERSION_HEX <= 0x02000000)
2640 # if !defined(SWIG_PYTHON_CLASSIC)
2641 # error "This python version requires to use swig with the '-classic' option"
2642 # endif
2643 #endif
2644 #if (PY_VERSION_HEX <= 0x02020000)
2645 # error "This python version requires to use swig with the '-nomodern' option"
2646 #endif
2647 #if (PY_VERSION_HEX <= 0x02020000)
2648 # error "This python version requires to use swig with the '-nomodernargs' option"
2649 #endif
2650 #ifndef METH_O
2651 # error "This python version requires to use swig with the '-nofastunpack' option"
2652 #endif
2653
2654 /*-----------------------------------------------
2655 @(target):= _misc_.so
2656 ------------------------------------------------*/
2657 #define SWIG_init init_misc_
2658
2659 #define SWIG_name "_misc_"
2660
2661 #define SWIGVERSION 0x010329
2662
2663
2664 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2665 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2666
2667
2668 #include <stdexcept>
2669
2670
2671 namespace swig {
2672 class PyObject_ptr {
2673 protected:
2674 PyObject *_obj;
2675
2676 public:
2677 PyObject_ptr() :_obj(0)
2678 {
2679 }
2680
2681 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2682 {
2683 Py_XINCREF(_obj);
2684 }
2685
2686 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2687 {
2688 if (initial_ref) Py_XINCREF(_obj);
2689 }
2690
2691 PyObject_ptr & operator=(const PyObject_ptr& item)
2692 {
2693 Py_XINCREF(item._obj);
2694 Py_XDECREF(_obj);
2695 _obj = item._obj;
2696 return *this;
2697 }
2698
2699 ~PyObject_ptr()
2700 {
2701 Py_XDECREF(_obj);
2702 }
2703
2704 operator PyObject *() const
2705 {
2706 return _obj;
2707 }
2708
2709 PyObject *operator->() const
2710 {
2711 return _obj;
2712 }
2713 };
2714 }
2715
2716
2717 namespace swig {
2718 struct PyObject_var : PyObject_ptr {
2719 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2720
2721 PyObject_var & operator = (PyObject* obj)
2722 {
2723 Py_XDECREF(_obj);
2724 _obj = obj;
2725 return *this;
2726 }
2727 };
2728 }
2729
2730
2731 #include "wx/wxPython/wxPython.h"
2732 #include "wx/wxPython/pyclasses.h"
2733 #include "wx/wxPython/pyistream.h"
2734
2735 static const wxString wxPyEmptyString(wxEmptyString);
2736
2737
2738
2739 #define SWIG_From_long PyInt_FromLong
2740
2741
2742 SWIGINTERNINLINE PyObject *
2743 SWIG_From_int (int value)
2744 {
2745 return SWIG_From_long (value);
2746 }
2747
2748
2749 #include <limits.h>
2750 #ifndef LLONG_MIN
2751 # define LLONG_MIN LONG_LONG_MIN
2752 #endif
2753 #ifndef LLONG_MAX
2754 # define LLONG_MAX LONG_LONG_MAX
2755 #endif
2756 #ifndef ULLONG_MAX
2757 # define ULLONG_MAX ULONG_LONG_MAX
2758 #endif
2759
2760
2761 SWIGINTERN int
2762 SWIG_AsVal_long (PyObject* obj, long* val)
2763 {
2764 if (PyNumber_Check(obj)) {
2765 if (val) *val = PyInt_AsLong(obj);
2766 return SWIG_OK;
2767 }
2768 return SWIG_TypeError;
2769 }
2770
2771
2772 SWIGINTERN int
2773 SWIG_AsVal_int (PyObject * obj, int *val)
2774 {
2775 long v;
2776 int res = SWIG_AsVal_long (obj, &v);
2777 if (SWIG_IsOK(res)) {
2778 if ((v < INT_MIN || v > INT_MAX)) {
2779 return SWIG_OverflowError;
2780 } else {
2781 if (val) *val = static_cast< int >(v);
2782 }
2783 }
2784 return res;
2785 }
2786
2787 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2788
2789 #include <wx/stockitem.h>
2790
2791 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2792 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2793 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2794
2795 SWIGINTERN int
2796 SWIG_AsVal_bool (PyObject *obj, bool *val)
2797 {
2798 if (obj == Py_True) {
2799 if (val) *val = true;
2800 return SWIG_OK;
2801 } else if (obj == Py_False) {
2802 if (val) *val = false;
2803 return SWIG_OK;
2804 } else {
2805 long v = 0;
2806 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2807 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2808 return res;
2809 }
2810 }
2811
2812
2813 SWIGINTERN int
2814 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2815 {
2816 long v = 0;
2817 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2818 return SWIG_TypeError;
2819 }
2820 else if (val)
2821 *val = (unsigned long)v;
2822 return SWIG_OK;
2823 }
2824
2825
2826 SWIGINTERNINLINE PyObject*
2827 SWIG_From_unsigned_SS_long (unsigned long value)
2828 {
2829 return (value > LONG_MAX) ?
2830 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2831 }
2832
2833
2834 void* wxGetXDisplay()
2835 {
2836 #ifdef __WXGTK__
2837 return wxGetDisplay();
2838 #else
2839 return NULL;
2840 #endif
2841 }
2842
2843
2844 wxWindow* FindWindowAtPointer() {
2845 wxPoint unused;
2846 return wxFindWindowAtPointer(unused);
2847 }
2848
2849
2850 bool wxThread_IsMain() {
2851 #ifdef WXP_WITH_THREAD
2852 return wxThread::IsMain();
2853 #else
2854 return true;
2855 #endif
2856 }
2857
2858 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2859 delete self;
2860 }
2861
2862 #include <wx/snglinst.h>
2863
2864
2865 #ifdef __WXMSW__
2866 #include <wx/msw/private.h>
2867 #include <wx/dynload.h>
2868 #endif
2869
2870
2871
2872 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2873 #if 0
2874 , int method
2875 #endif
2876 )
2877 {
2878 #ifdef __WXMSW__
2879 #if 0
2880 switch (method)
2881 {
2882 case 1:
2883 // This one only partially works. Appears to be an undocumented
2884 // "standard" convention that not all widgets adhear to. For
2885 // example, for some widgets backgrounds or non-client areas may
2886 // not be painted.
2887 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2888 break;
2889
2890 case 2:
2891 #endif
2892 // This one works much better, nearly all widgets and their
2893 // children are captured correctly[**]. Prior to the big
2894 // background erase changes that Vadim did in 2004-2005 this
2895 // method failed badly on XP with Themes activated, most native
2896 // widgets draw only partially, if at all. Without themes it
2897 // worked just like on Win2k. After those changes this method
2898 // works very well.
2899 //
2900 // ** For example the radio buttons in a wxRadioBox are not its
2901 // children by default, but you can capture it via the panel
2902 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2903 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2904 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2905 PRF_ERASEBKGND | PRF_OWNED );
2906 return true;
2907 #if 0
2908 break;
2909
2910 case 3:
2911 // This one is only defined in the latest SDK and is only
2912 // available on XP. MSDN says it is similar to sending WM_PRINT
2913 // so I expect that it will work similar to the above. Since it
2914 // is avaialble only on XP, it can't be compiled like this and
2915 // will have to be loaded dynamically.
2916 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2917
2918 // fall through
2919
2920 case 4:
2921 // Use PrintWindow if available, or fallback to WM_PRINT
2922 // otherwise. Unfortunately using PrintWindow is even worse than
2923 // WM_PRINT. For most native widgets nothing is drawn to the dc
2924 // at all, with or without Themes.
2925 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2926 static bool s_triedToLoad = false;
2927 static PrintWindow_t pfnPrintWindow = NULL;
2928 if ( !s_triedToLoad )
2929 {
2930
2931 s_triedToLoad = true;
2932 wxDynamicLibrary dllUser32(_T("user32.dll"));
2933 if ( dllUser32.IsLoaded() )
2934 {
2935 wxLogNull nolog; // Don't report errors here
2936 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2937 }
2938 }
2939 if (pfnPrintWindow)
2940 {
2941 //printf("Using PrintWindow\n");
2942 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2943 }
2944 else
2945 {
2946 //printf("Using WM_PRINT\n");
2947 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2948 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2949 PRF_ERASEBKGND | PRF_OWNED );
2950 }
2951 }
2952 #endif // 0
2953 #else
2954 return false;
2955 #endif // __WXMSW__
2956 }
2957
2958
2959
2960 #include <wx/tipdlg.h>
2961
2962
2963 SWIGINTERNINLINE PyObject *
2964 SWIG_From_size_t (size_t value)
2965 {
2966 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2967 }
2968
2969
2970 class wxPyTipProvider : public wxTipProvider {
2971 public:
2972 wxPyTipProvider(size_t currentTip)
2973 : wxTipProvider(currentTip) {}
2974
2975 DEC_PYCALLBACK_STRING__pure(GetTip);
2976 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2977 PYPRIVATE;
2978 };
2979
2980 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2981 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2982
2983
2984 SWIGINTERNINLINE int
2985 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2986 {
2987 unsigned long v;
2988 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2989 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2990 return res;
2991 }
2992
2993
2994 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
2995
2996 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
2997
2998 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
2999 : wxTimer(owner, id)
3000 {
3001 if (owner == NULL)
3002 SetOwner(this);
3003 }
3004
3005
3006 SWIGINTERN swig_type_info*
3007 SWIG_pchar_descriptor()
3008 {
3009 static int init = 0;
3010 static swig_type_info* info = 0;
3011 if (!init) {
3012 info = SWIG_TypeQuery("_p_char");
3013 init = 1;
3014 }
3015 return info;
3016 }
3017
3018
3019 SWIGINTERNINLINE PyObject *
3020 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3021 {
3022 if (carray) {
3023 if (size > INT_MAX) {
3024 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3025 return pchar_descriptor ?
3026 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3027 } else {
3028 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3029 }
3030 } else {
3031 return SWIG_Py_Void();
3032 }
3033 }
3034
3035
3036 SWIGINTERNINLINE PyObject *
3037 SWIG_FromCharPtr(const char *cptr)
3038 {
3039 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3040 }
3041
3042
3043 SWIGINTERN int
3044 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3045 {
3046 unsigned long v;
3047 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3048 if (SWIG_IsOK(res)) {
3049 if ((v > UINT_MAX)) {
3050 return SWIG_OverflowError;
3051 } else {
3052 if (val) *val = static_cast< unsigned int >(v);
3053 }
3054 }
3055 return res;
3056 }
3057
3058 SWIGINTERN wxString wxLog_TimeStamp(){
3059 wxString msg;
3060 wxLog::TimeStamp(&msg);
3061 return msg;
3062 }
3063 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3064 // Make some wrappers that double any % signs so they are 'escaped'
3065 void wxPyLogFatalError(const wxString& msg)
3066 {
3067 wxString m(msg);
3068 m.Replace(wxT("%"), wxT("%%"));
3069 wxLogFatalError(m);
3070 }
3071
3072 void wxPyLogError(const wxString& msg)
3073 {
3074 wxString m(msg);
3075 m.Replace(wxT("%"), wxT("%%"));
3076 wxLogError(m);
3077 }
3078
3079 void wxPyLogWarning(const wxString& msg)
3080 {
3081 wxString m(msg);
3082 m.Replace(wxT("%"), wxT("%%"));
3083 wxLogWarning(m);
3084 }
3085
3086 void wxPyLogMessage(const wxString& msg)
3087 {
3088 wxString m(msg);
3089 m.Replace(wxT("%"), wxT("%%"));
3090 wxLogMessage(m);
3091 }
3092
3093 void wxPyLogInfo(const wxString& msg)
3094 {
3095 wxString m(msg);
3096 m.Replace(wxT("%"), wxT("%%"));
3097 wxLogInfo(m);
3098 }
3099
3100 void wxPyLogDebug(const wxString& msg)
3101 {
3102 wxString m(msg);
3103 m.Replace(wxT("%"), wxT("%%"));
3104 wxLogDebug(m);
3105 }
3106
3107 void wxPyLogVerbose(const wxString& msg)
3108 {
3109 wxString m(msg);
3110 m.Replace(wxT("%"), wxT("%%"));
3111 wxLogVerbose(m);
3112 }
3113
3114 void wxPyLogStatus(const wxString& msg)
3115 {
3116 wxString m(msg);
3117 m.Replace(wxT("%"), wxT("%%"));
3118 wxLogStatus(m);
3119 }
3120
3121 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3122 {
3123 wxString m(msg);
3124 m.Replace(wxT("%"), wxT("%%"));
3125 wxLogStatus(pFrame, m);
3126 }
3127
3128 void wxPyLogSysError(const wxString& msg)
3129 {
3130 wxString m(msg);
3131 m.Replace(wxT("%"), wxT("%%"));
3132 wxLogSysError(m);
3133 }
3134
3135 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3136 {
3137 wxString m(msg);
3138 m.Replace(wxT("%"), wxT("%%"));
3139 wxLogGeneric(level, m);
3140 }
3141
3142 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3143 {
3144 wxString m(msg);
3145 m.Replace(wxT("%"), wxT("%%"));
3146 wxLogTrace(mask, m);
3147 }
3148
3149 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3150 {
3151 wxString m(msg);
3152 m.Replace(wxT("%"), wxT("%%"));
3153 wxLogTrace(mask, m);
3154 }
3155
3156
3157
3158 // A wxLog class that can be derived from in wxPython
3159 class wxPyLog : public wxLog {
3160 public:
3161 wxPyLog() : wxLog() {}
3162
3163 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3164 bool found;
3165 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3166 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3167 PyObject* s = wx2PyString(szString);
3168 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3169 Py_DECREF(s);
3170 }
3171 wxPyEndBlockThreads(blocked);
3172 if (! found)
3173 wxLog::DoLog(level, szString, t);
3174 }
3175
3176 virtual void DoLogString(const wxChar *szString, time_t t) {
3177 bool found;
3178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3179 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3180 PyObject* s = wx2PyString(szString);
3181 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3182 Py_DECREF(s);
3183 }
3184 wxPyEndBlockThreads(blocked);
3185 if (! found)
3186 wxLog::DoLogString(szString, t);
3187 }
3188
3189 DEC_PYCALLBACK_VOID_(Flush);
3190 PYPRIVATE;
3191 };
3192 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3193
3194
3195
3196
3197 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3198
3199
3200 #include <wx/joystick.h>
3201
3202
3203 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3204 // A C++ stub class for wxJoystick for platforms that don't have it.
3205 class wxJoystick : public wxObject {
3206 public:
3207 wxJoystick(int joystick = wxJOYSTICK1) {
3208 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3209 PyErr_SetString(PyExc_NotImplementedError,
3210 "wxJoystick is not available on this platform.");
3211 wxPyEndBlockThreads(blocked);
3212 }
3213 wxPoint GetPosition() { return wxPoint(-1,-1); }
3214 int GetZPosition() { return -1; }
3215 int GetButtonState() { return -1; }
3216 int GetPOVPosition() { return -1; }
3217 int GetPOVCTSPosition() { return -1; }
3218 int GetRudderPosition() { return -1; }
3219 int GetUPosition() { return -1; }
3220 int GetVPosition() { return -1; }
3221 int GetMovementThreshold() { return -1; }
3222 void SetMovementThreshold(int threshold) {}
3223
3224 bool IsOk(void) { return false; }
3225 int GetNumberJoysticks() { return -1; }
3226 int GetManufacturerId() { return -1; }
3227 int GetProductId() { return -1; }
3228 wxString GetProductName() { return wxEmptyString; }
3229 int GetXMin() { return -1; }
3230 int GetYMin() { return -1; }
3231 int GetZMin() { return -1; }
3232 int GetXMax() { return -1; }
3233 int GetYMax() { return -1; }
3234 int GetZMax() { return -1; }
3235 int GetNumberButtons() { return -1; }
3236 int GetNumberAxes() { return -1; }
3237 int GetMaxButtons() { return -1; }
3238 int GetMaxAxes() { return -1; }
3239 int GetPollingMin() { return -1; }
3240 int GetPollingMax() { return -1; }
3241 int GetRudderMin() { return -1; }
3242 int GetRudderMax() { return -1; }
3243 int GetUMin() { return -1; }
3244 int GetUMax() { return -1; }
3245 int GetVMin() { return -1; }
3246 int GetVMax() { return -1; }
3247
3248 bool HasRudder() { return false; }
3249 bool HasZ() { return false; }
3250 bool HasU() { return false; }
3251 bool HasV() { return false; }
3252 bool HasPOV() { return false; }
3253 bool HasPOV4Dir() { return false; }
3254 bool HasPOVCTS() { return false; }
3255
3256 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3257 bool ReleaseCapture() { return false; }
3258 };
3259 #endif
3260
3261
3262 #include <wx/sound.h>
3263
3264
3265 #if !wxUSE_SOUND
3266 // A C++ stub class for wxWave for platforms that don't have it.
3267 class wxSound : public wxObject
3268 {
3269 public:
3270 wxSound() {
3271 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3272 PyErr_SetString(PyExc_NotImplementedError,
3273 "wxSound is not available on this platform.");
3274 wxPyEndBlockThreads(blocked);
3275 }
3276 wxSound(const wxString&/*, bool*/) {
3277 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3278 PyErr_SetString(PyExc_NotImplementedError,
3279 "wxSound is not available on this platform.");
3280 wxPyEndBlockThreads(blocked);
3281 }
3282 wxSound(int, const wxByte*) {
3283 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3284 PyErr_SetString(PyExc_NotImplementedError,
3285 "wxSound is not available on this platform.");
3286 wxPyEndBlockThreads(blocked);
3287 }
3288
3289 ~wxSound() {};
3290
3291 bool Create(const wxString&/*, bool*/) { return false; }
3292 bool Create(int, const wxByte*) { return false; };
3293 bool IsOk() { return false; };
3294 bool Play(unsigned) const { return false; }
3295 static bool Play(const wxString&, unsigned) { return false; }
3296 static void Stop() {}
3297 };
3298
3299 #endif
3300
3301 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3302 if (fileName.Length() == 0)
3303 return new wxSound;
3304 else
3305 return new wxSound(fileName);
3306 }
3307 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3308 unsigned char* buffer; int size;
3309 wxSound *sound = NULL;
3310
3311 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3312 if (!PyArg_Parse(data, "t#", &buffer, &size))
3313 goto done;
3314 sound = new wxSound(size, buffer);
3315 done:
3316 wxPyEndBlockThreads(blocked);
3317 return sound;
3318 }
3319 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3320 #ifndef __WXMAC__
3321 unsigned char* buffer;
3322 int size;
3323 bool rv = false;
3324
3325 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3326 if (!PyArg_Parse(data, "t#", &buffer, &size))
3327 goto done;
3328 rv = self->Create(size, buffer);
3329 done:
3330 wxPyEndBlockThreads(blocked);
3331 return rv;
3332 #else
3333 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3334 PyErr_SetString(PyExc_NotImplementedError,
3335 "Create from data is not available on this platform.");
3336 wxPyEndBlockThreads(blocked);
3337 return false;
3338 #endif
3339 }
3340
3341 #include <wx/mimetype.h>
3342
3343 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3344 wxString str;
3345 if (self->GetMimeType(&str))
3346 return wx2PyString(str);
3347 else
3348 RETURN_NONE();
3349 }
3350 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3351 wxArrayString arr;
3352 if (self->GetMimeTypes(arr))
3353 return wxArrayString2PyList_helper(arr);
3354 else
3355 RETURN_NONE();
3356 }
3357 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3358 wxArrayString arr;
3359 if (self->GetExtensions(arr))
3360 return wxArrayString2PyList_helper(arr);
3361 else
3362 RETURN_NONE();
3363 }
3364 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3365 wxIconLocation loc;
3366 if (self->GetIcon(&loc))
3367 return new wxIcon(loc);
3368 else
3369 return NULL;
3370 }
3371 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3372 wxIconLocation loc;
3373 if (self->GetIcon(&loc)) {
3374 wxString iconFile = loc.GetFileName();
3375 int iconIndex = -1;
3376
3377 iconIndex = loc.GetIndex();
3378
3379 // Make a tuple and put the values in it
3380 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3381 PyObject* tuple = PyTuple_New(3);
3382 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3383 wxT("wxIcon"), true));
3384 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3385 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3386 wxPyEndBlockThreads(blocked);
3387 return tuple;
3388 }
3389 else
3390 RETURN_NONE();
3391 }
3392 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3393 wxString str;
3394 if (self->GetDescription(&str))
3395 return wx2PyString(str);
3396 else
3397 RETURN_NONE();
3398 }
3399 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3400 wxString str;
3401 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3402 return wx2PyString(str);
3403 else
3404 RETURN_NONE();
3405 }
3406 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3407 wxString str;
3408 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3409 return wx2PyString(str);
3410 else
3411 RETURN_NONE();
3412 }
3413 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3414 wxArrayString verbs;
3415 wxArrayString commands;
3416 if (self->GetAllCommands(&verbs, &commands,
3417 wxFileType::MessageParameters(filename, mimetype))) {
3418 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3419 PyObject* tuple = PyTuple_New(2);
3420 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3421 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3422 wxPyEndBlockThreads(blocked);
3423 return tuple;
3424 }
3425 else
3426 RETURN_NONE();
3427 }
3428 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3429 return wxFileType::ExpandCommand(command,
3430 wxFileType::MessageParameters(filename, mimetype));
3431 }
3432 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3433 wxArrayString arr;
3434 self->EnumAllFileTypes(arr);
3435 return wxArrayString2PyList_helper(arr);
3436 }
3437
3438 #include <wx/artprov.h>
3439
3440 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3441 static const wxString wxPyART_MENU(wxART_MENU);
3442 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3443 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3444 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3445 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3446 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3447 static const wxString wxPyART_OTHER(wxART_OTHER);
3448 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3449 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3450 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3451 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3452 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3453 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3454 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3455 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3456 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3457 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3458 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3459 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3460 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3461 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3462 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3463 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3464 static const wxString wxPyART_PRINT(wxART_PRINT);
3465 static const wxString wxPyART_HELP(wxART_HELP);
3466 static const wxString wxPyART_TIP(wxART_TIP);
3467 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3468 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3469 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3470 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3471 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3472 static const wxString wxPyART_CDROM(wxART_CDROM);
3473 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3474 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3475 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3476 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3477 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3478 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3479 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3480 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3481 static const wxString wxPyART_ERROR(wxART_ERROR);
3482 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3483 static const wxString wxPyART_WARNING(wxART_WARNING);
3484 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3485 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3486 static const wxString wxPyART_COPY(wxART_COPY);
3487 static const wxString wxPyART_CUT(wxART_CUT);
3488 static const wxString wxPyART_PASTE(wxART_PASTE);
3489 static const wxString wxPyART_DELETE(wxART_DELETE);
3490 static const wxString wxPyART_NEW(wxART_NEW);
3491 static const wxString wxPyART_UNDO(wxART_UNDO);
3492 static const wxString wxPyART_REDO(wxART_REDO);
3493 static const wxString wxPyART_QUIT(wxART_QUIT);
3494 static const wxString wxPyART_FIND(wxART_FIND);
3495 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3496 // Python aware wxArtProvider
3497 class wxPyArtProvider : public wxArtProvider {
3498 public:
3499
3500 virtual wxBitmap CreateBitmap(const wxArtID& id,
3501 const wxArtClient& client,
3502 const wxSize& size) {
3503 wxBitmap rval = wxNullBitmap;
3504 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3505 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3506 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3507 PyObject* ro;
3508 wxBitmap* ptr;
3509 PyObject* s1, *s2;
3510 s1 = wx2PyString(id);
3511 s2 = wx2PyString(client);
3512 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3513 Py_DECREF(so);
3514 Py_DECREF(s1);
3515 Py_DECREF(s2);
3516 if (ro) {
3517 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3518 rval = *ptr;
3519 Py_DECREF(ro);
3520 }
3521 }
3522 wxPyEndBlockThreads(blocked);
3523 return rval;
3524 }
3525
3526 PYPRIVATE;
3527 };
3528
3529 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3530
3531
3532
3533 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3534 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3535 PyObject* ret = PyTuple_New(3);
3536 if (ret) {
3537 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3538 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3539 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3540 }
3541 wxPyEndBlockThreads(blocked);
3542 return ret;
3543 }
3544
3545 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3546 bool cont;
3547 long index = 0;
3548 wxString value;
3549
3550 cont = self->GetFirstGroup(value, index);
3551 return __EnumerationHelper(cont, value, index);
3552 }
3553 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3554 bool cont;
3555 wxString value;
3556
3557 cont = self->GetNextGroup(value, index);
3558 return __EnumerationHelper(cont, value, index);
3559 }
3560 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3561 bool cont;
3562 long index = 0;
3563 wxString value;
3564
3565 cont = self->GetFirstEntry(value, index);
3566 return __EnumerationHelper(cont, value, index);
3567 }
3568 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3569 bool cont;
3570 wxString value;
3571
3572 cont = self->GetNextEntry(value, index);
3573 return __EnumerationHelper(cont, value, index);
3574 }
3575 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3576 long rv;
3577 self->Read(key, &rv, defaultVal);
3578 return rv;
3579 }
3580
3581 SWIGINTERN int
3582 SWIG_AsVal_double (PyObject *obj, double* val)
3583 {
3584 if (PyNumber_Check(obj)) {
3585 if (val) *val = PyFloat_AsDouble(obj);
3586 return SWIG_OK;
3587 }
3588 return SWIG_TypeError;
3589 }
3590
3591 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3592 double rv;
3593 self->Read(key, &rv, defaultVal);
3594 return rv;
3595 }
3596
3597 #define SWIG_From_double PyFloat_FromDouble
3598
3599 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3600 bool rv;
3601 self->Read(key, &rv, defaultVal);
3602 return rv;
3603 }
3604
3605 #include <wx/datetime.h>
3606
3607 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3608 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3609
3610 #define LOCAL_TZ wxDateTime::Local
3611
3612 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3613 wxString am;
3614 wxString pm;
3615 wxDateTime::GetAmPmStrings(&am, &pm);
3616 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3617 PyObject* tup = PyTuple_New(2);
3618 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3619 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3620 wxPyEndBlockThreads(blocked);
3621 return tup;
3622 }
3623
3624 SWIGINTERNINLINE PyObject *
3625 SWIG_From_unsigned_SS_int (unsigned int value)
3626 {
3627 return SWIG_From_unsigned_SS_long (value);
3628 }
3629
3630 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3631 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3632 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3633 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3634 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3635 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3636 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3637 return (*self < *other);
3638 }
3639 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3640 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3641 return (*self <= *other);
3642 }
3643 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3644 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3645 return (*self > *other);
3646 }
3647 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3648 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3649 return (*self >= *other);
3650 }
3651 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3652 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3653 return (*self == *other);
3654 }
3655 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3656 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3657 return (*self != *other);
3658 }
3659 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3660 const wxChar* rv;
3661 const wxChar* _date = date;
3662 rv = self->ParseRfc822Date(_date);
3663 if (rv == NULL) return -1;
3664 return rv - _date;
3665 }
3666 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3667 const wxChar* rv;
3668 const wxChar* _date = date;
3669 rv = self->ParseFormat(_date, format, dateDef);
3670 if (rv == NULL) return -1;
3671 return rv - _date;
3672 }
3673 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3674 const wxChar* rv;
3675 const wxChar* _datetime = datetime;
3676 rv = self->ParseDateTime(_datetime);
3677 if (rv == NULL) return -1;
3678 return rv - _datetime;
3679 }
3680 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3681 const wxChar* rv;
3682 const wxChar* _date = date;
3683 rv = self->ParseDate(_date);
3684 if (rv == NULL) return -1;
3685 return rv - _date;
3686 }
3687 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3688 const wxChar* rv;
3689 const wxChar* _time = time;
3690 rv = self->ParseTime(_time);
3691 if (rv == NULL) return -1;
3692 return rv - _time;
3693 }
3694 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3695 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3696 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3697 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3698 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3699 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3700 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3701 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3702 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3703 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3704 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3705 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3706 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3707 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3708 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3709 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3710
3711 #include <wx/dataobj.h>
3712
3713 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3714 size_t count = self->GetFormatCount(dir);
3715 wxDataFormat* formats = new wxDataFormat[count];
3716 self->GetAllFormats(formats, dir);
3717
3718 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3719 PyObject* list = PyList_New(count);
3720 for (size_t i=0; i<count; i++) {
3721 wxDataFormat* format = new wxDataFormat(formats[i]);
3722 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3723 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3724 }
3725 wxPyEndBlockThreads(blocked);
3726 delete [] formats;
3727 return list;
3728 }
3729 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3730 PyObject* rval = NULL;
3731 size_t size = self->GetDataSize(format);
3732 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3733 if (size) {
3734 char* buf = new char[size];
3735 if (self->GetDataHere(format, buf))
3736 rval = PyString_FromStringAndSize(buf, size);
3737 delete [] buf;
3738 }
3739 if (! rval) {
3740 rval = Py_None;
3741 Py_INCREF(rval);
3742 }
3743 wxPyEndBlockThreads(blocked);
3744 return rval;
3745 }
3746 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3747 bool rval;
3748 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3749 if (PyString_Check(data)) {
3750 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3751 }
3752 else {
3753 // raise a TypeError if not a string
3754 PyErr_SetString(PyExc_TypeError, "String expected.");
3755 rval = false;
3756 }
3757 wxPyEndBlockThreads(blocked);
3758 return rval;
3759 }
3760 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3761 PyObject* rval = NULL;
3762 size_t size = self->GetDataSize();
3763 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3764 if (size) {
3765 char* buf = new char[size];
3766 if (self->GetDataHere(buf))
3767 rval = PyString_FromStringAndSize(buf, size);
3768 delete [] buf;
3769 }
3770 if (! rval) {
3771 rval = Py_None;
3772 Py_INCREF(rval);
3773 }
3774 wxPyEndBlockThreads(blocked);
3775 return rval;
3776 }
3777 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3778 bool rval;
3779 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3780 if (PyString_Check(data)) {
3781 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3782 }
3783 else {
3784 // raise a TypeError if not a string
3785 PyErr_SetString(PyExc_TypeError, "String expected.");
3786 rval = false;
3787 }
3788 wxPyEndBlockThreads(blocked);
3789 return rval;
3790 }
3791 // Create a new class for wxPython to use
3792 class wxPyDataObjectSimple : public wxDataObjectSimple {
3793 public:
3794 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3795 : wxDataObjectSimple(format) {}
3796
3797 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3798 bool GetDataHere(void *buf) const;
3799 bool SetData(size_t len, const void *buf) const;
3800 PYPRIVATE;
3801 };
3802
3803 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3804
3805 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3806 // We need to get the data for this object and write it to buf. I think
3807 // the best way to do this for wxPython is to have the Python method
3808 // return either a string or None and then act appropriately with the
3809 // C++ version.
3810
3811 bool rval = false;
3812 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3813 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3814 PyObject* ro;
3815 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3816 if (ro) {
3817 rval = (ro != Py_None && PyString_Check(ro));
3818 if (rval)
3819 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3820 Py_DECREF(ro);
3821 }
3822 }
3823 wxPyEndBlockThreads(blocked);
3824 return rval;
3825 }
3826
3827 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
3828 // For this one we simply need to make a string from buf and len
3829 // and send it to the Python method.
3830 bool rval = false;
3831 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3832 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3833 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3834 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3835 Py_DECREF(data);
3836 }
3837 wxPyEndBlockThreads(blocked);
3838 return rval;
3839 }
3840
3841 // Create a new class for wxPython to use
3842 class wxPyTextDataObject : public wxTextDataObject {
3843 public:
3844 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3845 : wxTextDataObject(text) {}
3846
3847 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3848 DEC_PYCALLBACK_STRING__const(GetText);
3849 DEC_PYCALLBACK__STRING(SetText);
3850 PYPRIVATE;
3851 };
3852
3853 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3854 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3855 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3856
3857
3858 // Create a new class for wxPython to use
3859 class wxPyBitmapDataObject : public wxBitmapDataObject {
3860 public:
3861 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3862 : wxBitmapDataObject(bitmap) {}
3863
3864 wxBitmap GetBitmap() const;
3865 void SetBitmap(const wxBitmap& bitmap);
3866 PYPRIVATE;
3867 };
3868
3869 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3870 wxBitmap* rval = &wxNullBitmap;
3871 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3872 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3873 PyObject* ro;
3874 wxBitmap* ptr;
3875 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3876 if (ro) {
3877 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3878 rval = ptr;
3879 Py_DECREF(ro);
3880 }
3881 }
3882 wxPyEndBlockThreads(blocked);
3883 return *rval;
3884 }
3885
3886 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3887 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3888 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3889 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3890 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3891 Py_DECREF(bo);
3892 }
3893 wxPyEndBlockThreads(blocked);
3894 }
3895
3896 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3897 return new wxCustomDataObject(wxDataFormat(formatName));
3898 }
3899 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3900 bool rval;
3901 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3902 if (PyString_Check(data)) {
3903 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3904 }
3905 else {
3906 // raise a TypeError if not a string
3907 PyErr_SetString(PyExc_TypeError, "String expected.");
3908 rval = false;
3909 }
3910 wxPyEndBlockThreads(blocked);
3911 return rval;
3912 }
3913 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3914 PyObject* obj;
3915 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3916 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3917 wxPyEndBlockThreads(blocked);
3918 return obj;
3919 }
3920
3921 #include <wx/metafile.h>
3922
3923
3924 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3925
3926
3927 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3928 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3929 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3930 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3931 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3932
3933
3934 class wxPyTextDropTarget : public wxTextDropTarget {
3935 public:
3936 wxPyTextDropTarget() {}
3937
3938 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3939
3940 DEC_PYCALLBACK__(OnLeave);
3941 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3942 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3943 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3944 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3945
3946 PYPRIVATE;
3947 };
3948
3949 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3950 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3951 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3952 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3953 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3954 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3955
3956
3957
3958 class wxPyFileDropTarget : public wxFileDropTarget {
3959 public:
3960 wxPyFileDropTarget() {}
3961
3962 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3963
3964 DEC_PYCALLBACK__(OnLeave);
3965 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3966 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3967 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3968 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3969
3970 PYPRIVATE;
3971 };
3972
3973 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3974 const wxArrayString& filenames) {
3975 bool rval = false;
3976 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3977 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3978 PyObject* list = wxArrayString2PyList_helper(filenames);
3979 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3980 Py_DECREF(list);
3981 }
3982 wxPyEndBlockThreads(blocked);
3983 return rval;
3984 }
3985
3986
3987
3988 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3989 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3990 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3991 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
3992 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
3993
3994
3995
3996
3997 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
3998
3999 #include <wx/display.h>
4000
4001 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4002 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4003
4004 #if !wxUSE_DISPLAY
4005 const wxVideoMode wxDefaultVideoMode;
4006 #endif
4007
4008 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4009 #if wxUSE_DISPLAY
4010 PyObject* pyList = NULL;
4011 wxArrayVideoModes arr = self->GetModes(mode);
4012 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4013 pyList = PyList_New(0);
4014 for (size_t i=0; i < arr.GetCount(); i++)
4015 {
4016 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4017 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4018 PyList_Append(pyList, pyObj);
4019 Py_DECREF(pyObj);
4020 }
4021 wxPyEndBlockThreads(blocked);
4022 return pyList;
4023 #else
4024 wxPyRaiseNotImplemented();
4025 return NULL;
4026 #endif
4027 }
4028 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4029 #if wxUSE_DISPLAY
4030 return self->GetCurrentMode();
4031 #else
4032 wxPyRaiseNotImplemented();
4033 return wxDefaultVideoMode;
4034 #endif
4035 }
4036 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4037 #if wxUSE_DISPLAY
4038 return self->ChangeMode(mode);
4039 #else
4040 wxPyRaiseNotImplemented();
4041 return false;
4042 #endif
4043 }
4044 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4045 #if wxUSE_DISPLAY
4046 self->ResetMode();
4047 #else
4048 wxPyRaiseNotImplemented();
4049 #endif
4050 }
4051
4052 #include <wx/stdpaths.h>
4053
4054 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4055 return (wxStandardPaths*) &wxStandardPaths::Get();
4056 }
4057 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4058 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4059 #ifdef __cplusplus
4060 extern "C" {
4061 #endif
4062 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4063 PyObject *resultobj = 0;
4064 wxSystemColour arg1 ;
4065 wxColour result;
4066 int val1 ;
4067 int ecode1 = 0 ;
4068 PyObject * obj0 = 0 ;
4069 char * kwnames[] = {
4070 (char *) "index", NULL
4071 };
4072
4073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4074 ecode1 = SWIG_AsVal_int(obj0, &val1);
4075 if (!SWIG_IsOK(ecode1)) {
4076 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4077 }
4078 arg1 = static_cast< wxSystemColour >(val1);
4079 {
4080 if (!wxPyCheckForApp()) SWIG_fail;
4081 PyThreadState* __tstate = wxPyBeginAllowThreads();
4082 result = wxSystemSettings::GetColour(arg1);
4083 wxPyEndAllowThreads(__tstate);
4084 if (PyErr_Occurred()) SWIG_fail;
4085 }
4086 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4087 return resultobj;
4088 fail:
4089 return NULL;
4090 }
4091
4092
4093 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4094 PyObject *resultobj = 0;
4095 wxSystemFont arg1 ;
4096 wxFont result;
4097 int val1 ;
4098 int ecode1 = 0 ;
4099 PyObject * obj0 = 0 ;
4100 char * kwnames[] = {
4101 (char *) "index", NULL
4102 };
4103
4104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4105 ecode1 = SWIG_AsVal_int(obj0, &val1);
4106 if (!SWIG_IsOK(ecode1)) {
4107 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4108 }
4109 arg1 = static_cast< wxSystemFont >(val1);
4110 {
4111 if (!wxPyCheckForApp()) SWIG_fail;
4112 PyThreadState* __tstate = wxPyBeginAllowThreads();
4113 result = wxSystemSettings::GetFont(arg1);
4114 wxPyEndAllowThreads(__tstate);
4115 if (PyErr_Occurred()) SWIG_fail;
4116 }
4117 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4118 return resultobj;
4119 fail:
4120 return NULL;
4121 }
4122
4123
4124 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4125 PyObject *resultobj = 0;
4126 wxSystemMetric arg1 ;
4127 wxWindow *arg2 = (wxWindow *) NULL ;
4128 int result;
4129 int val1 ;
4130 int ecode1 = 0 ;
4131 void *argp2 = 0 ;
4132 int res2 = 0 ;
4133 PyObject * obj0 = 0 ;
4134 PyObject * obj1 = 0 ;
4135 char * kwnames[] = {
4136 (char *) "index",(char *) "win", NULL
4137 };
4138
4139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4140 ecode1 = SWIG_AsVal_int(obj0, &val1);
4141 if (!SWIG_IsOK(ecode1)) {
4142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4143 }
4144 arg1 = static_cast< wxSystemMetric >(val1);
4145 if (obj1) {
4146 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4147 if (!SWIG_IsOK(res2)) {
4148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4149 }
4150 arg2 = reinterpret_cast< wxWindow * >(argp2);
4151 }
4152 {
4153 if (!wxPyCheckForApp()) SWIG_fail;
4154 PyThreadState* __tstate = wxPyBeginAllowThreads();
4155 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4156 wxPyEndAllowThreads(__tstate);
4157 if (PyErr_Occurred()) SWIG_fail;
4158 }
4159 resultobj = SWIG_From_int(static_cast< int >(result));
4160 return resultobj;
4161 fail:
4162 return NULL;
4163 }
4164
4165
4166 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4167 PyObject *resultobj = 0;
4168 wxSystemFeature arg1 ;
4169 bool result;
4170 int val1 ;
4171 int ecode1 = 0 ;
4172 PyObject * obj0 = 0 ;
4173 char * kwnames[] = {
4174 (char *) "index", NULL
4175 };
4176
4177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4178 ecode1 = SWIG_AsVal_int(obj0, &val1);
4179 if (!SWIG_IsOK(ecode1)) {
4180 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4181 }
4182 arg1 = static_cast< wxSystemFeature >(val1);
4183 {
4184 if (!wxPyCheckForApp()) SWIG_fail;
4185 PyThreadState* __tstate = wxPyBeginAllowThreads();
4186 result = (bool)wxSystemSettings::HasFeature(arg1);
4187 wxPyEndAllowThreads(__tstate);
4188 if (PyErr_Occurred()) SWIG_fail;
4189 }
4190 {
4191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4192 }
4193 return resultobj;
4194 fail:
4195 return NULL;
4196 }
4197
4198
4199 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4200 PyObject *resultobj = 0;
4201 wxSystemScreenType result;
4202
4203 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4204 {
4205 if (!wxPyCheckForApp()) SWIG_fail;
4206 PyThreadState* __tstate = wxPyBeginAllowThreads();
4207 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4208 wxPyEndAllowThreads(__tstate);
4209 if (PyErr_Occurred()) SWIG_fail;
4210 }
4211 resultobj = SWIG_From_int(static_cast< int >(result));
4212 return resultobj;
4213 fail:
4214 return NULL;
4215 }
4216
4217
4218 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4219 PyObject *resultobj = 0;
4220 wxSystemScreenType arg1 ;
4221 int val1 ;
4222 int ecode1 = 0 ;
4223 PyObject * obj0 = 0 ;
4224 char * kwnames[] = {
4225 (char *) "screen", NULL
4226 };
4227
4228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4229 ecode1 = SWIG_AsVal_int(obj0, &val1);
4230 if (!SWIG_IsOK(ecode1)) {
4231 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4232 }
4233 arg1 = static_cast< wxSystemScreenType >(val1);
4234 {
4235 if (!wxPyCheckForApp()) SWIG_fail;
4236 PyThreadState* __tstate = wxPyBeginAllowThreads();
4237 wxSystemSettings::SetScreenType(arg1);
4238 wxPyEndAllowThreads(__tstate);
4239 if (PyErr_Occurred()) SWIG_fail;
4240 }
4241 resultobj = SWIG_Py_Void();
4242 return resultobj;
4243 fail:
4244 return NULL;
4245 }
4246
4247
4248 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4249 PyObject *obj;
4250 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4251 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4252 return SWIG_Py_Void();
4253 }
4254
4255 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4256 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4257 return 1;
4258 }
4259
4260
4261 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4262 PyObject *pyobj = 0;
4263
4264 {
4265 #if wxUSE_UNICODE
4266 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4267 #else
4268 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4269 #endif
4270 }
4271 return pyobj;
4272 }
4273
4274
4275 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4276 PyObject *resultobj = 0;
4277 wxSystemOptions *result = 0 ;
4278
4279 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4280 {
4281 PyThreadState* __tstate = wxPyBeginAllowThreads();
4282 result = (wxSystemOptions *)new wxSystemOptions();
4283 wxPyEndAllowThreads(__tstate);
4284 if (PyErr_Occurred()) SWIG_fail;
4285 }
4286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4287 return resultobj;
4288 fail:
4289 return NULL;
4290 }
4291
4292
4293 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4294 PyObject *resultobj = 0;
4295 wxString *arg1 = 0 ;
4296 wxString *arg2 = 0 ;
4297 bool temp1 = false ;
4298 bool temp2 = false ;
4299 PyObject * obj0 = 0 ;
4300 PyObject * obj1 = 0 ;
4301 char * kwnames[] = {
4302 (char *) "name",(char *) "value", NULL
4303 };
4304
4305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4306 {
4307 arg1 = wxString_in_helper(obj0);
4308 if (arg1 == NULL) SWIG_fail;
4309 temp1 = true;
4310 }
4311 {
4312 arg2 = wxString_in_helper(obj1);
4313 if (arg2 == NULL) SWIG_fail;
4314 temp2 = true;
4315 }
4316 {
4317 PyThreadState* __tstate = wxPyBeginAllowThreads();
4318 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4319 wxPyEndAllowThreads(__tstate);
4320 if (PyErr_Occurred()) SWIG_fail;
4321 }
4322 resultobj = SWIG_Py_Void();
4323 {
4324 if (temp1)
4325 delete arg1;
4326 }
4327 {
4328 if (temp2)
4329 delete arg2;
4330 }
4331 return resultobj;
4332 fail:
4333 {
4334 if (temp1)
4335 delete arg1;
4336 }
4337 {
4338 if (temp2)
4339 delete arg2;
4340 }
4341 return NULL;
4342 }
4343
4344
4345 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4346 PyObject *resultobj = 0;
4347 wxString *arg1 = 0 ;
4348 int arg2 ;
4349 bool temp1 = false ;
4350 int val2 ;
4351 int ecode2 = 0 ;
4352 PyObject * obj0 = 0 ;
4353 PyObject * obj1 = 0 ;
4354 char * kwnames[] = {
4355 (char *) "name",(char *) "value", NULL
4356 };
4357
4358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4359 {
4360 arg1 = wxString_in_helper(obj0);
4361 if (arg1 == NULL) SWIG_fail;
4362 temp1 = true;
4363 }
4364 ecode2 = SWIG_AsVal_int(obj1, &val2);
4365 if (!SWIG_IsOK(ecode2)) {
4366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4367 }
4368 arg2 = static_cast< int >(val2);
4369 {
4370 PyThreadState* __tstate = wxPyBeginAllowThreads();
4371 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4372 wxPyEndAllowThreads(__tstate);
4373 if (PyErr_Occurred()) SWIG_fail;
4374 }
4375 resultobj = SWIG_Py_Void();
4376 {
4377 if (temp1)
4378 delete arg1;
4379 }
4380 return resultobj;
4381 fail:
4382 {
4383 if (temp1)
4384 delete arg1;
4385 }
4386 return NULL;
4387 }
4388
4389
4390 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4391 PyObject *resultobj = 0;
4392 wxString *arg1 = 0 ;
4393 wxString result;
4394 bool temp1 = false ;
4395 PyObject * obj0 = 0 ;
4396 char * kwnames[] = {
4397 (char *) "name", NULL
4398 };
4399
4400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4401 {
4402 arg1 = wxString_in_helper(obj0);
4403 if (arg1 == NULL) SWIG_fail;
4404 temp1 = true;
4405 }
4406 {
4407 PyThreadState* __tstate = wxPyBeginAllowThreads();
4408 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4409 wxPyEndAllowThreads(__tstate);
4410 if (PyErr_Occurred()) SWIG_fail;
4411 }
4412 {
4413 #if wxUSE_UNICODE
4414 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4415 #else
4416 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4417 #endif
4418 }
4419 {
4420 if (temp1)
4421 delete arg1;
4422 }
4423 return resultobj;
4424 fail:
4425 {
4426 if (temp1)
4427 delete arg1;
4428 }
4429 return NULL;
4430 }
4431
4432
4433 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4434 PyObject *resultobj = 0;
4435 wxString *arg1 = 0 ;
4436 int result;
4437 bool temp1 = false ;
4438 PyObject * obj0 = 0 ;
4439 char * kwnames[] = {
4440 (char *) "name", NULL
4441 };
4442
4443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4444 {
4445 arg1 = wxString_in_helper(obj0);
4446 if (arg1 == NULL) SWIG_fail;
4447 temp1 = true;
4448 }
4449 {
4450 PyThreadState* __tstate = wxPyBeginAllowThreads();
4451 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4452 wxPyEndAllowThreads(__tstate);
4453 if (PyErr_Occurred()) SWIG_fail;
4454 }
4455 resultobj = SWIG_From_int(static_cast< int >(result));
4456 {
4457 if (temp1)
4458 delete arg1;
4459 }
4460 return resultobj;
4461 fail:
4462 {
4463 if (temp1)
4464 delete arg1;
4465 }
4466 return NULL;
4467 }
4468
4469
4470 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4471 PyObject *resultobj = 0;
4472 wxString *arg1 = 0 ;
4473 bool result;
4474 bool temp1 = false ;
4475 PyObject * obj0 = 0 ;
4476 char * kwnames[] = {
4477 (char *) "name", NULL
4478 };
4479
4480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4481 {
4482 arg1 = wxString_in_helper(obj0);
4483 if (arg1 == NULL) SWIG_fail;
4484 temp1 = true;
4485 }
4486 {
4487 PyThreadState* __tstate = wxPyBeginAllowThreads();
4488 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4489 wxPyEndAllowThreads(__tstate);
4490 if (PyErr_Occurred()) SWIG_fail;
4491 }
4492 {
4493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4494 }
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_IsFalse(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_IsFalse",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::IsFalse((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 *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4549 PyObject *obj;
4550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4551 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4552 return SWIG_Py_Void();
4553 }
4554
4555 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4556 return SWIG_Python_InitShadowInstance(args);
4557 }
4558
4559 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4560 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4561 return 1;
4562 }
4563
4564
4565 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4566 PyObject *pyobj = 0;
4567
4568 {
4569 #if wxUSE_UNICODE
4570 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4571 #else
4572 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4573 #endif
4574 }
4575 return pyobj;
4576 }
4577
4578
4579 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4580 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4581 return 1;
4582 }
4583
4584
4585 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4586 PyObject *pyobj = 0;
4587
4588 {
4589 #if wxUSE_UNICODE
4590 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4591 #else
4592 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4593 #endif
4594 }
4595 return pyobj;
4596 }
4597
4598
4599 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4600 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4601 return 1;
4602 }
4603
4604
4605 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4606 PyObject *pyobj = 0;
4607
4608 {
4609 #if wxUSE_UNICODE
4610 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4611 #else
4612 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4613 #endif
4614 }
4615 return pyobj;
4616 }
4617
4618
4619 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4620 PyObject *resultobj = 0;
4621 long result;
4622
4623 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4624 {
4625 PyThreadState* __tstate = wxPyBeginAllowThreads();
4626 result = (long)wxNewId();
4627 wxPyEndAllowThreads(__tstate);
4628 if (PyErr_Occurred()) SWIG_fail;
4629 }
4630 resultobj = SWIG_From_long(static_cast< long >(result));
4631 return resultobj;
4632 fail:
4633 return NULL;
4634 }
4635
4636
4637 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4638 PyObject *resultobj = 0;
4639 long arg1 ;
4640 long val1 ;
4641 int ecode1 = 0 ;
4642 PyObject * obj0 = 0 ;
4643 char * kwnames[] = {
4644 (char *) "id", NULL
4645 };
4646
4647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4648 ecode1 = SWIG_AsVal_long(obj0, &val1);
4649 if (!SWIG_IsOK(ecode1)) {
4650 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4651 }
4652 arg1 = static_cast< long >(val1);
4653 {
4654 PyThreadState* __tstate = wxPyBeginAllowThreads();
4655 wxRegisterId(arg1);
4656 wxPyEndAllowThreads(__tstate);
4657 if (PyErr_Occurred()) SWIG_fail;
4658 }
4659 resultobj = SWIG_Py_Void();
4660 return resultobj;
4661 fail:
4662 return NULL;
4663 }
4664
4665
4666 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4667 PyObject *resultobj = 0;
4668 long result;
4669
4670 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4671 {
4672 PyThreadState* __tstate = wxPyBeginAllowThreads();
4673 result = (long)wxGetCurrentId();
4674 wxPyEndAllowThreads(__tstate);
4675 if (PyErr_Occurred()) SWIG_fail;
4676 }
4677 resultobj = SWIG_From_long(static_cast< long >(result));
4678 return resultobj;
4679 fail:
4680 return NULL;
4681 }
4682
4683
4684 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4685 PyObject *resultobj = 0;
4686 int arg1 ;
4687 bool result;
4688 int val1 ;
4689 int ecode1 = 0 ;
4690 PyObject * obj0 = 0 ;
4691 char * kwnames[] = {
4692 (char *) "id", NULL
4693 };
4694
4695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4696 ecode1 = SWIG_AsVal_int(obj0, &val1);
4697 if (!SWIG_IsOK(ecode1)) {
4698 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4699 }
4700 arg1 = static_cast< int >(val1);
4701 {
4702 PyThreadState* __tstate = wxPyBeginAllowThreads();
4703 result = (bool)wxIsStockID(arg1);
4704 wxPyEndAllowThreads(__tstate);
4705 if (PyErr_Occurred()) SWIG_fail;
4706 }
4707 {
4708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4709 }
4710 return resultobj;
4711 fail:
4712 return NULL;
4713 }
4714
4715
4716 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4717 PyObject *resultobj = 0;
4718 int arg1 ;
4719 wxString *arg2 = 0 ;
4720 bool result;
4721 int val1 ;
4722 int ecode1 = 0 ;
4723 bool temp2 = false ;
4724 PyObject * obj0 = 0 ;
4725 PyObject * obj1 = 0 ;
4726 char * kwnames[] = {
4727 (char *) "id",(char *) "label", NULL
4728 };
4729
4730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4731 ecode1 = SWIG_AsVal_int(obj0, &val1);
4732 if (!SWIG_IsOK(ecode1)) {
4733 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4734 }
4735 arg1 = static_cast< int >(val1);
4736 {
4737 arg2 = wxString_in_helper(obj1);
4738 if (arg2 == NULL) SWIG_fail;
4739 temp2 = true;
4740 }
4741 {
4742 PyThreadState* __tstate = wxPyBeginAllowThreads();
4743 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4744 wxPyEndAllowThreads(__tstate);
4745 if (PyErr_Occurred()) SWIG_fail;
4746 }
4747 {
4748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4749 }
4750 {
4751 if (temp2)
4752 delete arg2;
4753 }
4754 return resultobj;
4755 fail:
4756 {
4757 if (temp2)
4758 delete arg2;
4759 }
4760 return NULL;
4761 }
4762
4763
4764 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4765 PyObject *resultobj = 0;
4766 int arg1 ;
4767 bool arg2 = (bool) true ;
4768 wxString arg3 = (wxString) wxPyEmptyString ;
4769 wxString result;
4770 int val1 ;
4771 int ecode1 = 0 ;
4772 bool val2 ;
4773 int ecode2 = 0 ;
4774 PyObject * obj0 = 0 ;
4775 PyObject * obj1 = 0 ;
4776 PyObject * obj2 = 0 ;
4777 char * kwnames[] = {
4778 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4779 };
4780
4781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4782 ecode1 = SWIG_AsVal_int(obj0, &val1);
4783 if (!SWIG_IsOK(ecode1)) {
4784 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4785 }
4786 arg1 = static_cast< int >(val1);
4787 if (obj1) {
4788 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4789 if (!SWIG_IsOK(ecode2)) {
4790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4791 }
4792 arg2 = static_cast< bool >(val2);
4793 }
4794 if (obj2) {
4795 {
4796 wxString* sptr = wxString_in_helper(obj2);
4797 if (sptr == NULL) SWIG_fail;
4798 arg3 = *sptr;
4799 delete sptr;
4800 }
4801 }
4802 {
4803 PyThreadState* __tstate = wxPyBeginAllowThreads();
4804 result = wxGetStockLabel(arg1,arg2,arg3);
4805 wxPyEndAllowThreads(__tstate);
4806 if (PyErr_Occurred()) SWIG_fail;
4807 }
4808 {
4809 #if wxUSE_UNICODE
4810 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4811 #else
4812 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4813 #endif
4814 }
4815 return resultobj;
4816 fail:
4817 return NULL;
4818 }
4819
4820
4821 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4822 PyObject *resultobj = 0;
4823
4824 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4825 {
4826 if (!wxPyCheckForApp()) SWIG_fail;
4827 PyThreadState* __tstate = wxPyBeginAllowThreads();
4828 wxBell();
4829 wxPyEndAllowThreads(__tstate);
4830 if (PyErr_Occurred()) SWIG_fail;
4831 }
4832 resultobj = SWIG_Py_Void();
4833 return resultobj;
4834 fail:
4835 return NULL;
4836 }
4837
4838
4839 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4840 PyObject *resultobj = 0;
4841
4842 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4843 {
4844 if (!wxPyCheckForApp()) SWIG_fail;
4845 PyThreadState* __tstate = wxPyBeginAllowThreads();
4846 wxEndBusyCursor();
4847 wxPyEndAllowThreads(__tstate);
4848 if (PyErr_Occurred()) SWIG_fail;
4849 }
4850 resultobj = SWIG_Py_Void();
4851 return resultobj;
4852 fail:
4853 return NULL;
4854 }
4855
4856
4857 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4858 PyObject *resultobj = 0;
4859 bool arg1 = (bool) true ;
4860 long result;
4861 bool val1 ;
4862 int ecode1 = 0 ;
4863 PyObject * obj0 = 0 ;
4864 char * kwnames[] = {
4865 (char *) "resetTimer", NULL
4866 };
4867
4868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4869 if (obj0) {
4870 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4871 if (!SWIG_IsOK(ecode1)) {
4872 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4873 }
4874 arg1 = static_cast< bool >(val1);
4875 }
4876 {
4877 PyThreadState* __tstate = wxPyBeginAllowThreads();
4878 result = (long)wxGetElapsedTime(arg1);
4879 wxPyEndAllowThreads(__tstate);
4880 if (PyErr_Occurred()) SWIG_fail;
4881 }
4882 resultobj = SWIG_From_long(static_cast< long >(result));
4883 return resultobj;
4884 fail:
4885 return NULL;
4886 }
4887
4888
4889 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4890 PyObject *resultobj = 0;
4891 bool result;
4892
4893 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4894 {
4895 PyThreadState* __tstate = wxPyBeginAllowThreads();
4896 result = (bool)wxIsBusy();
4897 wxPyEndAllowThreads(__tstate);
4898 if (PyErr_Occurred()) SWIG_fail;
4899 }
4900 {
4901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4902 }
4903 return resultobj;
4904 fail:
4905 return NULL;
4906 }
4907
4908
4909 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4910 PyObject *resultobj = 0;
4911 wxString result;
4912
4913 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4914 {
4915 PyThreadState* __tstate = wxPyBeginAllowThreads();
4916 result = wxNow();
4917 wxPyEndAllowThreads(__tstate);
4918 if (PyErr_Occurred()) SWIG_fail;
4919 }
4920 {
4921 #if wxUSE_UNICODE
4922 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4923 #else
4924 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4925 #endif
4926 }
4927 return resultobj;
4928 fail:
4929 return NULL;
4930 }
4931
4932
4933 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4934 PyObject *resultobj = 0;
4935 wxString const &arg1_defvalue = wxPyEmptyString ;
4936 wxString *arg1 = (wxString *) &arg1_defvalue ;
4937 bool result;
4938 bool temp1 = false ;
4939 PyObject * obj0 = 0 ;
4940 char * kwnames[] = {
4941 (char *) "command", NULL
4942 };
4943
4944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4945 if (obj0) {
4946 {
4947 arg1 = wxString_in_helper(obj0);
4948 if (arg1 == NULL) SWIG_fail;
4949 temp1 = true;
4950 }
4951 }
4952 {
4953 PyThreadState* __tstate = wxPyBeginAllowThreads();
4954 result = (bool)wxShell((wxString const &)*arg1);
4955 wxPyEndAllowThreads(__tstate);
4956 if (PyErr_Occurred()) SWIG_fail;
4957 }
4958 {
4959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4960 }
4961 {
4962 if (temp1)
4963 delete arg1;
4964 }
4965 return resultobj;
4966 fail:
4967 {
4968 if (temp1)
4969 delete arg1;
4970 }
4971 return NULL;
4972 }
4973
4974
4975 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4976 PyObject *resultobj = 0;
4977
4978 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
4979 {
4980 PyThreadState* __tstate = wxPyBeginAllowThreads();
4981 wxStartTimer();
4982 wxPyEndAllowThreads(__tstate);
4983 if (PyErr_Occurred()) SWIG_fail;
4984 }
4985 resultobj = SWIG_Py_Void();
4986 return resultobj;
4987 fail:
4988 return NULL;
4989 }
4990
4991
4992 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4993 PyObject *resultobj = 0;
4994 int *arg1 = (int *) 0 ;
4995 int *arg2 = (int *) 0 ;
4996 int result;
4997 int temp1 ;
4998 int res1 = SWIG_TMPOBJ ;
4999 int temp2 ;
5000 int res2 = SWIG_TMPOBJ ;
5001
5002 arg1 = &temp1;
5003 arg2 = &temp2;
5004 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5005 {
5006 PyThreadState* __tstate = wxPyBeginAllowThreads();
5007 result = (int)wxGetOsVersion(arg1,arg2);
5008 wxPyEndAllowThreads(__tstate);
5009 if (PyErr_Occurred()) SWIG_fail;
5010 }
5011 resultobj = SWIG_From_int(static_cast< int >(result));
5012 if (SWIG_IsTmpObj(res1)) {
5013 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5014 } else {
5015 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5016 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5017 }
5018 if (SWIG_IsTmpObj(res2)) {
5019 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5020 } else {
5021 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5022 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5023 }
5024 return resultobj;
5025 fail:
5026 return NULL;
5027 }
5028
5029
5030 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5031 PyObject *resultobj = 0;
5032 wxString result;
5033
5034 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5035 {
5036 PyThreadState* __tstate = wxPyBeginAllowThreads();
5037 result = wxGetOsDescription();
5038 wxPyEndAllowThreads(__tstate);
5039 if (PyErr_Occurred()) SWIG_fail;
5040 }
5041 {
5042 #if wxUSE_UNICODE
5043 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5044 #else
5045 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5046 #endif
5047 }
5048 return resultobj;
5049 fail:
5050 return NULL;
5051 }
5052
5053
5054 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5055 PyObject *resultobj = 0;
5056 wxMemorySize result;
5057
5058 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5059 {
5060 PyThreadState* __tstate = wxPyBeginAllowThreads();
5061 result = wxGetFreeMemory();
5062 wxPyEndAllowThreads(__tstate);
5063 if (PyErr_Occurred()) SWIG_fail;
5064 }
5065 resultobj = SWIG_NewPointerObj((new wxMemorySize(static_cast< const wxMemorySize& >(result))), SWIGTYPE_p_wxMemorySize, SWIG_POINTER_OWN | 0 );
5066 return resultobj;
5067 fail:
5068 return NULL;
5069 }
5070
5071
5072 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5073 PyObject *resultobj = 0;
5074 wxShutdownFlags arg1 ;
5075 bool result;
5076 int val1 ;
5077 int ecode1 = 0 ;
5078 PyObject * obj0 = 0 ;
5079 char * kwnames[] = {
5080 (char *) "wFlags", NULL
5081 };
5082
5083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5084 ecode1 = SWIG_AsVal_int(obj0, &val1);
5085 if (!SWIG_IsOK(ecode1)) {
5086 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5087 }
5088 arg1 = static_cast< wxShutdownFlags >(val1);
5089 {
5090 if (!wxPyCheckForApp()) SWIG_fail;
5091 PyThreadState* __tstate = wxPyBeginAllowThreads();
5092 result = (bool)wxShutdown(arg1);
5093 wxPyEndAllowThreads(__tstate);
5094 if (PyErr_Occurred()) SWIG_fail;
5095 }
5096 {
5097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5098 }
5099 return resultobj;
5100 fail:
5101 return NULL;
5102 }
5103
5104
5105 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5106 PyObject *resultobj = 0;
5107 int arg1 ;
5108 int val1 ;
5109 int ecode1 = 0 ;
5110 PyObject * obj0 = 0 ;
5111 char * kwnames[] = {
5112 (char *) "secs", NULL
5113 };
5114
5115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5116 ecode1 = SWIG_AsVal_int(obj0, &val1);
5117 if (!SWIG_IsOK(ecode1)) {
5118 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5119 }
5120 arg1 = static_cast< int >(val1);
5121 {
5122 PyThreadState* __tstate = wxPyBeginAllowThreads();
5123 wxSleep(arg1);
5124 wxPyEndAllowThreads(__tstate);
5125 if (PyErr_Occurred()) SWIG_fail;
5126 }
5127 resultobj = SWIG_Py_Void();
5128 return resultobj;
5129 fail:
5130 return NULL;
5131 }
5132
5133
5134 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5135 PyObject *resultobj = 0;
5136 unsigned long arg1 ;
5137 unsigned long val1 ;
5138 int ecode1 = 0 ;
5139 PyObject * obj0 = 0 ;
5140 char * kwnames[] = {
5141 (char *) "milliseconds", NULL
5142 };
5143
5144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5145 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5146 if (!SWIG_IsOK(ecode1)) {
5147 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5148 }
5149 arg1 = static_cast< unsigned long >(val1);
5150 {
5151 PyThreadState* __tstate = wxPyBeginAllowThreads();
5152 wxMilliSleep(arg1);
5153 wxPyEndAllowThreads(__tstate);
5154 if (PyErr_Occurred()) SWIG_fail;
5155 }
5156 resultobj = SWIG_Py_Void();
5157 return resultobj;
5158 fail:
5159 return NULL;
5160 }
5161
5162
5163 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5164 PyObject *resultobj = 0;
5165 unsigned long arg1 ;
5166 unsigned long val1 ;
5167 int ecode1 = 0 ;
5168 PyObject * obj0 = 0 ;
5169 char * kwnames[] = {
5170 (char *) "microseconds", NULL
5171 };
5172
5173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5174 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5175 if (!SWIG_IsOK(ecode1)) {
5176 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5177 }
5178 arg1 = static_cast< unsigned long >(val1);
5179 {
5180 PyThreadState* __tstate = wxPyBeginAllowThreads();
5181 wxMicroSleep(arg1);
5182 wxPyEndAllowThreads(__tstate);
5183 if (PyErr_Occurred()) SWIG_fail;
5184 }
5185 resultobj = SWIG_Py_Void();
5186 return resultobj;
5187 fail:
5188 return NULL;
5189 }
5190
5191
5192 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5193 PyObject *resultobj = 0;
5194 bool arg1 ;
5195 bool val1 ;
5196 int ecode1 = 0 ;
5197 PyObject * obj0 = 0 ;
5198 char * kwnames[] = {
5199 (char *) "enable", NULL
5200 };
5201
5202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5203 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5204 if (!SWIG_IsOK(ecode1)) {
5205 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5206 }
5207 arg1 = static_cast< bool >(val1);
5208 {
5209 PyThreadState* __tstate = wxPyBeginAllowThreads();
5210 wxEnableTopLevelWindows(arg1);
5211 wxPyEndAllowThreads(__tstate);
5212 if (PyErr_Occurred()) SWIG_fail;
5213 }
5214 resultobj = SWIG_Py_Void();
5215 return resultobj;
5216 fail:
5217 return NULL;
5218 }
5219
5220
5221 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5222 PyObject *resultobj = 0;
5223 wxString *arg1 = 0 ;
5224 wxString result;
5225 bool temp1 = false ;
5226 PyObject * obj0 = 0 ;
5227 char * kwnames[] = {
5228 (char *) "in", NULL
5229 };
5230
5231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5232 {
5233 arg1 = wxString_in_helper(obj0);
5234 if (arg1 == NULL) SWIG_fail;
5235 temp1 = true;
5236 }
5237 {
5238 PyThreadState* __tstate = wxPyBeginAllowThreads();
5239 result = wxStripMenuCodes((wxString const &)*arg1);
5240 wxPyEndAllowThreads(__tstate);
5241 if (PyErr_Occurred()) SWIG_fail;
5242 }
5243 {
5244 #if wxUSE_UNICODE
5245 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5246 #else
5247 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5248 #endif
5249 }
5250 {
5251 if (temp1)
5252 delete arg1;
5253 }
5254 return resultobj;
5255 fail:
5256 {
5257 if (temp1)
5258 delete arg1;
5259 }
5260 return NULL;
5261 }
5262
5263
5264 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5265 PyObject *resultobj = 0;
5266 wxString result;
5267
5268 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5269 {
5270 PyThreadState* __tstate = wxPyBeginAllowThreads();
5271 result = wxGetEmailAddress();
5272 wxPyEndAllowThreads(__tstate);
5273 if (PyErr_Occurred()) SWIG_fail;
5274 }
5275 {
5276 #if wxUSE_UNICODE
5277 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5278 #else
5279 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5280 #endif
5281 }
5282 return resultobj;
5283 fail:
5284 return NULL;
5285 }
5286
5287
5288 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5289 PyObject *resultobj = 0;
5290 wxString result;
5291
5292 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5293 {
5294 PyThreadState* __tstate = wxPyBeginAllowThreads();
5295 result = wxGetHostName();
5296 wxPyEndAllowThreads(__tstate);
5297 if (PyErr_Occurred()) SWIG_fail;
5298 }
5299 {
5300 #if wxUSE_UNICODE
5301 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5302 #else
5303 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5304 #endif
5305 }
5306 return resultobj;
5307 fail:
5308 return NULL;
5309 }
5310
5311
5312 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5313 PyObject *resultobj = 0;
5314 wxString result;
5315
5316 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5317 {
5318 PyThreadState* __tstate = wxPyBeginAllowThreads();
5319 result = wxGetFullHostName();
5320 wxPyEndAllowThreads(__tstate);
5321 if (PyErr_Occurred()) SWIG_fail;
5322 }
5323 {
5324 #if wxUSE_UNICODE
5325 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5326 #else
5327 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5328 #endif
5329 }
5330 return resultobj;
5331 fail:
5332 return NULL;
5333 }
5334
5335
5336 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5337 PyObject *resultobj = 0;
5338 wxString result;
5339
5340 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5341 {
5342 PyThreadState* __tstate = wxPyBeginAllowThreads();
5343 result = wxGetUserId();
5344 wxPyEndAllowThreads(__tstate);
5345 if (PyErr_Occurred()) SWIG_fail;
5346 }
5347 {
5348 #if wxUSE_UNICODE
5349 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5350 #else
5351 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5352 #endif
5353 }
5354 return resultobj;
5355 fail:
5356 return NULL;
5357 }
5358
5359
5360 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5361 PyObject *resultobj = 0;
5362 wxString result;
5363
5364 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5365 {
5366 PyThreadState* __tstate = wxPyBeginAllowThreads();
5367 result = wxGetUserName();
5368 wxPyEndAllowThreads(__tstate);
5369 if (PyErr_Occurred()) SWIG_fail;
5370 }
5371 {
5372 #if wxUSE_UNICODE
5373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5374 #else
5375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5376 #endif
5377 }
5378 return resultobj;
5379 fail:
5380 return NULL;
5381 }
5382
5383
5384 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5385 PyObject *resultobj = 0;
5386 wxString result;
5387
5388 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5389 {
5390 PyThreadState* __tstate = wxPyBeginAllowThreads();
5391 result = wxGetHomeDir();
5392 wxPyEndAllowThreads(__tstate);
5393 if (PyErr_Occurred()) SWIG_fail;
5394 }
5395 {
5396 #if wxUSE_UNICODE
5397 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5398 #else
5399 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5400 #endif
5401 }
5402 return resultobj;
5403 fail:
5404 return NULL;
5405 }
5406
5407
5408 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5409 PyObject *resultobj = 0;
5410 wxString const &arg1_defvalue = wxPyEmptyString ;
5411 wxString *arg1 = (wxString *) &arg1_defvalue ;
5412 wxString result;
5413 bool temp1 = false ;
5414 PyObject * obj0 = 0 ;
5415 char * kwnames[] = {
5416 (char *) "user", NULL
5417 };
5418
5419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5420 if (obj0) {
5421 {
5422 arg1 = wxString_in_helper(obj0);
5423 if (arg1 == NULL) SWIG_fail;
5424 temp1 = true;
5425 }
5426 }
5427 {
5428 PyThreadState* __tstate = wxPyBeginAllowThreads();
5429 result = wxGetUserHome((wxString const &)*arg1);
5430 wxPyEndAllowThreads(__tstate);
5431 if (PyErr_Occurred()) SWIG_fail;
5432 }
5433 {
5434 #if wxUSE_UNICODE
5435 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5436 #else
5437 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5438 #endif
5439 }
5440 {
5441 if (temp1)
5442 delete arg1;
5443 }
5444 return resultobj;
5445 fail:
5446 {
5447 if (temp1)
5448 delete arg1;
5449 }
5450 return NULL;
5451 }
5452
5453
5454 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5455 PyObject *resultobj = 0;
5456 unsigned long result;
5457
5458 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5459 {
5460 PyThreadState* __tstate = wxPyBeginAllowThreads();
5461 result = (unsigned long)wxGetProcessId();
5462 wxPyEndAllowThreads(__tstate);
5463 if (PyErr_Occurred()) SWIG_fail;
5464 }
5465 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5466 return resultobj;
5467 fail:
5468 return NULL;
5469 }
5470
5471
5472 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5473 PyObject *resultobj = 0;
5474
5475 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5476 {
5477 PyThreadState* __tstate = wxPyBeginAllowThreads();
5478 wxTrap();
5479 wxPyEndAllowThreads(__tstate);
5480 if (PyErr_Occurred()) SWIG_fail;
5481 }
5482 resultobj = SWIG_Py_Void();
5483 return resultobj;
5484 fail:
5485 return NULL;
5486 }
5487
5488
5489 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5490 PyObject *resultobj = 0;
5491 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5492 wxString *arg1 = (wxString *) &arg1_defvalue ;
5493 wxString const &arg2_defvalue = wxPyEmptyString ;
5494 wxString *arg2 = (wxString *) &arg2_defvalue ;
5495 wxString const &arg3_defvalue = wxPyEmptyString ;
5496 wxString *arg3 = (wxString *) &arg3_defvalue ;
5497 wxString const &arg4_defvalue = wxPyEmptyString ;
5498 wxString *arg4 = (wxString *) &arg4_defvalue ;
5499 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5500 wxString *arg5 = (wxString *) &arg5_defvalue ;
5501 int arg6 = (int) 0 ;
5502 wxWindow *arg7 = (wxWindow *) NULL ;
5503 int arg8 = (int) -1 ;
5504 int arg9 = (int) -1 ;
5505 wxString result;
5506 bool temp1 = false ;
5507 bool temp2 = false ;
5508 bool temp3 = false ;
5509 bool temp4 = false ;
5510 bool temp5 = false ;
5511 int val6 ;
5512 int ecode6 = 0 ;
5513 void *argp7 = 0 ;
5514 int res7 = 0 ;
5515 int val8 ;
5516 int ecode8 = 0 ;
5517 int val9 ;
5518 int ecode9 = 0 ;
5519 PyObject * obj0 = 0 ;
5520 PyObject * obj1 = 0 ;
5521 PyObject * obj2 = 0 ;
5522 PyObject * obj3 = 0 ;
5523 PyObject * obj4 = 0 ;
5524 PyObject * obj5 = 0 ;
5525 PyObject * obj6 = 0 ;
5526 PyObject * obj7 = 0 ;
5527 PyObject * obj8 = 0 ;
5528 char * kwnames[] = {
5529 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5530 };
5531
5532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5533 if (obj0) {
5534 {
5535 arg1 = wxString_in_helper(obj0);
5536 if (arg1 == NULL) SWIG_fail;
5537 temp1 = true;
5538 }
5539 }
5540 if (obj1) {
5541 {
5542 arg2 = wxString_in_helper(obj1);
5543 if (arg2 == NULL) SWIG_fail;
5544 temp2 = true;
5545 }
5546 }
5547 if (obj2) {
5548 {
5549 arg3 = wxString_in_helper(obj2);
5550 if (arg3 == NULL) SWIG_fail;
5551 temp3 = true;
5552 }
5553 }
5554 if (obj3) {
5555 {
5556 arg4 = wxString_in_helper(obj3);
5557 if (arg4 == NULL) SWIG_fail;
5558 temp4 = true;
5559 }
5560 }
5561 if (obj4) {
5562 {
5563 arg5 = wxString_in_helper(obj4);
5564 if (arg5 == NULL) SWIG_fail;
5565 temp5 = true;
5566 }
5567 }
5568 if (obj5) {
5569 ecode6 = SWIG_AsVal_int(obj5, &val6);
5570 if (!SWIG_IsOK(ecode6)) {
5571 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5572 }
5573 arg6 = static_cast< int >(val6);
5574 }
5575 if (obj6) {
5576 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5577 if (!SWIG_IsOK(res7)) {
5578 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5579 }
5580 arg7 = reinterpret_cast< wxWindow * >(argp7);
5581 }
5582 if (obj7) {
5583 ecode8 = SWIG_AsVal_int(obj7, &val8);
5584 if (!SWIG_IsOK(ecode8)) {
5585 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5586 }
5587 arg8 = static_cast< int >(val8);
5588 }
5589 if (obj8) {
5590 ecode9 = SWIG_AsVal_int(obj8, &val9);
5591 if (!SWIG_IsOK(ecode9)) {
5592 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5593 }
5594 arg9 = static_cast< int >(val9);
5595 }
5596 {
5597 if (!wxPyCheckForApp()) SWIG_fail;
5598 PyThreadState* __tstate = wxPyBeginAllowThreads();
5599 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5600 wxPyEndAllowThreads(__tstate);
5601 if (PyErr_Occurred()) SWIG_fail;
5602 }
5603 {
5604 #if wxUSE_UNICODE
5605 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5606 #else
5607 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5608 #endif
5609 }
5610 {
5611 if (temp1)
5612 delete arg1;
5613 }
5614 {
5615 if (temp2)
5616 delete arg2;
5617 }
5618 {
5619 if (temp3)
5620 delete arg3;
5621 }
5622 {
5623 if (temp4)
5624 delete arg4;
5625 }
5626 {
5627 if (temp5)
5628 delete arg5;
5629 }
5630 return resultobj;
5631 fail:
5632 {
5633 if (temp1)
5634 delete arg1;
5635 }
5636 {
5637 if (temp2)
5638 delete arg2;
5639 }
5640 {
5641 if (temp3)
5642 delete arg3;
5643 }
5644 {
5645 if (temp4)
5646 delete arg4;
5647 }
5648 {
5649 if (temp5)
5650 delete arg5;
5651 }
5652 return NULL;
5653 }
5654
5655
5656 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5657 PyObject *resultobj = 0;
5658 wxString *arg1 = 0 ;
5659 wxString *arg2 = 0 ;
5660 wxString const &arg3_defvalue = wxPyEmptyString ;
5661 wxString *arg3 = (wxString *) &arg3_defvalue ;
5662 wxWindow *arg4 = (wxWindow *) NULL ;
5663 wxString result;
5664 bool temp1 = false ;
5665 bool temp2 = false ;
5666 bool temp3 = false ;
5667 void *argp4 = 0 ;
5668 int res4 = 0 ;
5669 PyObject * obj0 = 0 ;
5670 PyObject * obj1 = 0 ;
5671 PyObject * obj2 = 0 ;
5672 PyObject * obj3 = 0 ;
5673 char * kwnames[] = {
5674 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5675 };
5676
5677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5678 {
5679 arg1 = wxString_in_helper(obj0);
5680 if (arg1 == NULL) SWIG_fail;
5681 temp1 = true;
5682 }
5683 {
5684 arg2 = wxString_in_helper(obj1);
5685 if (arg2 == NULL) SWIG_fail;
5686 temp2 = true;
5687 }
5688 if (obj2) {
5689 {
5690 arg3 = wxString_in_helper(obj2);
5691 if (arg3 == NULL) SWIG_fail;
5692 temp3 = true;
5693 }
5694 }
5695 if (obj3) {
5696 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5697 if (!SWIG_IsOK(res4)) {
5698 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5699 }
5700 arg4 = reinterpret_cast< wxWindow * >(argp4);
5701 }
5702 {
5703 if (!wxPyCheckForApp()) SWIG_fail;
5704 PyThreadState* __tstate = wxPyBeginAllowThreads();
5705 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5706 wxPyEndAllowThreads(__tstate);
5707 if (PyErr_Occurred()) SWIG_fail;
5708 }
5709 {
5710 #if wxUSE_UNICODE
5711 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5712 #else
5713 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5714 #endif
5715 }
5716 {
5717 if (temp1)
5718 delete arg1;
5719 }
5720 {
5721 if (temp2)
5722 delete arg2;
5723 }
5724 {
5725 if (temp3)
5726 delete arg3;
5727 }
5728 return resultobj;
5729 fail:
5730 {
5731 if (temp1)
5732 delete arg1;
5733 }
5734 {
5735 if (temp2)
5736 delete arg2;
5737 }
5738 {
5739 if (temp3)
5740 delete arg3;
5741 }
5742 return NULL;
5743 }
5744
5745
5746 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5747 PyObject *resultobj = 0;
5748 wxString *arg1 = 0 ;
5749 wxString *arg2 = 0 ;
5750 wxString const &arg3_defvalue = wxPyEmptyString ;
5751 wxString *arg3 = (wxString *) &arg3_defvalue ;
5752 wxWindow *arg4 = (wxWindow *) NULL ;
5753 wxString result;
5754 bool temp1 = false ;
5755 bool temp2 = false ;
5756 bool temp3 = false ;
5757 void *argp4 = 0 ;
5758 int res4 = 0 ;
5759 PyObject * obj0 = 0 ;
5760 PyObject * obj1 = 0 ;
5761 PyObject * obj2 = 0 ;
5762 PyObject * obj3 = 0 ;
5763 char * kwnames[] = {
5764 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5765 };
5766
5767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5768 {
5769 arg1 = wxString_in_helper(obj0);
5770 if (arg1 == NULL) SWIG_fail;
5771 temp1 = true;
5772 }
5773 {
5774 arg2 = wxString_in_helper(obj1);
5775 if (arg2 == NULL) SWIG_fail;
5776 temp2 = true;
5777 }
5778 if (obj2) {
5779 {
5780 arg3 = wxString_in_helper(obj2);
5781 if (arg3 == NULL) SWIG_fail;
5782 temp3 = true;
5783 }
5784 }
5785 if (obj3) {
5786 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5787 if (!SWIG_IsOK(res4)) {
5788 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5789 }
5790 arg4 = reinterpret_cast< wxWindow * >(argp4);
5791 }
5792 {
5793 if (!wxPyCheckForApp()) SWIG_fail;
5794 PyThreadState* __tstate = wxPyBeginAllowThreads();
5795 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5796 wxPyEndAllowThreads(__tstate);
5797 if (PyErr_Occurred()) SWIG_fail;
5798 }
5799 {
5800 #if wxUSE_UNICODE
5801 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5802 #else
5803 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5804 #endif
5805 }
5806 {
5807 if (temp1)
5808 delete arg1;
5809 }
5810 {
5811 if (temp2)
5812 delete arg2;
5813 }
5814 {
5815 if (temp3)
5816 delete arg3;
5817 }
5818 return resultobj;
5819 fail:
5820 {
5821 if (temp1)
5822 delete arg1;
5823 }
5824 {
5825 if (temp2)
5826 delete arg2;
5827 }
5828 {
5829 if (temp3)
5830 delete arg3;
5831 }
5832 return NULL;
5833 }
5834
5835
5836 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5837 PyObject *resultobj = 0;
5838 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5839 wxString *arg1 = (wxString *) &arg1_defvalue ;
5840 wxString const &arg2_defvalue = wxPyEmptyString ;
5841 wxString *arg2 = (wxString *) &arg2_defvalue ;
5842 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5843 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5844 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5845 wxWindow *arg5 = (wxWindow *) NULL ;
5846 wxString result;
5847 bool temp1 = false ;
5848 bool temp2 = false ;
5849 long val3 ;
5850 int ecode3 = 0 ;
5851 wxPoint temp4 ;
5852 void *argp5 = 0 ;
5853 int res5 = 0 ;
5854 PyObject * obj0 = 0 ;
5855 PyObject * obj1 = 0 ;
5856 PyObject * obj2 = 0 ;
5857 PyObject * obj3 = 0 ;
5858 PyObject * obj4 = 0 ;
5859 char * kwnames[] = {
5860 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5861 };
5862
5863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5864 if (obj0) {
5865 {
5866 arg1 = wxString_in_helper(obj0);
5867 if (arg1 == NULL) SWIG_fail;
5868 temp1 = true;
5869 }
5870 }
5871 if (obj1) {
5872 {
5873 arg2 = wxString_in_helper(obj1);
5874 if (arg2 == NULL) SWIG_fail;
5875 temp2 = true;
5876 }
5877 }
5878 if (obj2) {
5879 ecode3 = SWIG_AsVal_long(obj2, &val3);
5880 if (!SWIG_IsOK(ecode3)) {
5881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5882 }
5883 arg3 = static_cast< long >(val3);
5884 }
5885 if (obj3) {
5886 {
5887 arg4 = &temp4;
5888 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5889 }
5890 }
5891 if (obj4) {
5892 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5893 if (!SWIG_IsOK(res5)) {
5894 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5895 }
5896 arg5 = reinterpret_cast< wxWindow * >(argp5);
5897 }
5898 {
5899 if (!wxPyCheckForApp()) SWIG_fail;
5900 PyThreadState* __tstate = wxPyBeginAllowThreads();
5901 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5902 wxPyEndAllowThreads(__tstate);
5903 if (PyErr_Occurred()) SWIG_fail;
5904 }
5905 {
5906 #if wxUSE_UNICODE
5907 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5908 #else
5909 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5910 #endif
5911 }
5912 {
5913 if (temp1)
5914 delete arg1;
5915 }
5916 {
5917 if (temp2)
5918 delete arg2;
5919 }
5920 return resultobj;
5921 fail:
5922 {
5923 if (temp1)
5924 delete arg1;
5925 }
5926 {
5927 if (temp2)
5928 delete arg2;
5929 }
5930 return NULL;
5931 }
5932
5933
5934 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5935 PyObject *resultobj = 0;
5936 wxString *arg1 = 0 ;
5937 wxString const &arg2_defvalue = wxPyEmptyString ;
5938 wxString *arg2 = (wxString *) &arg2_defvalue ;
5939 wxString const &arg3_defvalue = wxPyEmptyString ;
5940 wxString *arg3 = (wxString *) &arg3_defvalue ;
5941 wxWindow *arg4 = (wxWindow *) NULL ;
5942 int arg5 = (int) -1 ;
5943 int arg6 = (int) -1 ;
5944 bool arg7 = (bool) true ;
5945 wxString result;
5946 bool temp1 = false ;
5947 bool temp2 = false ;
5948 bool temp3 = false ;
5949 void *argp4 = 0 ;
5950 int res4 = 0 ;
5951 int val5 ;
5952 int ecode5 = 0 ;
5953 int val6 ;
5954 int ecode6 = 0 ;
5955 bool val7 ;
5956 int ecode7 = 0 ;
5957 PyObject * obj0 = 0 ;
5958 PyObject * obj1 = 0 ;
5959 PyObject * obj2 = 0 ;
5960 PyObject * obj3 = 0 ;
5961 PyObject * obj4 = 0 ;
5962 PyObject * obj5 = 0 ;
5963 PyObject * obj6 = 0 ;
5964 char * kwnames[] = {
5965 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5966 };
5967
5968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
5969 {
5970 arg1 = wxString_in_helper(obj0);
5971 if (arg1 == NULL) SWIG_fail;
5972 temp1 = true;
5973 }
5974 if (obj1) {
5975 {
5976 arg2 = wxString_in_helper(obj1);
5977 if (arg2 == NULL) SWIG_fail;
5978 temp2 = true;
5979 }
5980 }
5981 if (obj2) {
5982 {
5983 arg3 = wxString_in_helper(obj2);
5984 if (arg3 == NULL) SWIG_fail;
5985 temp3 = true;
5986 }
5987 }
5988 if (obj3) {
5989 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5990 if (!SWIG_IsOK(res4)) {
5991 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
5992 }
5993 arg4 = reinterpret_cast< wxWindow * >(argp4);
5994 }
5995 if (obj4) {
5996 ecode5 = SWIG_AsVal_int(obj4, &val5);
5997 if (!SWIG_IsOK(ecode5)) {
5998 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
5999 }
6000 arg5 = static_cast< int >(val5);
6001 }
6002 if (obj5) {
6003 ecode6 = SWIG_AsVal_int(obj5, &val6);
6004 if (!SWIG_IsOK(ecode6)) {
6005 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6006 }
6007 arg6 = static_cast< int >(val6);
6008 }
6009 if (obj6) {
6010 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6011 if (!SWIG_IsOK(ecode7)) {
6012 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6013 }
6014 arg7 = static_cast< bool >(val7);
6015 }
6016 {
6017 if (!wxPyCheckForApp()) SWIG_fail;
6018 PyThreadState* __tstate = wxPyBeginAllowThreads();
6019 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6020 wxPyEndAllowThreads(__tstate);
6021 if (PyErr_Occurred()) SWIG_fail;
6022 }
6023 {
6024 #if wxUSE_UNICODE
6025 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6026 #else
6027 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6028 #endif
6029 }
6030 {
6031 if (temp1)
6032 delete arg1;
6033 }
6034 {
6035 if (temp2)
6036 delete arg2;
6037 }
6038 {
6039 if (temp3)
6040 delete arg3;
6041 }
6042 return resultobj;
6043 fail:
6044 {
6045 if (temp1)
6046 delete arg1;
6047 }
6048 {
6049 if (temp2)
6050 delete arg2;
6051 }
6052 {
6053 if (temp3)
6054 delete arg3;
6055 }
6056 return NULL;
6057 }
6058
6059
6060 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6061 PyObject *resultobj = 0;
6062 wxString *arg1 = 0 ;
6063 wxString const &arg2_defvalue = wxPyEmptyString ;
6064 wxString *arg2 = (wxString *) &arg2_defvalue ;
6065 wxString const &arg3_defvalue = wxPyEmptyString ;
6066 wxString *arg3 = (wxString *) &arg3_defvalue ;
6067 wxWindow *arg4 = (wxWindow *) NULL ;
6068 wxString result;
6069 bool temp1 = false ;
6070 bool temp2 = false ;
6071 bool temp3 = false ;
6072 void *argp4 = 0 ;
6073 int res4 = 0 ;
6074 PyObject * obj0 = 0 ;
6075 PyObject * obj1 = 0 ;
6076 PyObject * obj2 = 0 ;
6077 PyObject * obj3 = 0 ;
6078 char * kwnames[] = {
6079 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6080 };
6081
6082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6083 {
6084 arg1 = wxString_in_helper(obj0);
6085 if (arg1 == NULL) SWIG_fail;
6086 temp1 = true;
6087 }
6088 if (obj1) {
6089 {
6090 arg2 = wxString_in_helper(obj1);
6091 if (arg2 == NULL) SWIG_fail;
6092 temp2 = true;
6093 }
6094 }
6095 if (obj2) {
6096 {
6097 arg3 = wxString_in_helper(obj2);
6098 if (arg3 == NULL) SWIG_fail;
6099 temp3 = true;
6100 }
6101 }
6102 if (obj3) {
6103 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6104 if (!SWIG_IsOK(res4)) {
6105 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6106 }
6107 arg4 = reinterpret_cast< wxWindow * >(argp4);
6108 }
6109 {
6110 if (!wxPyCheckForApp()) SWIG_fail;
6111 PyThreadState* __tstate = wxPyBeginAllowThreads();
6112 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6113 wxPyEndAllowThreads(__tstate);
6114 if (PyErr_Occurred()) SWIG_fail;
6115 }
6116 {
6117 #if wxUSE_UNICODE
6118 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6119 #else
6120 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6121 #endif
6122 }
6123 {
6124 if (temp1)
6125 delete arg1;
6126 }
6127 {
6128 if (temp2)
6129 delete arg2;
6130 }
6131 {
6132 if (temp3)
6133 delete arg3;
6134 }
6135 return resultobj;
6136 fail:
6137 {
6138 if (temp1)
6139 delete arg1;
6140 }
6141 {
6142 if (temp2)
6143 delete arg2;
6144 }
6145 {
6146 if (temp3)
6147 delete arg3;
6148 }
6149 return NULL;
6150 }
6151
6152
6153 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6154 PyObject *resultobj = 0;
6155 wxString *arg1 = 0 ;
6156 wxString *arg2 = 0 ;
6157 int arg3 ;
6158 wxString *arg4 = (wxString *) 0 ;
6159 wxWindow *arg5 = (wxWindow *) NULL ;
6160 int arg6 = (int) -1 ;
6161 int arg7 = (int) -1 ;
6162 bool arg8 = (bool) true ;
6163 int arg9 = (int) 150 ;
6164 int arg10 = (int) 200 ;
6165 wxString result;
6166 bool temp1 = false ;
6167 bool temp2 = false ;
6168 void *argp5 = 0 ;
6169 int res5 = 0 ;
6170 int val6 ;
6171 int ecode6 = 0 ;
6172 int val7 ;
6173 int ecode7 = 0 ;
6174 bool val8 ;
6175 int ecode8 = 0 ;
6176 int val9 ;
6177 int ecode9 = 0 ;
6178 int val10 ;
6179 int ecode10 = 0 ;
6180 PyObject * obj0 = 0 ;
6181 PyObject * obj1 = 0 ;
6182 PyObject * obj2 = 0 ;
6183 PyObject * obj3 = 0 ;
6184 PyObject * obj4 = 0 ;
6185 PyObject * obj5 = 0 ;
6186 PyObject * obj6 = 0 ;
6187 PyObject * obj7 = 0 ;
6188 PyObject * obj8 = 0 ;
6189 char * kwnames[] = {
6190 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6191 };
6192
6193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6194 {
6195 arg1 = wxString_in_helper(obj0);
6196 if (arg1 == NULL) SWIG_fail;
6197 temp1 = true;
6198 }
6199 {
6200 arg2 = wxString_in_helper(obj1);
6201 if (arg2 == NULL) SWIG_fail;
6202 temp2 = true;
6203 }
6204 {
6205 arg3 = PyList_Size(obj2);
6206 arg4 = wxString_LIST_helper(obj2);
6207 if (arg4 == NULL) SWIG_fail;
6208 }
6209 if (obj3) {
6210 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6211 if (!SWIG_IsOK(res5)) {
6212 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6213 }
6214 arg5 = reinterpret_cast< wxWindow * >(argp5);
6215 }
6216 if (obj4) {
6217 ecode6 = SWIG_AsVal_int(obj4, &val6);
6218 if (!SWIG_IsOK(ecode6)) {
6219 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6220 }
6221 arg6 = static_cast< int >(val6);
6222 }
6223 if (obj5) {
6224 ecode7 = SWIG_AsVal_int(obj5, &val7);
6225 if (!SWIG_IsOK(ecode7)) {
6226 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6227 }
6228 arg7 = static_cast< int >(val7);
6229 }
6230 if (obj6) {
6231 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6232 if (!SWIG_IsOK(ecode8)) {
6233 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6234 }
6235 arg8 = static_cast< bool >(val8);
6236 }
6237 if (obj7) {
6238 ecode9 = SWIG_AsVal_int(obj7, &val9);
6239 if (!SWIG_IsOK(ecode9)) {
6240 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6241 }
6242 arg9 = static_cast< int >(val9);
6243 }
6244 if (obj8) {
6245 ecode10 = SWIG_AsVal_int(obj8, &val10);
6246 if (!SWIG_IsOK(ecode10)) {
6247 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6248 }
6249 arg10 = static_cast< int >(val10);
6250 }
6251 {
6252 if (!wxPyCheckForApp()) SWIG_fail;
6253 PyThreadState* __tstate = wxPyBeginAllowThreads();
6254 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6255 wxPyEndAllowThreads(__tstate);
6256 if (PyErr_Occurred()) SWIG_fail;
6257 }
6258 {
6259 #if wxUSE_UNICODE
6260 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6261 #else
6262 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6263 #endif
6264 }
6265 {
6266 if (temp1)
6267 delete arg1;
6268 }
6269 {
6270 if (temp2)
6271 delete arg2;
6272 }
6273 {
6274 if (arg4) delete [] arg4;
6275 }
6276 return resultobj;
6277 fail:
6278 {
6279 if (temp1)
6280 delete arg1;
6281 }
6282 {
6283 if (temp2)
6284 delete arg2;
6285 }
6286 {
6287 if (arg4) delete [] arg4;
6288 }
6289 return NULL;
6290 }
6291
6292
6293 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6294 PyObject *resultobj = 0;
6295 wxString *arg1 = 0 ;
6296 wxString *arg2 = 0 ;
6297 int arg3 ;
6298 wxString *arg4 = (wxString *) 0 ;
6299 wxWindow *arg5 = (wxWindow *) NULL ;
6300 int arg6 = (int) -1 ;
6301 int arg7 = (int) -1 ;
6302 bool arg8 = (bool) true ;
6303 int arg9 = (int) 150 ;
6304 int arg10 = (int) 200 ;
6305 int result;
6306 bool temp1 = false ;
6307 bool temp2 = false ;
6308 void *argp5 = 0 ;
6309 int res5 = 0 ;
6310 int val6 ;
6311 int ecode6 = 0 ;
6312 int val7 ;
6313 int ecode7 = 0 ;
6314 bool val8 ;
6315 int ecode8 = 0 ;
6316 int val9 ;
6317 int ecode9 = 0 ;
6318 int val10 ;
6319 int ecode10 = 0 ;
6320 PyObject * obj0 = 0 ;
6321 PyObject * obj1 = 0 ;
6322 PyObject * obj2 = 0 ;
6323 PyObject * obj3 = 0 ;
6324 PyObject * obj4 = 0 ;
6325 PyObject * obj5 = 0 ;
6326 PyObject * obj6 = 0 ;
6327 PyObject * obj7 = 0 ;
6328 PyObject * obj8 = 0 ;
6329 char * kwnames[] = {
6330 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6331 };
6332
6333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6334 {
6335 arg1 = wxString_in_helper(obj0);
6336 if (arg1 == NULL) SWIG_fail;
6337 temp1 = true;
6338 }
6339 {
6340 arg2 = wxString_in_helper(obj1);
6341 if (arg2 == NULL) SWIG_fail;
6342 temp2 = true;
6343 }
6344 {
6345 arg3 = PyList_Size(obj2);
6346 arg4 = wxString_LIST_helper(obj2);
6347 if (arg4 == NULL) SWIG_fail;
6348 }
6349 if (obj3) {
6350 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6351 if (!SWIG_IsOK(res5)) {
6352 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6353 }
6354 arg5 = reinterpret_cast< wxWindow * >(argp5);
6355 }
6356 if (obj4) {
6357 ecode6 = SWIG_AsVal_int(obj4, &val6);
6358 if (!SWIG_IsOK(ecode6)) {
6359 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6360 }
6361 arg6 = static_cast< int >(val6);
6362 }
6363 if (obj5) {
6364 ecode7 = SWIG_AsVal_int(obj5, &val7);
6365 if (!SWIG_IsOK(ecode7)) {
6366 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6367 }
6368 arg7 = static_cast< int >(val7);
6369 }
6370 if (obj6) {
6371 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6372 if (!SWIG_IsOK(ecode8)) {
6373 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6374 }
6375 arg8 = static_cast< bool >(val8);
6376 }
6377 if (obj7) {
6378 ecode9 = SWIG_AsVal_int(obj7, &val9);
6379 if (!SWIG_IsOK(ecode9)) {
6380 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6381 }
6382 arg9 = static_cast< int >(val9);
6383 }
6384 if (obj8) {
6385 ecode10 = SWIG_AsVal_int(obj8, &val10);
6386 if (!SWIG_IsOK(ecode10)) {
6387 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6388 }
6389 arg10 = static_cast< int >(val10);
6390 }
6391 {
6392 if (!wxPyCheckForApp()) SWIG_fail;
6393 PyThreadState* __tstate = wxPyBeginAllowThreads();
6394 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6395 wxPyEndAllowThreads(__tstate);
6396 if (PyErr_Occurred()) SWIG_fail;
6397 }
6398 resultobj = SWIG_From_int(static_cast< int >(result));
6399 {
6400 if (temp1)
6401 delete arg1;
6402 }
6403 {
6404 if (temp2)
6405 delete arg2;
6406 }
6407 {
6408 if (arg4) delete [] arg4;
6409 }
6410 return resultobj;
6411 fail:
6412 {
6413 if (temp1)
6414 delete arg1;
6415 }
6416 {
6417 if (temp2)
6418 delete arg2;
6419 }
6420 {
6421 if (arg4) delete [] arg4;
6422 }
6423 return NULL;
6424 }
6425
6426
6427 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6428 PyObject *resultobj = 0;
6429 wxString *arg1 = 0 ;
6430 wxString const &arg2_defvalue = wxPyEmptyString ;
6431 wxString *arg2 = (wxString *) &arg2_defvalue ;
6432 int arg3 = (int) wxOK|wxCENTRE ;
6433 wxWindow *arg4 = (wxWindow *) NULL ;
6434 int arg5 = (int) -1 ;
6435 int arg6 = (int) -1 ;
6436 int result;
6437 bool temp1 = false ;
6438 bool temp2 = false ;
6439 int val3 ;
6440 int ecode3 = 0 ;
6441 void *argp4 = 0 ;
6442 int res4 = 0 ;
6443 int val5 ;
6444 int ecode5 = 0 ;
6445 int val6 ;
6446 int ecode6 = 0 ;
6447 PyObject * obj0 = 0 ;
6448 PyObject * obj1 = 0 ;
6449 PyObject * obj2 = 0 ;
6450 PyObject * obj3 = 0 ;
6451 PyObject * obj4 = 0 ;
6452 PyObject * obj5 = 0 ;
6453 char * kwnames[] = {
6454 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6455 };
6456
6457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6458 {
6459 arg1 = wxString_in_helper(obj0);
6460 if (arg1 == NULL) SWIG_fail;
6461 temp1 = true;
6462 }
6463 if (obj1) {
6464 {
6465 arg2 = wxString_in_helper(obj1);
6466 if (arg2 == NULL) SWIG_fail;
6467 temp2 = true;
6468 }
6469 }
6470 if (obj2) {
6471 ecode3 = SWIG_AsVal_int(obj2, &val3);
6472 if (!SWIG_IsOK(ecode3)) {
6473 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6474 }
6475 arg3 = static_cast< int >(val3);
6476 }
6477 if (obj3) {
6478 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6479 if (!SWIG_IsOK(res4)) {
6480 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6481 }
6482 arg4 = reinterpret_cast< wxWindow * >(argp4);
6483 }
6484 if (obj4) {
6485 ecode5 = SWIG_AsVal_int(obj4, &val5);
6486 if (!SWIG_IsOK(ecode5)) {
6487 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6488 }
6489 arg5 = static_cast< int >(val5);
6490 }
6491 if (obj5) {
6492 ecode6 = SWIG_AsVal_int(obj5, &val6);
6493 if (!SWIG_IsOK(ecode6)) {
6494 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6495 }
6496 arg6 = static_cast< int >(val6);
6497 }
6498 {
6499 if (!wxPyCheckForApp()) SWIG_fail;
6500 PyThreadState* __tstate = wxPyBeginAllowThreads();
6501 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6502 wxPyEndAllowThreads(__tstate);
6503 if (PyErr_Occurred()) SWIG_fail;
6504 }
6505 resultobj = SWIG_From_int(static_cast< int >(result));
6506 {
6507 if (temp1)
6508 delete arg1;
6509 }
6510 {
6511 if (temp2)
6512 delete arg2;
6513 }
6514 return resultobj;
6515 fail:
6516 {
6517 if (temp1)
6518 delete arg1;
6519 }
6520 {
6521 if (temp2)
6522 delete arg2;
6523 }
6524 return NULL;
6525 }
6526
6527
6528 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6529 PyObject *resultobj = 0;
6530 bool result;
6531
6532 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6533 {
6534 if (!wxPyCheckForApp()) SWIG_fail;
6535 PyThreadState* __tstate = wxPyBeginAllowThreads();
6536 result = (bool)wxColourDisplay();
6537 wxPyEndAllowThreads(__tstate);
6538 if (PyErr_Occurred()) SWIG_fail;
6539 }
6540 {
6541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6542 }
6543 return resultobj;
6544 fail:
6545 return NULL;
6546 }
6547
6548
6549 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6550 PyObject *resultobj = 0;
6551 int result;
6552
6553 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6554 {
6555 if (!wxPyCheckForApp()) SWIG_fail;
6556 PyThreadState* __tstate = wxPyBeginAllowThreads();
6557 result = (int)wxDisplayDepth();
6558 wxPyEndAllowThreads(__tstate);
6559 if (PyErr_Occurred()) SWIG_fail;
6560 }
6561 resultobj = SWIG_From_int(static_cast< int >(result));
6562 return resultobj;
6563 fail:
6564 return NULL;
6565 }
6566
6567
6568 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6569 PyObject *resultobj = 0;
6570 int result;
6571
6572 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6573 {
6574 if (!wxPyCheckForApp()) SWIG_fail;
6575 PyThreadState* __tstate = wxPyBeginAllowThreads();
6576 result = (int)wxGetDisplayDepth();
6577 wxPyEndAllowThreads(__tstate);
6578 if (PyErr_Occurred()) SWIG_fail;
6579 }
6580 resultobj = SWIG_From_int(static_cast< int >(result));
6581 return resultobj;
6582 fail:
6583 return NULL;
6584 }
6585
6586
6587 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6588 PyObject *resultobj = 0;
6589 int *arg1 = (int *) 0 ;
6590 int *arg2 = (int *) 0 ;
6591 int temp1 ;
6592 int res1 = SWIG_TMPOBJ ;
6593 int temp2 ;
6594 int res2 = SWIG_TMPOBJ ;
6595
6596 arg1 = &temp1;
6597 arg2 = &temp2;
6598 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6599 {
6600 if (!wxPyCheckForApp()) SWIG_fail;
6601 PyThreadState* __tstate = wxPyBeginAllowThreads();
6602 wxDisplaySize(arg1,arg2);
6603 wxPyEndAllowThreads(__tstate);
6604 if (PyErr_Occurred()) SWIG_fail;
6605 }
6606 resultobj = SWIG_Py_Void();
6607 if (SWIG_IsTmpObj(res1)) {
6608 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6609 } else {
6610 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6611 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6612 }
6613 if (SWIG_IsTmpObj(res2)) {
6614 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6615 } else {
6616 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6618 }
6619 return resultobj;
6620 fail:
6621 return NULL;
6622 }
6623
6624
6625 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6626 PyObject *resultobj = 0;
6627 wxSize result;
6628
6629 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6630 {
6631 if (!wxPyCheckForApp()) SWIG_fail;
6632 PyThreadState* __tstate = wxPyBeginAllowThreads();
6633 result = wxGetDisplaySize();
6634 wxPyEndAllowThreads(__tstate);
6635 if (PyErr_Occurred()) SWIG_fail;
6636 }
6637 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6638 return resultobj;
6639 fail:
6640 return NULL;
6641 }
6642
6643
6644 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6645 PyObject *resultobj = 0;
6646 int *arg1 = (int *) 0 ;
6647 int *arg2 = (int *) 0 ;
6648 int temp1 ;
6649 int res1 = SWIG_TMPOBJ ;
6650 int temp2 ;
6651 int res2 = SWIG_TMPOBJ ;
6652
6653 arg1 = &temp1;
6654 arg2 = &temp2;
6655 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6656 {
6657 if (!wxPyCheckForApp()) SWIG_fail;
6658 PyThreadState* __tstate = wxPyBeginAllowThreads();
6659 wxDisplaySizeMM(arg1,arg2);
6660 wxPyEndAllowThreads(__tstate);
6661 if (PyErr_Occurred()) SWIG_fail;
6662 }
6663 resultobj = SWIG_Py_Void();
6664 if (SWIG_IsTmpObj(res1)) {
6665 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6666 } else {
6667 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6668 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6669 }
6670 if (SWIG_IsTmpObj(res2)) {
6671 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6672 } else {
6673 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6674 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6675 }
6676 return resultobj;
6677 fail:
6678 return NULL;
6679 }
6680
6681
6682 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6683 PyObject *resultobj = 0;
6684 wxSize result;
6685
6686 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6687 {
6688 if (!wxPyCheckForApp()) SWIG_fail;
6689 PyThreadState* __tstate = wxPyBeginAllowThreads();
6690 result = wxGetDisplaySizeMM();
6691 wxPyEndAllowThreads(__tstate);
6692 if (PyErr_Occurred()) SWIG_fail;
6693 }
6694 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6695 return resultobj;
6696 fail:
6697 return NULL;
6698 }
6699
6700
6701 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6702 PyObject *resultobj = 0;
6703 int *arg1 = (int *) 0 ;
6704 int *arg2 = (int *) 0 ;
6705 int *arg3 = (int *) 0 ;
6706 int *arg4 = (int *) 0 ;
6707 int temp1 ;
6708 int res1 = SWIG_TMPOBJ ;
6709 int temp2 ;
6710 int res2 = SWIG_TMPOBJ ;
6711 int temp3 ;
6712 int res3 = SWIG_TMPOBJ ;
6713 int temp4 ;
6714 int res4 = SWIG_TMPOBJ ;
6715
6716 arg1 = &temp1;
6717 arg2 = &temp2;
6718 arg3 = &temp3;
6719 arg4 = &temp4;
6720 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6721 {
6722 if (!wxPyCheckForApp()) SWIG_fail;
6723 PyThreadState* __tstate = wxPyBeginAllowThreads();
6724 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6725 wxPyEndAllowThreads(__tstate);
6726 if (PyErr_Occurred()) SWIG_fail;
6727 }
6728 resultobj = SWIG_Py_Void();
6729 if (SWIG_IsTmpObj(res1)) {
6730 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6731 } else {
6732 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6733 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6734 }
6735 if (SWIG_IsTmpObj(res2)) {
6736 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6737 } else {
6738 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6739 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6740 }
6741 if (SWIG_IsTmpObj(res3)) {
6742 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6743 } else {
6744 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6745 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6746 }
6747 if (SWIG_IsTmpObj(res4)) {
6748 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6749 } else {
6750 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6751 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6752 }
6753 return resultobj;
6754 fail:
6755 return NULL;
6756 }
6757
6758
6759 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6760 PyObject *resultobj = 0;
6761 wxRect result;
6762
6763 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6764 {
6765 if (!wxPyCheckForApp()) SWIG_fail;
6766 PyThreadState* __tstate = wxPyBeginAllowThreads();
6767 result = wxGetClientDisplayRect();
6768 wxPyEndAllowThreads(__tstate);
6769 if (PyErr_Occurred()) SWIG_fail;
6770 }
6771 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6772 return resultobj;
6773 fail:
6774 return NULL;
6775 }
6776
6777
6778 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6779 PyObject *resultobj = 0;
6780 wxCursor *arg1 = 0 ;
6781 void *argp1 = 0 ;
6782 int res1 = 0 ;
6783 PyObject * obj0 = 0 ;
6784 char * kwnames[] = {
6785 (char *) "cursor", NULL
6786 };
6787
6788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6789 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6790 if (!SWIG_IsOK(res1)) {
6791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6792 }
6793 if (!argp1) {
6794 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6795 }
6796 arg1 = reinterpret_cast< wxCursor * >(argp1);
6797 {
6798 if (!wxPyCheckForApp()) SWIG_fail;
6799 PyThreadState* __tstate = wxPyBeginAllowThreads();
6800 wxSetCursor(*arg1);
6801 wxPyEndAllowThreads(__tstate);
6802 if (PyErr_Occurred()) SWIG_fail;
6803 }
6804 resultobj = SWIG_Py_Void();
6805 return resultobj;
6806 fail:
6807 return NULL;
6808 }
6809
6810
6811 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6812 PyObject *resultobj = 0;
6813 void *result = 0 ;
6814
6815 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
6816 {
6817 if (!wxPyCheckForApp()) SWIG_fail;
6818 PyThreadState* __tstate = wxPyBeginAllowThreads();
6819 result = (void *)wxGetXDisplay();
6820 wxPyEndAllowThreads(__tstate);
6821 if (PyErr_Occurred()) SWIG_fail;
6822 }
6823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
6824 return resultobj;
6825 fail:
6826 return NULL;
6827 }
6828
6829
6830 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6831 PyObject *resultobj = 0;
6832 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6833 void *argp1 = 0 ;
6834 int res1 = 0 ;
6835 PyObject * obj0 = 0 ;
6836 char * kwnames[] = {
6837 (char *) "cursor", NULL
6838 };
6839
6840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
6841 if (obj0) {
6842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
6843 if (!SWIG_IsOK(res1)) {
6844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
6845 }
6846 arg1 = reinterpret_cast< wxCursor * >(argp1);
6847 }
6848 {
6849 if (!wxPyCheckForApp()) SWIG_fail;
6850 PyThreadState* __tstate = wxPyBeginAllowThreads();
6851 wxBeginBusyCursor(arg1);
6852 wxPyEndAllowThreads(__tstate);
6853 if (PyErr_Occurred()) SWIG_fail;
6854 }
6855 resultobj = SWIG_Py_Void();
6856 return resultobj;
6857 fail:
6858 return NULL;
6859 }
6860
6861
6862 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6863 PyObject *resultobj = 0;
6864 wxPoint result;
6865
6866 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
6867 {
6868 if (!wxPyCheckForApp()) SWIG_fail;
6869 PyThreadState* __tstate = wxPyBeginAllowThreads();
6870 result = wxGetMousePosition();
6871 wxPyEndAllowThreads(__tstate);
6872 if (PyErr_Occurred()) SWIG_fail;
6873 }
6874 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6875 return resultobj;
6876 fail:
6877 return NULL;
6878 }
6879
6880
6881 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6882 PyObject *resultobj = 0;
6883 wxWindow *result = 0 ;
6884
6885 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
6886 {
6887 if (!wxPyCheckForApp()) SWIG_fail;
6888 PyThreadState* __tstate = wxPyBeginAllowThreads();
6889 result = (wxWindow *)FindWindowAtPointer();
6890 wxPyEndAllowThreads(__tstate);
6891 if (PyErr_Occurred()) SWIG_fail;
6892 }
6893 {
6894 resultobj = wxPyMake_wxObject(result, 0);
6895 }
6896 return resultobj;
6897 fail:
6898 return NULL;
6899 }
6900
6901
6902 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6903 PyObject *resultobj = 0;
6904 wxWindow *result = 0 ;
6905
6906 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
6907 {
6908 if (!wxPyCheckForApp()) SWIG_fail;
6909 PyThreadState* __tstate = wxPyBeginAllowThreads();
6910 result = (wxWindow *)wxGetActiveWindow();
6911 wxPyEndAllowThreads(__tstate);
6912 if (PyErr_Occurred()) SWIG_fail;
6913 }
6914 {
6915 resultobj = wxPyMake_wxObject(result, 0);
6916 }
6917 return resultobj;
6918 fail:
6919 return NULL;
6920 }
6921
6922
6923 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6924 PyObject *resultobj = 0;
6925 wxPoint *arg1 = 0 ;
6926 wxWindow *result = 0 ;
6927 wxPoint temp1 ;
6928 PyObject * obj0 = 0 ;
6929 char * kwnames[] = {
6930 (char *) "pt", NULL
6931 };
6932
6933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6934 {
6935 arg1 = &temp1;
6936 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6937 }
6938 {
6939 if (!wxPyCheckForApp()) SWIG_fail;
6940 PyThreadState* __tstate = wxPyBeginAllowThreads();
6941 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
6942 wxPyEndAllowThreads(__tstate);
6943 if (PyErr_Occurred()) SWIG_fail;
6944 }
6945 {
6946 resultobj = wxPyMake_wxObject(result, 0);
6947 }
6948 return resultobj;
6949 fail:
6950 return NULL;
6951 }
6952
6953
6954 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6955 PyObject *resultobj = 0;
6956 wxPoint *arg1 = 0 ;
6957 wxWindow *result = 0 ;
6958 wxPoint temp1 ;
6959 PyObject * obj0 = 0 ;
6960 char * kwnames[] = {
6961 (char *) "pt", NULL
6962 };
6963
6964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6965 {
6966 arg1 = &temp1;
6967 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6968 }
6969 {
6970 if (!wxPyCheckForApp()) SWIG_fail;
6971 PyThreadState* __tstate = wxPyBeginAllowThreads();
6972 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6973 wxPyEndAllowThreads(__tstate);
6974 if (PyErr_Occurred()) SWIG_fail;
6975 }
6976 {
6977 resultobj = wxPyMake_wxObject(result, 0);
6978 }
6979 return resultobj;
6980 fail:
6981 return NULL;
6982 }
6983
6984
6985 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6986 PyObject *resultobj = 0;
6987 wxWindow *arg1 = (wxWindow *) 0 ;
6988 wxWindow *result = 0 ;
6989 void *argp1 = 0 ;
6990 int res1 = 0 ;
6991 PyObject * obj0 = 0 ;
6992 char * kwnames[] = {
6993 (char *) "win", NULL
6994 };
6995
6996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
6997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
6998 if (!SWIG_IsOK(res1)) {
6999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7000 }
7001 arg1 = reinterpret_cast< wxWindow * >(argp1);
7002 {
7003 if (!wxPyCheckForApp()) SWIG_fail;
7004 PyThreadState* __tstate = wxPyBeginAllowThreads();
7005 result = (wxWindow *)wxGetTopLevelParent(arg1);
7006 wxPyEndAllowThreads(__tstate);
7007 if (PyErr_Occurred()) SWIG_fail;
7008 }
7009 {
7010 resultobj = wxPyMake_wxObject(result, 0);
7011 }
7012 return resultobj;
7013 fail:
7014 return NULL;
7015 }
7016
7017
7018 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7019 PyObject *resultobj = 0;
7020 wxString *arg1 = 0 ;
7021 bool result;
7022 bool temp1 = false ;
7023 PyObject * obj0 = 0 ;
7024 char * kwnames[] = {
7025 (char *) "url", NULL
7026 };
7027
7028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7029 {
7030 arg1 = wxString_in_helper(obj0);
7031 if (arg1 == NULL) SWIG_fail;
7032 temp1 = true;
7033 }
7034 {
7035 PyThreadState* __tstate = wxPyBeginAllowThreads();
7036 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7037 wxPyEndAllowThreads(__tstate);
7038 if (PyErr_Occurred()) SWIG_fail;
7039 }
7040 {
7041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7042 }
7043 {
7044 if (temp1)
7045 delete arg1;
7046 }
7047 return resultobj;
7048 fail:
7049 {
7050 if (temp1)
7051 delete arg1;
7052 }
7053 return NULL;
7054 }
7055
7056
7057 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7058 PyObject *resultobj = 0;
7059 wxKeyCode arg1 ;
7060 bool result;
7061 int val1 ;
7062 int ecode1 = 0 ;
7063 PyObject * obj0 = 0 ;
7064 char * kwnames[] = {
7065 (char *) "key", NULL
7066 };
7067
7068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7069 ecode1 = SWIG_AsVal_int(obj0, &val1);
7070 if (!SWIG_IsOK(ecode1)) {
7071 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7072 }
7073 arg1 = static_cast< wxKeyCode >(val1);
7074 {
7075 if (!wxPyCheckForApp()) SWIG_fail;
7076 PyThreadState* __tstate = wxPyBeginAllowThreads();
7077 result = (bool)wxGetKeyState(arg1);
7078 wxPyEndAllowThreads(__tstate);
7079 if (PyErr_Occurred()) SWIG_fail;
7080 }
7081 {
7082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7083 }
7084 return resultobj;
7085 fail:
7086 return NULL;
7087 }
7088
7089
7090 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7091 PyObject *resultobj = 0;
7092 wxMouseState *result = 0 ;
7093
7094 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7095 {
7096 PyThreadState* __tstate = wxPyBeginAllowThreads();
7097 result = (wxMouseState *)new wxMouseState();
7098 wxPyEndAllowThreads(__tstate);
7099 if (PyErr_Occurred()) SWIG_fail;
7100 }
7101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7102 return resultobj;
7103 fail:
7104 return NULL;
7105 }
7106
7107
7108 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7109 PyObject *resultobj = 0;
7110 wxMouseState *arg1 = (wxMouseState *) 0 ;
7111 void *argp1 = 0 ;
7112 int res1 = 0 ;
7113 PyObject *swig_obj[1] ;
7114
7115 if (!args) SWIG_fail;
7116 swig_obj[0] = args;
7117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7118 if (!SWIG_IsOK(res1)) {
7119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7120 }
7121 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7122 {
7123 PyThreadState* __tstate = wxPyBeginAllowThreads();
7124 delete arg1;
7125
7126 wxPyEndAllowThreads(__tstate);
7127 if (PyErr_Occurred()) SWIG_fail;
7128 }
7129 resultobj = SWIG_Py_Void();
7130 return resultobj;
7131 fail:
7132 return NULL;
7133 }
7134
7135
7136 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7137 PyObject *resultobj = 0;
7138 wxMouseState *arg1 = (wxMouseState *) 0 ;
7139 int result;
7140 void *argp1 = 0 ;
7141 int res1 = 0 ;
7142 PyObject *swig_obj[1] ;
7143
7144 if (!args) SWIG_fail;
7145 swig_obj[0] = args;
7146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7147 if (!SWIG_IsOK(res1)) {
7148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7149 }
7150 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7151 {
7152 PyThreadState* __tstate = wxPyBeginAllowThreads();
7153 result = (int)(arg1)->GetX();
7154 wxPyEndAllowThreads(__tstate);
7155 if (PyErr_Occurred()) SWIG_fail;
7156 }
7157 resultobj = SWIG_From_int(static_cast< int >(result));
7158 return resultobj;
7159 fail:
7160 return NULL;
7161 }
7162
7163
7164 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7165 PyObject *resultobj = 0;
7166 wxMouseState *arg1 = (wxMouseState *) 0 ;
7167 int result;
7168 void *argp1 = 0 ;
7169 int res1 = 0 ;
7170 PyObject *swig_obj[1] ;
7171
7172 if (!args) SWIG_fail;
7173 swig_obj[0] = args;
7174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7175 if (!SWIG_IsOK(res1)) {
7176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7177 }
7178 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7179 {
7180 PyThreadState* __tstate = wxPyBeginAllowThreads();
7181 result = (int)(arg1)->GetY();
7182 wxPyEndAllowThreads(__tstate);
7183 if (PyErr_Occurred()) SWIG_fail;
7184 }
7185 resultobj = SWIG_From_int(static_cast< int >(result));
7186 return resultobj;
7187 fail:
7188 return NULL;
7189 }
7190
7191
7192 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7193 PyObject *resultobj = 0;
7194 wxMouseState *arg1 = (wxMouseState *) 0 ;
7195 bool result;
7196 void *argp1 = 0 ;
7197 int res1 = 0 ;
7198 PyObject *swig_obj[1] ;
7199
7200 if (!args) SWIG_fail;
7201 swig_obj[0] = args;
7202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7203 if (!SWIG_IsOK(res1)) {
7204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7205 }
7206 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7207 {
7208 PyThreadState* __tstate = wxPyBeginAllowThreads();
7209 result = (bool)(arg1)->LeftDown();
7210 wxPyEndAllowThreads(__tstate);
7211 if (PyErr_Occurred()) SWIG_fail;
7212 }
7213 {
7214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7215 }
7216 return resultobj;
7217 fail:
7218 return NULL;
7219 }
7220
7221
7222 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7223 PyObject *resultobj = 0;
7224 wxMouseState *arg1 = (wxMouseState *) 0 ;
7225 bool result;
7226 void *argp1 = 0 ;
7227 int res1 = 0 ;
7228 PyObject *swig_obj[1] ;
7229
7230 if (!args) SWIG_fail;
7231 swig_obj[0] = args;
7232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7233 if (!SWIG_IsOK(res1)) {
7234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7235 }
7236 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7237 {
7238 PyThreadState* __tstate = wxPyBeginAllowThreads();
7239 result = (bool)(arg1)->MiddleDown();
7240 wxPyEndAllowThreads(__tstate);
7241 if (PyErr_Occurred()) SWIG_fail;
7242 }
7243 {
7244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7245 }
7246 return resultobj;
7247 fail:
7248 return NULL;
7249 }
7250
7251
7252 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7253 PyObject *resultobj = 0;
7254 wxMouseState *arg1 = (wxMouseState *) 0 ;
7255 bool result;
7256 void *argp1 = 0 ;
7257 int res1 = 0 ;
7258 PyObject *swig_obj[1] ;
7259
7260 if (!args) SWIG_fail;
7261 swig_obj[0] = args;
7262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7263 if (!SWIG_IsOK(res1)) {
7264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7265 }
7266 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7267 {
7268 PyThreadState* __tstate = wxPyBeginAllowThreads();
7269 result = (bool)(arg1)->RightDown();
7270 wxPyEndAllowThreads(__tstate);
7271 if (PyErr_Occurred()) SWIG_fail;
7272 }
7273 {
7274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7275 }
7276 return resultobj;
7277 fail:
7278 return NULL;
7279 }
7280
7281
7282 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7283 PyObject *resultobj = 0;
7284 wxMouseState *arg1 = (wxMouseState *) 0 ;
7285 bool result;
7286 void *argp1 = 0 ;
7287 int res1 = 0 ;
7288 PyObject *swig_obj[1] ;
7289
7290 if (!args) SWIG_fail;
7291 swig_obj[0] = args;
7292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7293 if (!SWIG_IsOK(res1)) {
7294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7295 }
7296 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7297 {
7298 PyThreadState* __tstate = wxPyBeginAllowThreads();
7299 result = (bool)(arg1)->ControlDown();
7300 wxPyEndAllowThreads(__tstate);
7301 if (PyErr_Occurred()) SWIG_fail;
7302 }
7303 {
7304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7305 }
7306 return resultobj;
7307 fail:
7308 return NULL;
7309 }
7310
7311
7312 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7313 PyObject *resultobj = 0;
7314 wxMouseState *arg1 = (wxMouseState *) 0 ;
7315 bool result;
7316 void *argp1 = 0 ;
7317 int res1 = 0 ;
7318 PyObject *swig_obj[1] ;
7319
7320 if (!args) SWIG_fail;
7321 swig_obj[0] = args;
7322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7323 if (!SWIG_IsOK(res1)) {
7324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7325 }
7326 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7327 {
7328 PyThreadState* __tstate = wxPyBeginAllowThreads();
7329 result = (bool)(arg1)->ShiftDown();
7330 wxPyEndAllowThreads(__tstate);
7331 if (PyErr_Occurred()) SWIG_fail;
7332 }
7333 {
7334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7335 }
7336 return resultobj;
7337 fail:
7338 return NULL;
7339 }
7340
7341
7342 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7343 PyObject *resultobj = 0;
7344 wxMouseState *arg1 = (wxMouseState *) 0 ;
7345 bool result;
7346 void *argp1 = 0 ;
7347 int res1 = 0 ;
7348 PyObject *swig_obj[1] ;
7349
7350 if (!args) SWIG_fail;
7351 swig_obj[0] = args;
7352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7353 if (!SWIG_IsOK(res1)) {
7354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7355 }
7356 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7357 {
7358 PyThreadState* __tstate = wxPyBeginAllowThreads();
7359 result = (bool)(arg1)->AltDown();
7360 wxPyEndAllowThreads(__tstate);
7361 if (PyErr_Occurred()) SWIG_fail;
7362 }
7363 {
7364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7365 }
7366 return resultobj;
7367 fail:
7368 return NULL;
7369 }
7370
7371
7372 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7373 PyObject *resultobj = 0;
7374 wxMouseState *arg1 = (wxMouseState *) 0 ;
7375 bool result;
7376 void *argp1 = 0 ;
7377 int res1 = 0 ;
7378 PyObject *swig_obj[1] ;
7379
7380 if (!args) SWIG_fail;
7381 swig_obj[0] = args;
7382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7383 if (!SWIG_IsOK(res1)) {
7384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7385 }
7386 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7387 {
7388 PyThreadState* __tstate = wxPyBeginAllowThreads();
7389 result = (bool)(arg1)->MetaDown();
7390 wxPyEndAllowThreads(__tstate);
7391 if (PyErr_Occurred()) SWIG_fail;
7392 }
7393 {
7394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7395 }
7396 return resultobj;
7397 fail:
7398 return NULL;
7399 }
7400
7401
7402 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7403 PyObject *resultobj = 0;
7404 wxMouseState *arg1 = (wxMouseState *) 0 ;
7405 bool result;
7406 void *argp1 = 0 ;
7407 int res1 = 0 ;
7408 PyObject *swig_obj[1] ;
7409
7410 if (!args) SWIG_fail;
7411 swig_obj[0] = args;
7412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7413 if (!SWIG_IsOK(res1)) {
7414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7415 }
7416 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7417 {
7418 PyThreadState* __tstate = wxPyBeginAllowThreads();
7419 result = (bool)(arg1)->CmdDown();
7420 wxPyEndAllowThreads(__tstate);
7421 if (PyErr_Occurred()) SWIG_fail;
7422 }
7423 {
7424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7425 }
7426 return resultobj;
7427 fail:
7428 return NULL;
7429 }
7430
7431
7432 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7433 PyObject *resultobj = 0;
7434 wxMouseState *arg1 = (wxMouseState *) 0 ;
7435 int arg2 ;
7436 void *argp1 = 0 ;
7437 int res1 = 0 ;
7438 int val2 ;
7439 int ecode2 = 0 ;
7440 PyObject * obj0 = 0 ;
7441 PyObject * obj1 = 0 ;
7442 char * kwnames[] = {
7443 (char *) "self",(char *) "x", NULL
7444 };
7445
7446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7448 if (!SWIG_IsOK(res1)) {
7449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7450 }
7451 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7452 ecode2 = SWIG_AsVal_int(obj1, &val2);
7453 if (!SWIG_IsOK(ecode2)) {
7454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7455 }
7456 arg2 = static_cast< int >(val2);
7457 {
7458 PyThreadState* __tstate = wxPyBeginAllowThreads();
7459 (arg1)->SetX(arg2);
7460 wxPyEndAllowThreads(__tstate);
7461 if (PyErr_Occurred()) SWIG_fail;
7462 }
7463 resultobj = SWIG_Py_Void();
7464 return resultobj;
7465 fail:
7466 return NULL;
7467 }
7468
7469
7470 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7471 PyObject *resultobj = 0;
7472 wxMouseState *arg1 = (wxMouseState *) 0 ;
7473 int arg2 ;
7474 void *argp1 = 0 ;
7475 int res1 = 0 ;
7476 int val2 ;
7477 int ecode2 = 0 ;
7478 PyObject * obj0 = 0 ;
7479 PyObject * obj1 = 0 ;
7480 char * kwnames[] = {
7481 (char *) "self",(char *) "y", NULL
7482 };
7483
7484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7486 if (!SWIG_IsOK(res1)) {
7487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7488 }
7489 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7490 ecode2 = SWIG_AsVal_int(obj1, &val2);
7491 if (!SWIG_IsOK(ecode2)) {
7492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7493 }
7494 arg2 = static_cast< int >(val2);
7495 {
7496 PyThreadState* __tstate = wxPyBeginAllowThreads();
7497 (arg1)->SetY(arg2);
7498 wxPyEndAllowThreads(__tstate);
7499 if (PyErr_Occurred()) SWIG_fail;
7500 }
7501 resultobj = SWIG_Py_Void();
7502 return resultobj;
7503 fail:
7504 return NULL;
7505 }
7506
7507
7508 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7509 PyObject *resultobj = 0;
7510 wxMouseState *arg1 = (wxMouseState *) 0 ;
7511 bool arg2 ;
7512 void *argp1 = 0 ;
7513 int res1 = 0 ;
7514 bool val2 ;
7515 int ecode2 = 0 ;
7516 PyObject * obj0 = 0 ;
7517 PyObject * obj1 = 0 ;
7518 char * kwnames[] = {
7519 (char *) "self",(char *) "down", NULL
7520 };
7521
7522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7524 if (!SWIG_IsOK(res1)) {
7525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7526 }
7527 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7528 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7529 if (!SWIG_IsOK(ecode2)) {
7530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7531 }
7532 arg2 = static_cast< bool >(val2);
7533 {
7534 PyThreadState* __tstate = wxPyBeginAllowThreads();
7535 (arg1)->SetLeftDown(arg2);
7536 wxPyEndAllowThreads(__tstate);
7537 if (PyErr_Occurred()) SWIG_fail;
7538 }
7539 resultobj = SWIG_Py_Void();
7540 return resultobj;
7541 fail:
7542 return NULL;
7543 }
7544
7545
7546 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7547 PyObject *resultobj = 0;
7548 wxMouseState *arg1 = (wxMouseState *) 0 ;
7549 bool arg2 ;
7550 void *argp1 = 0 ;
7551 int res1 = 0 ;
7552 bool val2 ;
7553 int ecode2 = 0 ;
7554 PyObject * obj0 = 0 ;
7555 PyObject * obj1 = 0 ;
7556 char * kwnames[] = {
7557 (char *) "self",(char *) "down", NULL
7558 };
7559
7560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7562 if (!SWIG_IsOK(res1)) {
7563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7564 }
7565 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7566 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7567 if (!SWIG_IsOK(ecode2)) {
7568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7569 }
7570 arg2 = static_cast< bool >(val2);
7571 {
7572 PyThreadState* __tstate = wxPyBeginAllowThreads();
7573 (arg1)->SetMiddleDown(arg2);
7574 wxPyEndAllowThreads(__tstate);
7575 if (PyErr_Occurred()) SWIG_fail;
7576 }
7577 resultobj = SWIG_Py_Void();
7578 return resultobj;
7579 fail:
7580 return NULL;
7581 }
7582
7583
7584 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7585 PyObject *resultobj = 0;
7586 wxMouseState *arg1 = (wxMouseState *) 0 ;
7587 bool arg2 ;
7588 void *argp1 = 0 ;
7589 int res1 = 0 ;
7590 bool val2 ;
7591 int ecode2 = 0 ;
7592 PyObject * obj0 = 0 ;
7593 PyObject * obj1 = 0 ;
7594 char * kwnames[] = {
7595 (char *) "self",(char *) "down", NULL
7596 };
7597
7598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7600 if (!SWIG_IsOK(res1)) {
7601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7602 }
7603 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7604 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7605 if (!SWIG_IsOK(ecode2)) {
7606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7607 }
7608 arg2 = static_cast< bool >(val2);
7609 {
7610 PyThreadState* __tstate = wxPyBeginAllowThreads();
7611 (arg1)->SetRightDown(arg2);
7612 wxPyEndAllowThreads(__tstate);
7613 if (PyErr_Occurred()) SWIG_fail;
7614 }
7615 resultobj = SWIG_Py_Void();
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7623 PyObject *resultobj = 0;
7624 wxMouseState *arg1 = (wxMouseState *) 0 ;
7625 bool arg2 ;
7626 void *argp1 = 0 ;
7627 int res1 = 0 ;
7628 bool val2 ;
7629 int ecode2 = 0 ;
7630 PyObject * obj0 = 0 ;
7631 PyObject * obj1 = 0 ;
7632 char * kwnames[] = {
7633 (char *) "self",(char *) "down", NULL
7634 };
7635
7636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7638 if (!SWIG_IsOK(res1)) {
7639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7640 }
7641 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7642 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7643 if (!SWIG_IsOK(ecode2)) {
7644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7645 }
7646 arg2 = static_cast< bool >(val2);
7647 {
7648 PyThreadState* __tstate = wxPyBeginAllowThreads();
7649 (arg1)->SetControlDown(arg2);
7650 wxPyEndAllowThreads(__tstate);
7651 if (PyErr_Occurred()) SWIG_fail;
7652 }
7653 resultobj = SWIG_Py_Void();
7654 return resultobj;
7655 fail:
7656 return NULL;
7657 }
7658
7659
7660 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7661 PyObject *resultobj = 0;
7662 wxMouseState *arg1 = (wxMouseState *) 0 ;
7663 bool arg2 ;
7664 void *argp1 = 0 ;
7665 int res1 = 0 ;
7666 bool val2 ;
7667 int ecode2 = 0 ;
7668 PyObject * obj0 = 0 ;
7669 PyObject * obj1 = 0 ;
7670 char * kwnames[] = {
7671 (char *) "self",(char *) "down", NULL
7672 };
7673
7674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7676 if (!SWIG_IsOK(res1)) {
7677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7678 }
7679 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7680 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7681 if (!SWIG_IsOK(ecode2)) {
7682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7683 }
7684 arg2 = static_cast< bool >(val2);
7685 {
7686 PyThreadState* __tstate = wxPyBeginAllowThreads();
7687 (arg1)->SetShiftDown(arg2);
7688 wxPyEndAllowThreads(__tstate);
7689 if (PyErr_Occurred()) SWIG_fail;
7690 }
7691 resultobj = SWIG_Py_Void();
7692 return resultobj;
7693 fail:
7694 return NULL;
7695 }
7696
7697
7698 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7699 PyObject *resultobj = 0;
7700 wxMouseState *arg1 = (wxMouseState *) 0 ;
7701 bool arg2 ;
7702 void *argp1 = 0 ;
7703 int res1 = 0 ;
7704 bool val2 ;
7705 int ecode2 = 0 ;
7706 PyObject * obj0 = 0 ;
7707 PyObject * obj1 = 0 ;
7708 char * kwnames[] = {
7709 (char *) "self",(char *) "down", NULL
7710 };
7711
7712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7714 if (!SWIG_IsOK(res1)) {
7715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7716 }
7717 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7718 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7719 if (!SWIG_IsOK(ecode2)) {
7720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7721 }
7722 arg2 = static_cast< bool >(val2);
7723 {
7724 PyThreadState* __tstate = wxPyBeginAllowThreads();
7725 (arg1)->SetAltDown(arg2);
7726 wxPyEndAllowThreads(__tstate);
7727 if (PyErr_Occurred()) SWIG_fail;
7728 }
7729 resultobj = SWIG_Py_Void();
7730 return resultobj;
7731 fail:
7732 return NULL;
7733 }
7734
7735
7736 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7737 PyObject *resultobj = 0;
7738 wxMouseState *arg1 = (wxMouseState *) 0 ;
7739 bool arg2 ;
7740 void *argp1 = 0 ;
7741 int res1 = 0 ;
7742 bool val2 ;
7743 int ecode2 = 0 ;
7744 PyObject * obj0 = 0 ;
7745 PyObject * obj1 = 0 ;
7746 char * kwnames[] = {
7747 (char *) "self",(char *) "down", NULL
7748 };
7749
7750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7752 if (!SWIG_IsOK(res1)) {
7753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7754 }
7755 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7756 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7757 if (!SWIG_IsOK(ecode2)) {
7758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7759 }
7760 arg2 = static_cast< bool >(val2);
7761 {
7762 PyThreadState* __tstate = wxPyBeginAllowThreads();
7763 (arg1)->SetMetaDown(arg2);
7764 wxPyEndAllowThreads(__tstate);
7765 if (PyErr_Occurred()) SWIG_fail;
7766 }
7767 resultobj = SWIG_Py_Void();
7768 return resultobj;
7769 fail:
7770 return NULL;
7771 }
7772
7773
7774 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7775 PyObject *obj;
7776 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7777 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7778 return SWIG_Py_Void();
7779 }
7780
7781 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7782 return SWIG_Python_InitShadowInstance(args);
7783 }
7784
7785 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7786 PyObject *resultobj = 0;
7787 wxMouseState result;
7788
7789 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7790 {
7791 PyThreadState* __tstate = wxPyBeginAllowThreads();
7792 result = wxGetMouseState();
7793 wxPyEndAllowThreads(__tstate);
7794 if (PyErr_Occurred()) SWIG_fail;
7795 }
7796 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7797 return resultobj;
7798 fail:
7799 return NULL;
7800 }
7801
7802
7803 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7804 PyObject *resultobj = 0;
7805
7806 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
7807 {
7808 if (!wxPyCheckForApp()) SWIG_fail;
7809 PyThreadState* __tstate = wxPyBeginAllowThreads();
7810 wxWakeUpMainThread();
7811 wxPyEndAllowThreads(__tstate);
7812 if (PyErr_Occurred()) SWIG_fail;
7813 }
7814 resultobj = SWIG_Py_Void();
7815 return resultobj;
7816 fail:
7817 return NULL;
7818 }
7819
7820
7821 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7822 PyObject *resultobj = 0;
7823
7824 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
7825 {
7826 if (!wxPyCheckForApp()) SWIG_fail;
7827 PyThreadState* __tstate = wxPyBeginAllowThreads();
7828 wxMutexGuiEnter();
7829 wxPyEndAllowThreads(__tstate);
7830 if (PyErr_Occurred()) SWIG_fail;
7831 }
7832 resultobj = SWIG_Py_Void();
7833 return resultobj;
7834 fail:
7835 return NULL;
7836 }
7837
7838
7839 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7840 PyObject *resultobj = 0;
7841
7842 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
7843 {
7844 if (!wxPyCheckForApp()) SWIG_fail;
7845 PyThreadState* __tstate = wxPyBeginAllowThreads();
7846 wxMutexGuiLeave();
7847 wxPyEndAllowThreads(__tstate);
7848 if (PyErr_Occurred()) SWIG_fail;
7849 }
7850 resultobj = SWIG_Py_Void();
7851 return resultobj;
7852 fail:
7853 return NULL;
7854 }
7855
7856
7857 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7858 PyObject *resultobj = 0;
7859 wxMutexGuiLocker *result = 0 ;
7860
7861 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
7862 {
7863 if (!wxPyCheckForApp()) SWIG_fail;
7864 PyThreadState* __tstate = wxPyBeginAllowThreads();
7865 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
7866 wxPyEndAllowThreads(__tstate);
7867 if (PyErr_Occurred()) SWIG_fail;
7868 }
7869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
7870 return resultobj;
7871 fail:
7872 return NULL;
7873 }
7874
7875
7876 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7877 PyObject *resultobj = 0;
7878 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
7879 void *argp1 = 0 ;
7880 int res1 = 0 ;
7881 PyObject *swig_obj[1] ;
7882
7883 if (!args) SWIG_fail;
7884 swig_obj[0] = args;
7885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
7886 if (!SWIG_IsOK(res1)) {
7887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
7888 }
7889 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
7890 {
7891 PyThreadState* __tstate = wxPyBeginAllowThreads();
7892 delete arg1;
7893
7894 wxPyEndAllowThreads(__tstate);
7895 if (PyErr_Occurred()) SWIG_fail;
7896 }
7897 resultobj = SWIG_Py_Void();
7898 return resultobj;
7899 fail:
7900 return NULL;
7901 }
7902
7903
7904 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7905 PyObject *obj;
7906 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7907 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
7908 return SWIG_Py_Void();
7909 }
7910
7911 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7912 return SWIG_Python_InitShadowInstance(args);
7913 }
7914
7915 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7916 PyObject *resultobj = 0;
7917 bool result;
7918
7919 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
7920 {
7921 PyThreadState* __tstate = wxPyBeginAllowThreads();
7922 result = (bool)wxThread_IsMain();
7923 wxPyEndAllowThreads(__tstate);
7924 if (PyErr_Occurred()) SWIG_fail;
7925 }
7926 {
7927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7928 }
7929 return resultobj;
7930 fail:
7931 return NULL;
7932 }
7933
7934
7935 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7936 PyObject *resultobj = 0;
7937 wxString *arg1 = 0 ;
7938 wxToolTip *result = 0 ;
7939 bool temp1 = false ;
7940 PyObject * obj0 = 0 ;
7941 char * kwnames[] = {
7942 (char *) "tip", NULL
7943 };
7944
7945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
7946 {
7947 arg1 = wxString_in_helper(obj0);
7948 if (arg1 == NULL) SWIG_fail;
7949 temp1 = true;
7950 }
7951 {
7952 if (!wxPyCheckForApp()) SWIG_fail;
7953 PyThreadState* __tstate = wxPyBeginAllowThreads();
7954 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
7955 wxPyEndAllowThreads(__tstate);
7956 if (PyErr_Occurred()) SWIG_fail;
7957 }
7958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
7959 {
7960 if (temp1)
7961 delete arg1;
7962 }
7963 return resultobj;
7964 fail:
7965 {
7966 if (temp1)
7967 delete arg1;
7968 }
7969 return NULL;
7970 }
7971
7972
7973 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7974 PyObject *resultobj = 0;
7975 wxToolTip *arg1 = (wxToolTip *) 0 ;
7976 void *argp1 = 0 ;
7977 int res1 = 0 ;
7978 PyObject *swig_obj[1] ;
7979
7980 if (!args) SWIG_fail;
7981 swig_obj[0] = args;
7982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
7983 if (!SWIG_IsOK(res1)) {
7984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
7985 }
7986 arg1 = reinterpret_cast< wxToolTip * >(argp1);
7987 {
7988 PyThreadState* __tstate = wxPyBeginAllowThreads();
7989 delete arg1;
7990
7991 wxPyEndAllowThreads(__tstate);
7992 if (PyErr_Occurred()) SWIG_fail;
7993 }
7994 resultobj = SWIG_Py_Void();
7995 return resultobj;
7996 fail:
7997 return NULL;
7998 }
7999
8000
8001 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8002 PyObject *resultobj = 0;
8003 wxToolTip *arg1 = (wxToolTip *) 0 ;
8004 wxString *arg2 = 0 ;
8005 void *argp1 = 0 ;
8006 int res1 = 0 ;
8007 bool temp2 = false ;
8008 PyObject * obj0 = 0 ;
8009 PyObject * obj1 = 0 ;
8010 char * kwnames[] = {
8011 (char *) "self",(char *) "tip", NULL
8012 };
8013
8014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8016 if (!SWIG_IsOK(res1)) {
8017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8018 }
8019 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8020 {
8021 arg2 = wxString_in_helper(obj1);
8022 if (arg2 == NULL) SWIG_fail;
8023 temp2 = true;
8024 }
8025 {
8026 PyThreadState* __tstate = wxPyBeginAllowThreads();
8027 (arg1)->SetTip((wxString const &)*arg2);
8028 wxPyEndAllowThreads(__tstate);
8029 if (PyErr_Occurred()) SWIG_fail;
8030 }
8031 resultobj = SWIG_Py_Void();
8032 {
8033 if (temp2)
8034 delete arg2;
8035 }
8036 return resultobj;
8037 fail:
8038 {
8039 if (temp2)
8040 delete arg2;
8041 }
8042 return NULL;
8043 }
8044
8045
8046 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8047 PyObject *resultobj = 0;
8048 wxToolTip *arg1 = (wxToolTip *) 0 ;
8049 wxString result;
8050 void *argp1 = 0 ;
8051 int res1 = 0 ;
8052 PyObject *swig_obj[1] ;
8053
8054 if (!args) SWIG_fail;
8055 swig_obj[0] = args;
8056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8057 if (!SWIG_IsOK(res1)) {
8058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8059 }
8060 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8061 {
8062 PyThreadState* __tstate = wxPyBeginAllowThreads();
8063 result = (arg1)->GetTip();
8064 wxPyEndAllowThreads(__tstate);
8065 if (PyErr_Occurred()) SWIG_fail;
8066 }
8067 {
8068 #if wxUSE_UNICODE
8069 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8070 #else
8071 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8072 #endif
8073 }
8074 return resultobj;
8075 fail:
8076 return NULL;
8077 }
8078
8079
8080 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8081 PyObject *resultobj = 0;
8082 wxToolTip *arg1 = (wxToolTip *) 0 ;
8083 wxWindow *result = 0 ;
8084 void *argp1 = 0 ;
8085 int res1 = 0 ;
8086 PyObject *swig_obj[1] ;
8087
8088 if (!args) SWIG_fail;
8089 swig_obj[0] = args;
8090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8091 if (!SWIG_IsOK(res1)) {
8092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8093 }
8094 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8095 {
8096 PyThreadState* __tstate = wxPyBeginAllowThreads();
8097 result = (wxWindow *)(arg1)->GetWindow();
8098 wxPyEndAllowThreads(__tstate);
8099 if (PyErr_Occurred()) SWIG_fail;
8100 }
8101 {
8102 resultobj = wxPyMake_wxObject(result, 0);
8103 }
8104 return resultobj;
8105 fail:
8106 return NULL;
8107 }
8108
8109
8110 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8111 PyObject *resultobj = 0;
8112 bool arg1 ;
8113 bool val1 ;
8114 int ecode1 = 0 ;
8115 PyObject * obj0 = 0 ;
8116 char * kwnames[] = {
8117 (char *) "flag", NULL
8118 };
8119
8120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8121 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8122 if (!SWIG_IsOK(ecode1)) {
8123 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8124 }
8125 arg1 = static_cast< bool >(val1);
8126 {
8127 PyThreadState* __tstate = wxPyBeginAllowThreads();
8128 wxToolTip::Enable(arg1);
8129 wxPyEndAllowThreads(__tstate);
8130 if (PyErr_Occurred()) SWIG_fail;
8131 }
8132 resultobj = SWIG_Py_Void();
8133 return resultobj;
8134 fail:
8135 return NULL;
8136 }
8137
8138
8139 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8140 PyObject *resultobj = 0;
8141 long arg1 ;
8142 long val1 ;
8143 int ecode1 = 0 ;
8144 PyObject * obj0 = 0 ;
8145 char * kwnames[] = {
8146 (char *) "milliseconds", NULL
8147 };
8148
8149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8150 ecode1 = SWIG_AsVal_long(obj0, &val1);
8151 if (!SWIG_IsOK(ecode1)) {
8152 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8153 }
8154 arg1 = static_cast< long >(val1);
8155 {
8156 PyThreadState* __tstate = wxPyBeginAllowThreads();
8157 wxToolTip::SetDelay(arg1);
8158 wxPyEndAllowThreads(__tstate);
8159 if (PyErr_Occurred()) SWIG_fail;
8160 }
8161 resultobj = SWIG_Py_Void();
8162 return resultobj;
8163 fail:
8164 return NULL;
8165 }
8166
8167
8168 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8169 PyObject *obj;
8170 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8171 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8172 return SWIG_Py_Void();
8173 }
8174
8175 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8176 return SWIG_Python_InitShadowInstance(args);
8177 }
8178
8179 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8180 PyObject *resultobj = 0;
8181 wxWindow *arg1 = (wxWindow *) 0 ;
8182 wxSize *arg2 = 0 ;
8183 wxCaret *result = 0 ;
8184 void *argp1 = 0 ;
8185 int res1 = 0 ;
8186 wxSize temp2 ;
8187 PyObject * obj0 = 0 ;
8188 PyObject * obj1 = 0 ;
8189 char * kwnames[] = {
8190 (char *) "window",(char *) "size", NULL
8191 };
8192
8193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8195 if (!SWIG_IsOK(res1)) {
8196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8197 }
8198 arg1 = reinterpret_cast< wxWindow * >(argp1);
8199 {
8200 arg2 = &temp2;
8201 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8202 }
8203 {
8204 if (!wxPyCheckForApp()) SWIG_fail;
8205 PyThreadState* __tstate = wxPyBeginAllowThreads();
8206 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8207 wxPyEndAllowThreads(__tstate);
8208 if (PyErr_Occurred()) SWIG_fail;
8209 }
8210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8211 return resultobj;
8212 fail:
8213 return NULL;
8214 }
8215
8216
8217 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8218 PyObject *resultobj = 0;
8219 wxCaret *arg1 = (wxCaret *) 0 ;
8220 void *argp1 = 0 ;
8221 int res1 = 0 ;
8222 PyObject *swig_obj[1] ;
8223
8224 if (!args) SWIG_fail;
8225 swig_obj[0] = args;
8226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8227 if (!SWIG_IsOK(res1)) {
8228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8229 }
8230 arg1 = reinterpret_cast< wxCaret * >(argp1);
8231 {
8232 PyThreadState* __tstate = wxPyBeginAllowThreads();
8233 delete arg1;
8234
8235 wxPyEndAllowThreads(__tstate);
8236 if (PyErr_Occurred()) SWIG_fail;
8237 }
8238 resultobj = SWIG_Py_Void();
8239 return resultobj;
8240 fail:
8241 return NULL;
8242 }
8243
8244
8245 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8246 PyObject *resultobj = 0;
8247 wxCaret *arg1 = (wxCaret *) 0 ;
8248 void *argp1 = 0 ;
8249 int res1 = 0 ;
8250 PyObject *swig_obj[1] ;
8251
8252 if (!args) SWIG_fail;
8253 swig_obj[0] = args;
8254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8255 if (!SWIG_IsOK(res1)) {
8256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8257 }
8258 arg1 = reinterpret_cast< wxCaret * >(argp1);
8259 {
8260 PyThreadState* __tstate = wxPyBeginAllowThreads();
8261 wxCaret_Destroy(arg1);
8262 wxPyEndAllowThreads(__tstate);
8263 if (PyErr_Occurred()) SWIG_fail;
8264 }
8265 resultobj = SWIG_Py_Void();
8266 return resultobj;
8267 fail:
8268 return NULL;
8269 }
8270
8271
8272 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8273 PyObject *resultobj = 0;
8274 wxCaret *arg1 = (wxCaret *) 0 ;
8275 bool result;
8276 void *argp1 = 0 ;
8277 int res1 = 0 ;
8278 PyObject *swig_obj[1] ;
8279
8280 if (!args) SWIG_fail;
8281 swig_obj[0] = args;
8282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8283 if (!SWIG_IsOK(res1)) {
8284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8285 }
8286 arg1 = reinterpret_cast< wxCaret * >(argp1);
8287 {
8288 PyThreadState* __tstate = wxPyBeginAllowThreads();
8289 result = (bool)(arg1)->IsOk();
8290 wxPyEndAllowThreads(__tstate);
8291 if (PyErr_Occurred()) SWIG_fail;
8292 }
8293 {
8294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8295 }
8296 return resultobj;
8297 fail:
8298 return NULL;
8299 }
8300
8301
8302 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8303 PyObject *resultobj = 0;
8304 wxCaret *arg1 = (wxCaret *) 0 ;
8305 bool result;
8306 void *argp1 = 0 ;
8307 int res1 = 0 ;
8308 PyObject *swig_obj[1] ;
8309
8310 if (!args) SWIG_fail;
8311 swig_obj[0] = args;
8312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8313 if (!SWIG_IsOK(res1)) {
8314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8315 }
8316 arg1 = reinterpret_cast< wxCaret * >(argp1);
8317 {
8318 PyThreadState* __tstate = wxPyBeginAllowThreads();
8319 result = (bool)(arg1)->IsVisible();
8320 wxPyEndAllowThreads(__tstate);
8321 if (PyErr_Occurred()) SWIG_fail;
8322 }
8323 {
8324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8325 }
8326 return resultobj;
8327 fail:
8328 return NULL;
8329 }
8330
8331
8332 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8333 PyObject *resultobj = 0;
8334 wxCaret *arg1 = (wxCaret *) 0 ;
8335 wxPoint result;
8336 void *argp1 = 0 ;
8337 int res1 = 0 ;
8338 PyObject *swig_obj[1] ;
8339
8340 if (!args) SWIG_fail;
8341 swig_obj[0] = args;
8342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8343 if (!SWIG_IsOK(res1)) {
8344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8345 }
8346 arg1 = reinterpret_cast< wxCaret * >(argp1);
8347 {
8348 PyThreadState* __tstate = wxPyBeginAllowThreads();
8349 result = (arg1)->GetPosition();
8350 wxPyEndAllowThreads(__tstate);
8351 if (PyErr_Occurred()) SWIG_fail;
8352 }
8353 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8354 return resultobj;
8355 fail:
8356 return NULL;
8357 }
8358
8359
8360 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8361 PyObject *resultobj = 0;
8362 wxCaret *arg1 = (wxCaret *) 0 ;
8363 int *arg2 = (int *) 0 ;
8364 int *arg3 = (int *) 0 ;
8365 void *argp1 = 0 ;
8366 int res1 = 0 ;
8367 int temp2 ;
8368 int res2 = SWIG_TMPOBJ ;
8369 int temp3 ;
8370 int res3 = SWIG_TMPOBJ ;
8371 PyObject *swig_obj[1] ;
8372
8373 arg2 = &temp2;
8374 arg3 = &temp3;
8375 if (!args) SWIG_fail;
8376 swig_obj[0] = args;
8377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8378 if (!SWIG_IsOK(res1)) {
8379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8380 }
8381 arg1 = reinterpret_cast< wxCaret * >(argp1);
8382 {
8383 PyThreadState* __tstate = wxPyBeginAllowThreads();
8384 (arg1)->GetPosition(arg2,arg3);
8385 wxPyEndAllowThreads(__tstate);
8386 if (PyErr_Occurred()) SWIG_fail;
8387 }
8388 resultobj = SWIG_Py_Void();
8389 if (SWIG_IsTmpObj(res2)) {
8390 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8391 } else {
8392 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8393 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8394 }
8395 if (SWIG_IsTmpObj(res3)) {
8396 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8397 } else {
8398 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8399 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8400 }
8401 return resultobj;
8402 fail:
8403 return NULL;
8404 }
8405
8406
8407 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8408 PyObject *resultobj = 0;
8409 wxCaret *arg1 = (wxCaret *) 0 ;
8410 wxSize result;
8411 void *argp1 = 0 ;
8412 int res1 = 0 ;
8413 PyObject *swig_obj[1] ;
8414
8415 if (!args) SWIG_fail;
8416 swig_obj[0] = args;
8417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8418 if (!SWIG_IsOK(res1)) {
8419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8420 }
8421 arg1 = reinterpret_cast< wxCaret * >(argp1);
8422 {
8423 PyThreadState* __tstate = wxPyBeginAllowThreads();
8424 result = (arg1)->GetSize();
8425 wxPyEndAllowThreads(__tstate);
8426 if (PyErr_Occurred()) SWIG_fail;
8427 }
8428 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8429 return resultobj;
8430 fail:
8431 return NULL;
8432 }
8433
8434
8435 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8436 PyObject *resultobj = 0;
8437 wxCaret *arg1 = (wxCaret *) 0 ;
8438 int *arg2 = (int *) 0 ;
8439 int *arg3 = (int *) 0 ;
8440 void *argp1 = 0 ;
8441 int res1 = 0 ;
8442 int temp2 ;
8443 int res2 = SWIG_TMPOBJ ;
8444 int temp3 ;
8445 int res3 = SWIG_TMPOBJ ;
8446 PyObject *swig_obj[1] ;
8447
8448 arg2 = &temp2;
8449 arg3 = &temp3;
8450 if (!args) SWIG_fail;
8451 swig_obj[0] = args;
8452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8453 if (!SWIG_IsOK(res1)) {
8454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8455 }
8456 arg1 = reinterpret_cast< wxCaret * >(argp1);
8457 {
8458 PyThreadState* __tstate = wxPyBeginAllowThreads();
8459 (arg1)->GetSize(arg2,arg3);
8460 wxPyEndAllowThreads(__tstate);
8461 if (PyErr_Occurred()) SWIG_fail;
8462 }
8463 resultobj = SWIG_Py_Void();
8464 if (SWIG_IsTmpObj(res2)) {
8465 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8466 } else {
8467 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8468 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8469 }
8470 if (SWIG_IsTmpObj(res3)) {
8471 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8472 } else {
8473 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8474 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8475 }
8476 return resultobj;
8477 fail:
8478 return NULL;
8479 }
8480
8481
8482 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8483 PyObject *resultobj = 0;
8484 wxCaret *arg1 = (wxCaret *) 0 ;
8485 wxWindow *result = 0 ;
8486 void *argp1 = 0 ;
8487 int res1 = 0 ;
8488 PyObject *swig_obj[1] ;
8489
8490 if (!args) SWIG_fail;
8491 swig_obj[0] = args;
8492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8493 if (!SWIG_IsOK(res1)) {
8494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8495 }
8496 arg1 = reinterpret_cast< wxCaret * >(argp1);
8497 {
8498 PyThreadState* __tstate = wxPyBeginAllowThreads();
8499 result = (wxWindow *)(arg1)->GetWindow();
8500 wxPyEndAllowThreads(__tstate);
8501 if (PyErr_Occurred()) SWIG_fail;
8502 }
8503 {
8504 resultobj = wxPyMake_wxObject(result, 0);
8505 }
8506 return resultobj;
8507 fail:
8508 return NULL;
8509 }
8510
8511
8512 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8513 PyObject *resultobj = 0;
8514 wxCaret *arg1 = (wxCaret *) 0 ;
8515 int arg2 ;
8516 int arg3 ;
8517 void *argp1 = 0 ;
8518 int res1 = 0 ;
8519 int val2 ;
8520 int ecode2 = 0 ;
8521 int val3 ;
8522 int ecode3 = 0 ;
8523 PyObject * obj0 = 0 ;
8524 PyObject * obj1 = 0 ;
8525 PyObject * obj2 = 0 ;
8526 char * kwnames[] = {
8527 (char *) "self",(char *) "x",(char *) "y", NULL
8528 };
8529
8530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8532 if (!SWIG_IsOK(res1)) {
8533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8534 }
8535 arg1 = reinterpret_cast< wxCaret * >(argp1);
8536 ecode2 = SWIG_AsVal_int(obj1, &val2);
8537 if (!SWIG_IsOK(ecode2)) {
8538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8539 }
8540 arg2 = static_cast< int >(val2);
8541 ecode3 = SWIG_AsVal_int(obj2, &val3);
8542 if (!SWIG_IsOK(ecode3)) {
8543 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8544 }
8545 arg3 = static_cast< int >(val3);
8546 {
8547 PyThreadState* __tstate = wxPyBeginAllowThreads();
8548 (arg1)->Move(arg2,arg3);
8549 wxPyEndAllowThreads(__tstate);
8550 if (PyErr_Occurred()) SWIG_fail;
8551 }
8552 resultobj = SWIG_Py_Void();
8553 return resultobj;
8554 fail:
8555 return NULL;
8556 }
8557
8558
8559 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8560 PyObject *resultobj = 0;
8561 wxCaret *arg1 = (wxCaret *) 0 ;
8562 wxPoint *arg2 = 0 ;
8563 void *argp1 = 0 ;
8564 int res1 = 0 ;
8565 wxPoint temp2 ;
8566 PyObject * obj0 = 0 ;
8567 PyObject * obj1 = 0 ;
8568 char * kwnames[] = {
8569 (char *) "self",(char *) "pt", NULL
8570 };
8571
8572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8574 if (!SWIG_IsOK(res1)) {
8575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8576 }
8577 arg1 = reinterpret_cast< wxCaret * >(argp1);
8578 {
8579 arg2 = &temp2;
8580 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8581 }
8582 {
8583 PyThreadState* __tstate = wxPyBeginAllowThreads();
8584 (arg1)->Move((wxPoint const &)*arg2);
8585 wxPyEndAllowThreads(__tstate);
8586 if (PyErr_Occurred()) SWIG_fail;
8587 }
8588 resultobj = SWIG_Py_Void();
8589 return resultobj;
8590 fail:
8591 return NULL;
8592 }
8593
8594
8595 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8596 PyObject *resultobj = 0;
8597 wxCaret *arg1 = (wxCaret *) 0 ;
8598 int arg2 ;
8599 int arg3 ;
8600 void *argp1 = 0 ;
8601 int res1 = 0 ;
8602 int val2 ;
8603 int ecode2 = 0 ;
8604 int val3 ;
8605 int ecode3 = 0 ;
8606 PyObject * obj0 = 0 ;
8607 PyObject * obj1 = 0 ;
8608 PyObject * obj2 = 0 ;
8609 char * kwnames[] = {
8610 (char *) "self",(char *) "width",(char *) "height", NULL
8611 };
8612
8613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8615 if (!SWIG_IsOK(res1)) {
8616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8617 }
8618 arg1 = reinterpret_cast< wxCaret * >(argp1);
8619 ecode2 = SWIG_AsVal_int(obj1, &val2);
8620 if (!SWIG_IsOK(ecode2)) {
8621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8622 }
8623 arg2 = static_cast< int >(val2);
8624 ecode3 = SWIG_AsVal_int(obj2, &val3);
8625 if (!SWIG_IsOK(ecode3)) {
8626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8627 }
8628 arg3 = static_cast< int >(val3);
8629 {
8630 PyThreadState* __tstate = wxPyBeginAllowThreads();
8631 (arg1)->SetSize(arg2,arg3);
8632 wxPyEndAllowThreads(__tstate);
8633 if (PyErr_Occurred()) SWIG_fail;
8634 }
8635 resultobj = SWIG_Py_Void();
8636 return resultobj;
8637 fail:
8638 return NULL;
8639 }
8640
8641
8642 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8643 PyObject *resultobj = 0;
8644 wxCaret *arg1 = (wxCaret *) 0 ;
8645 wxSize *arg2 = 0 ;
8646 void *argp1 = 0 ;
8647 int res1 = 0 ;
8648 wxSize temp2 ;
8649 PyObject * obj0 = 0 ;
8650 PyObject * obj1 = 0 ;
8651 char * kwnames[] = {
8652 (char *) "self",(char *) "size", NULL
8653 };
8654
8655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8657 if (!SWIG_IsOK(res1)) {
8658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8659 }
8660 arg1 = reinterpret_cast< wxCaret * >(argp1);
8661 {
8662 arg2 = &temp2;
8663 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8664 }
8665 {
8666 PyThreadState* __tstate = wxPyBeginAllowThreads();
8667 (arg1)->SetSize((wxSize const &)*arg2);
8668 wxPyEndAllowThreads(__tstate);
8669 if (PyErr_Occurred()) SWIG_fail;
8670 }
8671 resultobj = SWIG_Py_Void();
8672 return resultobj;
8673 fail:
8674 return NULL;
8675 }
8676
8677
8678 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8679 PyObject *resultobj = 0;
8680 wxCaret *arg1 = (wxCaret *) 0 ;
8681 int arg2 = (int) true ;
8682 void *argp1 = 0 ;
8683 int res1 = 0 ;
8684 int val2 ;
8685 int ecode2 = 0 ;
8686 PyObject * obj0 = 0 ;
8687 PyObject * obj1 = 0 ;
8688 char * kwnames[] = {
8689 (char *) "self",(char *) "show", NULL
8690 };
8691
8692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8694 if (!SWIG_IsOK(res1)) {
8695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8696 }
8697 arg1 = reinterpret_cast< wxCaret * >(argp1);
8698 if (obj1) {
8699 ecode2 = SWIG_AsVal_int(obj1, &val2);
8700 if (!SWIG_IsOK(ecode2)) {
8701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8702 }
8703 arg2 = static_cast< int >(val2);
8704 }
8705 {
8706 PyThreadState* __tstate = wxPyBeginAllowThreads();
8707 (arg1)->Show(arg2);
8708 wxPyEndAllowThreads(__tstate);
8709 if (PyErr_Occurred()) SWIG_fail;
8710 }
8711 resultobj = SWIG_Py_Void();
8712 return resultobj;
8713 fail:
8714 return NULL;
8715 }
8716
8717
8718 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8719 PyObject *resultobj = 0;
8720 wxCaret *arg1 = (wxCaret *) 0 ;
8721 void *argp1 = 0 ;
8722 int res1 = 0 ;
8723 PyObject *swig_obj[1] ;
8724
8725 if (!args) SWIG_fail;
8726 swig_obj[0] = args;
8727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8728 if (!SWIG_IsOK(res1)) {
8729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8730 }
8731 arg1 = reinterpret_cast< wxCaret * >(argp1);
8732 {
8733 PyThreadState* __tstate = wxPyBeginAllowThreads();
8734 (arg1)->Hide();
8735 wxPyEndAllowThreads(__tstate);
8736 if (PyErr_Occurred()) SWIG_fail;
8737 }
8738 resultobj = SWIG_Py_Void();
8739 return resultobj;
8740 fail:
8741 return NULL;
8742 }
8743
8744
8745 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8746 PyObject *resultobj = 0;
8747 int result;
8748
8749 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8750 {
8751 PyThreadState* __tstate = wxPyBeginAllowThreads();
8752 result = (int)wxCaret::GetBlinkTime();
8753 wxPyEndAllowThreads(__tstate);
8754 if (PyErr_Occurred()) SWIG_fail;
8755 }
8756 resultobj = SWIG_From_int(static_cast< int >(result));
8757 return resultobj;
8758 fail:
8759 return NULL;
8760 }
8761
8762
8763 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8764 PyObject *resultobj = 0;
8765 int arg1 ;
8766 int val1 ;
8767 int ecode1 = 0 ;
8768 PyObject * obj0 = 0 ;
8769 char * kwnames[] = {
8770 (char *) "milliseconds", NULL
8771 };
8772
8773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8774 ecode1 = SWIG_AsVal_int(obj0, &val1);
8775 if (!SWIG_IsOK(ecode1)) {
8776 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8777 }
8778 arg1 = static_cast< int >(val1);
8779 {
8780 PyThreadState* __tstate = wxPyBeginAllowThreads();
8781 wxCaret::SetBlinkTime(arg1);
8782 wxPyEndAllowThreads(__tstate);
8783 if (PyErr_Occurred()) SWIG_fail;
8784 }
8785 resultobj = SWIG_Py_Void();
8786 return resultobj;
8787 fail:
8788 return NULL;
8789 }
8790
8791
8792 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8793 PyObject *obj;
8794 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8795 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8796 return SWIG_Py_Void();
8797 }
8798
8799 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8800 return SWIG_Python_InitShadowInstance(args);
8801 }
8802
8803 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8804 PyObject *resultobj = 0;
8805 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8806 wxBusyCursor *result = 0 ;
8807 void *argp1 = 0 ;
8808 int res1 = 0 ;
8809 PyObject * obj0 = 0 ;
8810 char * kwnames[] = {
8811 (char *) "cursor", NULL
8812 };
8813
8814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
8815 if (obj0) {
8816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
8817 if (!SWIG_IsOK(res1)) {
8818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
8819 }
8820 arg1 = reinterpret_cast< wxCursor * >(argp1);
8821 }
8822 {
8823 if (!wxPyCheckForApp()) SWIG_fail;
8824 PyThreadState* __tstate = wxPyBeginAllowThreads();
8825 result = (wxBusyCursor *)new wxBusyCursor(arg1);
8826 wxPyEndAllowThreads(__tstate);
8827 if (PyErr_Occurred()) SWIG_fail;
8828 }
8829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
8830 return resultobj;
8831 fail:
8832 return NULL;
8833 }
8834
8835
8836 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8837 PyObject *resultobj = 0;
8838 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
8839 void *argp1 = 0 ;
8840 int res1 = 0 ;
8841 PyObject *swig_obj[1] ;
8842
8843 if (!args) SWIG_fail;
8844 swig_obj[0] = args;
8845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
8846 if (!SWIG_IsOK(res1)) {
8847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
8848 }
8849 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
8850 {
8851 PyThreadState* __tstate = wxPyBeginAllowThreads();
8852 delete arg1;
8853
8854 wxPyEndAllowThreads(__tstate);
8855 if (PyErr_Occurred()) SWIG_fail;
8856 }
8857 resultobj = SWIG_Py_Void();
8858 return resultobj;
8859 fail:
8860 return NULL;
8861 }
8862
8863
8864 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8865 PyObject *obj;
8866 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8867 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
8868 return SWIG_Py_Void();
8869 }
8870
8871 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8872 return SWIG_Python_InitShadowInstance(args);
8873 }
8874
8875 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8876 PyObject *resultobj = 0;
8877 wxWindow *arg1 = (wxWindow *) NULL ;
8878 wxWindowDisabler *result = 0 ;
8879 void *argp1 = 0 ;
8880 int res1 = 0 ;
8881 PyObject * obj0 = 0 ;
8882 char * kwnames[] = {
8883 (char *) "winToSkip", NULL
8884 };
8885
8886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
8887 if (obj0) {
8888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8889 if (!SWIG_IsOK(res1)) {
8890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
8891 }
8892 arg1 = reinterpret_cast< wxWindow * >(argp1);
8893 }
8894 {
8895 if (!wxPyCheckForApp()) SWIG_fail;
8896 PyThreadState* __tstate = wxPyBeginAllowThreads();
8897 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
8898 wxPyEndAllowThreads(__tstate);
8899 if (PyErr_Occurred()) SWIG_fail;
8900 }
8901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
8902 return resultobj;
8903 fail:
8904 return NULL;
8905 }
8906
8907
8908 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8909 PyObject *resultobj = 0;
8910 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
8911 void *argp1 = 0 ;
8912 int res1 = 0 ;
8913 PyObject *swig_obj[1] ;
8914
8915 if (!args) SWIG_fail;
8916 swig_obj[0] = args;
8917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
8918 if (!SWIG_IsOK(res1)) {
8919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
8920 }
8921 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
8922 {
8923 PyThreadState* __tstate = wxPyBeginAllowThreads();
8924 delete arg1;
8925
8926 wxPyEndAllowThreads(__tstate);
8927 if (PyErr_Occurred()) SWIG_fail;
8928 }
8929 resultobj = SWIG_Py_Void();
8930 return resultobj;
8931 fail:
8932 return NULL;
8933 }
8934
8935
8936 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8937 PyObject *obj;
8938 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8939 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
8940 return SWIG_Py_Void();
8941 }
8942
8943 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8944 return SWIG_Python_InitShadowInstance(args);
8945 }
8946
8947 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8948 PyObject *resultobj = 0;
8949 wxString *arg1 = 0 ;
8950 wxBusyInfo *result = 0 ;
8951 bool temp1 = false ;
8952 PyObject * obj0 = 0 ;
8953 char * kwnames[] = {
8954 (char *) "message", NULL
8955 };
8956
8957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
8958 {
8959 arg1 = wxString_in_helper(obj0);
8960 if (arg1 == NULL) SWIG_fail;
8961 temp1 = true;
8962 }
8963 {
8964 if (!wxPyCheckForApp()) SWIG_fail;
8965 PyThreadState* __tstate = wxPyBeginAllowThreads();
8966 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
8967 wxPyEndAllowThreads(__tstate);
8968 if (PyErr_Occurred()) SWIG_fail;
8969 }
8970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
8971 {
8972 if (temp1)
8973 delete arg1;
8974 }
8975 return resultobj;
8976 fail:
8977 {
8978 if (temp1)
8979 delete arg1;
8980 }
8981 return NULL;
8982 }
8983
8984
8985 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8986 PyObject *resultobj = 0;
8987 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
8988 void *argp1 = 0 ;
8989 int res1 = 0 ;
8990 PyObject *swig_obj[1] ;
8991
8992 if (!args) SWIG_fail;
8993 swig_obj[0] = args;
8994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
8995 if (!SWIG_IsOK(res1)) {
8996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
8997 }
8998 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
8999 {
9000 PyThreadState* __tstate = wxPyBeginAllowThreads();
9001 delete arg1;
9002
9003 wxPyEndAllowThreads(__tstate);
9004 if (PyErr_Occurred()) SWIG_fail;
9005 }
9006 resultobj = SWIG_Py_Void();
9007 return resultobj;
9008 fail:
9009 return NULL;
9010 }
9011
9012
9013 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9014 PyObject *obj;
9015 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9016 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9017 return SWIG_Py_Void();
9018 }
9019
9020 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9021 return SWIG_Python_InitShadowInstance(args);
9022 }
9023
9024 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9025 PyObject *resultobj = 0;
9026 wxStopWatch *result = 0 ;
9027
9028 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9029 {
9030 PyThreadState* __tstate = wxPyBeginAllowThreads();
9031 result = (wxStopWatch *)new wxStopWatch();
9032 wxPyEndAllowThreads(__tstate);
9033 if (PyErr_Occurred()) SWIG_fail;
9034 }
9035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9036 return resultobj;
9037 fail:
9038 return NULL;
9039 }
9040
9041
9042 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9043 PyObject *resultobj = 0;
9044 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9045 long arg2 = (long) 0 ;
9046 void *argp1 = 0 ;
9047 int res1 = 0 ;
9048 long val2 ;
9049 int ecode2 = 0 ;
9050 PyObject * obj0 = 0 ;
9051 PyObject * obj1 = 0 ;
9052 char * kwnames[] = {
9053 (char *) "self",(char *) "t0", NULL
9054 };
9055
9056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9058 if (!SWIG_IsOK(res1)) {
9059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9060 }
9061 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9062 if (obj1) {
9063 ecode2 = SWIG_AsVal_long(obj1, &val2);
9064 if (!SWIG_IsOK(ecode2)) {
9065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9066 }
9067 arg2 = static_cast< long >(val2);
9068 }
9069 {
9070 PyThreadState* __tstate = wxPyBeginAllowThreads();
9071 (arg1)->Start(arg2);
9072 wxPyEndAllowThreads(__tstate);
9073 if (PyErr_Occurred()) SWIG_fail;
9074 }
9075 resultobj = SWIG_Py_Void();
9076 return resultobj;
9077 fail:
9078 return NULL;
9079 }
9080
9081
9082 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9083 PyObject *resultobj = 0;
9084 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9085 void *argp1 = 0 ;
9086 int res1 = 0 ;
9087 PyObject *swig_obj[1] ;
9088
9089 if (!args) SWIG_fail;
9090 swig_obj[0] = args;
9091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9092 if (!SWIG_IsOK(res1)) {
9093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9094 }
9095 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9096 {
9097 PyThreadState* __tstate = wxPyBeginAllowThreads();
9098 (arg1)->Pause();
9099 wxPyEndAllowThreads(__tstate);
9100 if (PyErr_Occurred()) SWIG_fail;
9101 }
9102 resultobj = SWIG_Py_Void();
9103 return resultobj;
9104 fail:
9105 return NULL;
9106 }
9107
9108
9109 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9110 PyObject *resultobj = 0;
9111 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9112 void *argp1 = 0 ;
9113 int res1 = 0 ;
9114 PyObject *swig_obj[1] ;
9115
9116 if (!args) SWIG_fail;
9117 swig_obj[0] = args;
9118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9119 if (!SWIG_IsOK(res1)) {
9120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9121 }
9122 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9123 {
9124 PyThreadState* __tstate = wxPyBeginAllowThreads();
9125 (arg1)->Resume();
9126 wxPyEndAllowThreads(__tstate);
9127 if (PyErr_Occurred()) SWIG_fail;
9128 }
9129 resultobj = SWIG_Py_Void();
9130 return resultobj;
9131 fail:
9132 return NULL;
9133 }
9134
9135
9136 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9137 PyObject *resultobj = 0;
9138 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9139 long result;
9140 void *argp1 = 0 ;
9141 int res1 = 0 ;
9142 PyObject *swig_obj[1] ;
9143
9144 if (!args) SWIG_fail;
9145 swig_obj[0] = args;
9146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9147 if (!SWIG_IsOK(res1)) {
9148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9149 }
9150 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9151 {
9152 PyThreadState* __tstate = wxPyBeginAllowThreads();
9153 result = (long)((wxStopWatch const *)arg1)->Time();
9154 wxPyEndAllowThreads(__tstate);
9155 if (PyErr_Occurred()) SWIG_fail;
9156 }
9157 resultobj = SWIG_From_long(static_cast< long >(result));
9158 return resultobj;
9159 fail:
9160 return NULL;
9161 }
9162
9163
9164 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9165 PyObject *obj;
9166 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9167 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9168 return SWIG_Py_Void();
9169 }
9170
9171 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9172 return SWIG_Python_InitShadowInstance(args);
9173 }
9174
9175 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9176 PyObject *resultobj = 0;
9177 int arg1 = (int) 9 ;
9178 int arg2 = (int) wxID_FILE1 ;
9179 wxFileHistory *result = 0 ;
9180 int val1 ;
9181 int ecode1 = 0 ;
9182 int val2 ;
9183 int ecode2 = 0 ;
9184 PyObject * obj0 = 0 ;
9185 PyObject * obj1 = 0 ;
9186 char * kwnames[] = {
9187 (char *) "maxFiles",(char *) "idBase", NULL
9188 };
9189
9190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9191 if (obj0) {
9192 ecode1 = SWIG_AsVal_int(obj0, &val1);
9193 if (!SWIG_IsOK(ecode1)) {
9194 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9195 }
9196 arg1 = static_cast< int >(val1);
9197 }
9198 if (obj1) {
9199 ecode2 = SWIG_AsVal_int(obj1, &val2);
9200 if (!SWIG_IsOK(ecode2)) {
9201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9202 }
9203 arg2 = static_cast< int >(val2);
9204 }
9205 {
9206 PyThreadState* __tstate = wxPyBeginAllowThreads();
9207 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9208 wxPyEndAllowThreads(__tstate);
9209 if (PyErr_Occurred()) SWIG_fail;
9210 }
9211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9212 return resultobj;
9213 fail:
9214 return NULL;
9215 }
9216
9217
9218 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9219 PyObject *resultobj = 0;
9220 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9221 void *argp1 = 0 ;
9222 int res1 = 0 ;
9223 PyObject *swig_obj[1] ;
9224
9225 if (!args) SWIG_fail;
9226 swig_obj[0] = args;
9227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9228 if (!SWIG_IsOK(res1)) {
9229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9230 }
9231 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9232 {
9233 PyThreadState* __tstate = wxPyBeginAllowThreads();
9234 delete arg1;
9235
9236 wxPyEndAllowThreads(__tstate);
9237 if (PyErr_Occurred()) SWIG_fail;
9238 }
9239 resultobj = SWIG_Py_Void();
9240 return resultobj;
9241 fail:
9242 return NULL;
9243 }
9244
9245
9246 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9247 PyObject *resultobj = 0;
9248 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9249 wxString *arg2 = 0 ;
9250 void *argp1 = 0 ;
9251 int res1 = 0 ;
9252 bool temp2 = false ;
9253 PyObject * obj0 = 0 ;
9254 PyObject * obj1 = 0 ;
9255 char * kwnames[] = {
9256 (char *) "self",(char *) "file", NULL
9257 };
9258
9259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9261 if (!SWIG_IsOK(res1)) {
9262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9263 }
9264 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9265 {
9266 arg2 = wxString_in_helper(obj1);
9267 if (arg2 == NULL) SWIG_fail;
9268 temp2 = true;
9269 }
9270 {
9271 PyThreadState* __tstate = wxPyBeginAllowThreads();
9272 (arg1)->AddFileToHistory((wxString const &)*arg2);
9273 wxPyEndAllowThreads(__tstate);
9274 if (PyErr_Occurred()) SWIG_fail;
9275 }
9276 resultobj = SWIG_Py_Void();
9277 {
9278 if (temp2)
9279 delete arg2;
9280 }
9281 return resultobj;
9282 fail:
9283 {
9284 if (temp2)
9285 delete arg2;
9286 }
9287 return NULL;
9288 }
9289
9290
9291 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9292 PyObject *resultobj = 0;
9293 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9294 int arg2 ;
9295 void *argp1 = 0 ;
9296 int res1 = 0 ;
9297 int val2 ;
9298 int ecode2 = 0 ;
9299 PyObject * obj0 = 0 ;
9300 PyObject * obj1 = 0 ;
9301 char * kwnames[] = {
9302 (char *) "self",(char *) "i", NULL
9303 };
9304
9305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9307 if (!SWIG_IsOK(res1)) {
9308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9309 }
9310 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9311 ecode2 = SWIG_AsVal_int(obj1, &val2);
9312 if (!SWIG_IsOK(ecode2)) {
9313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9314 }
9315 arg2 = static_cast< int >(val2);
9316 {
9317 PyThreadState* __tstate = wxPyBeginAllowThreads();
9318 (arg1)->RemoveFileFromHistory(arg2);
9319 wxPyEndAllowThreads(__tstate);
9320 if (PyErr_Occurred()) SWIG_fail;
9321 }
9322 resultobj = SWIG_Py_Void();
9323 return resultobj;
9324 fail:
9325 return NULL;
9326 }
9327
9328
9329 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9330 PyObject *resultobj = 0;
9331 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9332 int result;
9333 void *argp1 = 0 ;
9334 int res1 = 0 ;
9335 PyObject *swig_obj[1] ;
9336
9337 if (!args) SWIG_fail;
9338 swig_obj[0] = args;
9339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9340 if (!SWIG_IsOK(res1)) {
9341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9342 }
9343 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9344 {
9345 PyThreadState* __tstate = wxPyBeginAllowThreads();
9346 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9347 wxPyEndAllowThreads(__tstate);
9348 if (PyErr_Occurred()) SWIG_fail;
9349 }
9350 resultobj = SWIG_From_int(static_cast< int >(result));
9351 return resultobj;
9352 fail:
9353 return NULL;
9354 }
9355
9356
9357 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9358 PyObject *resultobj = 0;
9359 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9360 wxMenu *arg2 = (wxMenu *) 0 ;
9361 void *argp1 = 0 ;
9362 int res1 = 0 ;
9363 void *argp2 = 0 ;
9364 int res2 = 0 ;
9365 PyObject * obj0 = 0 ;
9366 PyObject * obj1 = 0 ;
9367 char * kwnames[] = {
9368 (char *) "self",(char *) "menu", NULL
9369 };
9370
9371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9373 if (!SWIG_IsOK(res1)) {
9374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9375 }
9376 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9377 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9378 if (!SWIG_IsOK(res2)) {
9379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9380 }
9381 arg2 = reinterpret_cast< wxMenu * >(argp2);
9382 {
9383 PyThreadState* __tstate = wxPyBeginAllowThreads();
9384 (arg1)->UseMenu(arg2);
9385 wxPyEndAllowThreads(__tstate);
9386 if (PyErr_Occurred()) SWIG_fail;
9387 }
9388 resultobj = SWIG_Py_Void();
9389 return resultobj;
9390 fail:
9391 return NULL;
9392 }
9393
9394
9395 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9396 PyObject *resultobj = 0;
9397 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9398 wxMenu *arg2 = (wxMenu *) 0 ;
9399 void *argp1 = 0 ;
9400 int res1 = 0 ;
9401 void *argp2 = 0 ;
9402 int res2 = 0 ;
9403 PyObject * obj0 = 0 ;
9404 PyObject * obj1 = 0 ;
9405 char * kwnames[] = {
9406 (char *) "self",(char *) "menu", NULL
9407 };
9408
9409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9411 if (!SWIG_IsOK(res1)) {
9412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9413 }
9414 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9415 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9416 if (!SWIG_IsOK(res2)) {
9417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9418 }
9419 arg2 = reinterpret_cast< wxMenu * >(argp2);
9420 {
9421 PyThreadState* __tstate = wxPyBeginAllowThreads();
9422 (arg1)->RemoveMenu(arg2);
9423 wxPyEndAllowThreads(__tstate);
9424 if (PyErr_Occurred()) SWIG_fail;
9425 }
9426 resultobj = SWIG_Py_Void();
9427 return resultobj;
9428 fail:
9429 return NULL;
9430 }
9431
9432
9433 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9434 PyObject *resultobj = 0;
9435 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9436 wxConfigBase *arg2 = 0 ;
9437 void *argp1 = 0 ;
9438 int res1 = 0 ;
9439 void *argp2 = 0 ;
9440 int res2 = 0 ;
9441 PyObject * obj0 = 0 ;
9442 PyObject * obj1 = 0 ;
9443 char * kwnames[] = {
9444 (char *) "self",(char *) "config", NULL
9445 };
9446
9447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9449 if (!SWIG_IsOK(res1)) {
9450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9451 }
9452 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9453 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9454 if (!SWIG_IsOK(res2)) {
9455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9456 }
9457 if (!argp2) {
9458 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9459 }
9460 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9461 {
9462 PyThreadState* __tstate = wxPyBeginAllowThreads();
9463 (arg1)->Load(*arg2);
9464 wxPyEndAllowThreads(__tstate);
9465 if (PyErr_Occurred()) SWIG_fail;
9466 }
9467 resultobj = SWIG_Py_Void();
9468 return resultobj;
9469 fail:
9470 return NULL;
9471 }
9472
9473
9474 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9475 PyObject *resultobj = 0;
9476 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9477 wxConfigBase *arg2 = 0 ;
9478 void *argp1 = 0 ;
9479 int res1 = 0 ;
9480 void *argp2 = 0 ;
9481 int res2 = 0 ;
9482 PyObject * obj0 = 0 ;
9483 PyObject * obj1 = 0 ;
9484 char * kwnames[] = {
9485 (char *) "self",(char *) "config", NULL
9486 };
9487
9488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9490 if (!SWIG_IsOK(res1)) {
9491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9492 }
9493 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9494 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9495 if (!SWIG_IsOK(res2)) {
9496 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9497 }
9498 if (!argp2) {
9499 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9500 }
9501 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9502 {
9503 PyThreadState* __tstate = wxPyBeginAllowThreads();
9504 (arg1)->Save(*arg2);
9505 wxPyEndAllowThreads(__tstate);
9506 if (PyErr_Occurred()) SWIG_fail;
9507 }
9508 resultobj = SWIG_Py_Void();
9509 return resultobj;
9510 fail:
9511 return NULL;
9512 }
9513
9514
9515 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9516 PyObject *resultobj = 0;
9517 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9518 void *argp1 = 0 ;
9519 int res1 = 0 ;
9520 PyObject *swig_obj[1] ;
9521
9522 if (!args) SWIG_fail;
9523 swig_obj[0] = args;
9524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9525 if (!SWIG_IsOK(res1)) {
9526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9527 }
9528 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9529 {
9530 PyThreadState* __tstate = wxPyBeginAllowThreads();
9531 (arg1)->AddFilesToMenu();
9532 wxPyEndAllowThreads(__tstate);
9533 if (PyErr_Occurred()) SWIG_fail;
9534 }
9535 resultobj = SWIG_Py_Void();
9536 return resultobj;
9537 fail:
9538 return NULL;
9539 }
9540
9541
9542 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9543 PyObject *resultobj = 0;
9544 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9545 wxMenu *arg2 = (wxMenu *) 0 ;
9546 void *argp1 = 0 ;
9547 int res1 = 0 ;
9548 void *argp2 = 0 ;
9549 int res2 = 0 ;
9550 PyObject * obj0 = 0 ;
9551 PyObject * obj1 = 0 ;
9552 char * kwnames[] = {
9553 (char *) "self",(char *) "menu", NULL
9554 };
9555
9556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9558 if (!SWIG_IsOK(res1)) {
9559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9560 }
9561 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9562 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9563 if (!SWIG_IsOK(res2)) {
9564 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9565 }
9566 arg2 = reinterpret_cast< wxMenu * >(argp2);
9567 {
9568 PyThreadState* __tstate = wxPyBeginAllowThreads();
9569 (arg1)->AddFilesToMenu(arg2);
9570 wxPyEndAllowThreads(__tstate);
9571 if (PyErr_Occurred()) SWIG_fail;
9572 }
9573 resultobj = SWIG_Py_Void();
9574 return resultobj;
9575 fail:
9576 return NULL;
9577 }
9578
9579
9580 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9581 PyObject *resultobj = 0;
9582 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9583 int arg2 ;
9584 wxString result;
9585 void *argp1 = 0 ;
9586 int res1 = 0 ;
9587 int val2 ;
9588 int ecode2 = 0 ;
9589 PyObject * obj0 = 0 ;
9590 PyObject * obj1 = 0 ;
9591 char * kwnames[] = {
9592 (char *) "self",(char *) "i", NULL
9593 };
9594
9595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",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_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9599 }
9600 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9601 ecode2 = SWIG_AsVal_int(obj1, &val2);
9602 if (!SWIG_IsOK(ecode2)) {
9603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9604 }
9605 arg2 = static_cast< int >(val2);
9606 {
9607 PyThreadState* __tstate = wxPyBeginAllowThreads();
9608 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9609 wxPyEndAllowThreads(__tstate);
9610 if (PyErr_Occurred()) SWIG_fail;
9611 }
9612 {
9613 #if wxUSE_UNICODE
9614 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9615 #else
9616 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9617 #endif
9618 }
9619 return resultobj;
9620 fail:
9621 return NULL;
9622 }
9623
9624
9625 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9626 PyObject *resultobj = 0;
9627 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9628 int result;
9629 void *argp1 = 0 ;
9630 int res1 = 0 ;
9631 PyObject *swig_obj[1] ;
9632
9633 if (!args) SWIG_fail;
9634 swig_obj[0] = args;
9635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9636 if (!SWIG_IsOK(res1)) {
9637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9638 }
9639 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9640 {
9641 PyThreadState* __tstate = wxPyBeginAllowThreads();
9642 result = (int)((wxFileHistory const *)arg1)->GetCount();
9643 wxPyEndAllowThreads(__tstate);
9644 if (PyErr_Occurred()) SWIG_fail;
9645 }
9646 resultobj = SWIG_From_int(static_cast< int >(result));
9647 return resultobj;
9648 fail:
9649 return NULL;
9650 }
9651
9652
9653 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9654 PyObject *obj;
9655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9656 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9657 return SWIG_Py_Void();
9658 }
9659
9660 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9661 return SWIG_Python_InitShadowInstance(args);
9662 }
9663
9664 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9665 PyObject *resultobj = 0;
9666 wxString *arg1 = 0 ;
9667 wxString const &arg2_defvalue = wxPyEmptyString ;
9668 wxString *arg2 = (wxString *) &arg2_defvalue ;
9669 wxSingleInstanceChecker *result = 0 ;
9670 bool temp1 = false ;
9671 bool temp2 = false ;
9672 PyObject * obj0 = 0 ;
9673 PyObject * obj1 = 0 ;
9674 char * kwnames[] = {
9675 (char *) "name",(char *) "path", NULL
9676 };
9677
9678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9679 {
9680 arg1 = wxString_in_helper(obj0);
9681 if (arg1 == NULL) SWIG_fail;
9682 temp1 = true;
9683 }
9684 if (obj1) {
9685 {
9686 arg2 = wxString_in_helper(obj1);
9687 if (arg2 == NULL) SWIG_fail;
9688 temp2 = true;
9689 }
9690 }
9691 {
9692 PyThreadState* __tstate = wxPyBeginAllowThreads();
9693 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9694 wxPyEndAllowThreads(__tstate);
9695 if (PyErr_Occurred()) SWIG_fail;
9696 }
9697 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9698 {
9699 if (temp1)
9700 delete arg1;
9701 }
9702 {
9703 if (temp2)
9704 delete arg2;
9705 }
9706 return resultobj;
9707 fail:
9708 {
9709 if (temp1)
9710 delete arg1;
9711 }
9712 {
9713 if (temp2)
9714 delete arg2;
9715 }
9716 return NULL;
9717 }
9718
9719
9720 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9721 PyObject *resultobj = 0;
9722 wxSingleInstanceChecker *result = 0 ;
9723
9724 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9725 {
9726 PyThreadState* __tstate = wxPyBeginAllowThreads();
9727 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9728 wxPyEndAllowThreads(__tstate);
9729 if (PyErr_Occurred()) SWIG_fail;
9730 }
9731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9732 return resultobj;
9733 fail:
9734 return NULL;
9735 }
9736
9737
9738 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9739 PyObject *resultobj = 0;
9740 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9741 void *argp1 = 0 ;
9742 int res1 = 0 ;
9743 PyObject *swig_obj[1] ;
9744
9745 if (!args) SWIG_fail;
9746 swig_obj[0] = args;
9747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9748 if (!SWIG_IsOK(res1)) {
9749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9750 }
9751 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9752 {
9753 PyThreadState* __tstate = wxPyBeginAllowThreads();
9754 delete arg1;
9755
9756 wxPyEndAllowThreads(__tstate);
9757 if (PyErr_Occurred()) SWIG_fail;
9758 }
9759 resultobj = SWIG_Py_Void();
9760 return resultobj;
9761 fail:
9762 return NULL;
9763 }
9764
9765
9766 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9767 PyObject *resultobj = 0;
9768 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9769 wxString *arg2 = 0 ;
9770 wxString const &arg3_defvalue = wxPyEmptyString ;
9771 wxString *arg3 = (wxString *) &arg3_defvalue ;
9772 bool result;
9773 void *argp1 = 0 ;
9774 int res1 = 0 ;
9775 bool temp2 = false ;
9776 bool temp3 = false ;
9777 PyObject * obj0 = 0 ;
9778 PyObject * obj1 = 0 ;
9779 PyObject * obj2 = 0 ;
9780 char * kwnames[] = {
9781 (char *) "self",(char *) "name",(char *) "path", NULL
9782 };
9783
9784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9786 if (!SWIG_IsOK(res1)) {
9787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9788 }
9789 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9790 {
9791 arg2 = wxString_in_helper(obj1);
9792 if (arg2 == NULL) SWIG_fail;
9793 temp2 = true;
9794 }
9795 if (obj2) {
9796 {
9797 arg3 = wxString_in_helper(obj2);
9798 if (arg3 == NULL) SWIG_fail;
9799 temp3 = true;
9800 }
9801 }
9802 {
9803 PyThreadState* __tstate = wxPyBeginAllowThreads();
9804 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9805 wxPyEndAllowThreads(__tstate);
9806 if (PyErr_Occurred()) SWIG_fail;
9807 }
9808 {
9809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9810 }
9811 {
9812 if (temp2)
9813 delete arg2;
9814 }
9815 {
9816 if (temp3)
9817 delete arg3;
9818 }
9819 return resultobj;
9820 fail:
9821 {
9822 if (temp2)
9823 delete arg2;
9824 }
9825 {
9826 if (temp3)
9827 delete arg3;
9828 }
9829 return NULL;
9830 }
9831
9832
9833 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9834 PyObject *resultobj = 0;
9835 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9836 bool result;
9837 void *argp1 = 0 ;
9838 int res1 = 0 ;
9839 PyObject *swig_obj[1] ;
9840
9841 if (!args) SWIG_fail;
9842 swig_obj[0] = args;
9843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9844 if (!SWIG_IsOK(res1)) {
9845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
9846 }
9847 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9848 {
9849 PyThreadState* __tstate = wxPyBeginAllowThreads();
9850 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
9851 wxPyEndAllowThreads(__tstate);
9852 if (PyErr_Occurred()) SWIG_fail;
9853 }
9854 {
9855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9856 }
9857 return resultobj;
9858 fail:
9859 return NULL;
9860 }
9861
9862
9863 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9864 PyObject *obj;
9865 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9866 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
9867 return SWIG_Py_Void();
9868 }
9869
9870 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9871 return SWIG_Python_InitShadowInstance(args);
9872 }
9873
9874 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9875 PyObject *resultobj = 0;
9876 wxWindow *arg1 = (wxWindow *) 0 ;
9877 wxDC *arg2 = 0 ;
9878 bool result;
9879 void *argp1 = 0 ;
9880 int res1 = 0 ;
9881 void *argp2 = 0 ;
9882 int res2 = 0 ;
9883 PyObject * obj0 = 0 ;
9884 PyObject * obj1 = 0 ;
9885 char * kwnames[] = {
9886 (char *) "window",(char *) "dc", NULL
9887 };
9888
9889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
9890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9891 if (!SWIG_IsOK(res1)) {
9892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
9893 }
9894 arg1 = reinterpret_cast< wxWindow * >(argp1);
9895 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
9896 if (!SWIG_IsOK(res2)) {
9897 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9898 }
9899 if (!argp2) {
9900 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9901 }
9902 arg2 = reinterpret_cast< wxDC * >(argp2);
9903 {
9904 PyThreadState* __tstate = wxPyBeginAllowThreads();
9905 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
9906 wxPyEndAllowThreads(__tstate);
9907 if (PyErr_Occurred()) SWIG_fail;
9908 }
9909 {
9910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9911 }
9912 return resultobj;
9913 fail:
9914 return NULL;
9915 }
9916
9917
9918 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9919 PyObject *resultobj = 0;
9920 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9921 void *argp1 = 0 ;
9922 int res1 = 0 ;
9923 PyObject *swig_obj[1] ;
9924
9925 if (!args) SWIG_fail;
9926 swig_obj[0] = args;
9927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
9928 if (!SWIG_IsOK(res1)) {
9929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9930 }
9931 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9932 {
9933 PyThreadState* __tstate = wxPyBeginAllowThreads();
9934 delete arg1;
9935
9936 wxPyEndAllowThreads(__tstate);
9937 if (PyErr_Occurred()) SWIG_fail;
9938 }
9939 resultobj = SWIG_Py_Void();
9940 return resultobj;
9941 fail:
9942 return NULL;
9943 }
9944
9945
9946 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9947 PyObject *resultobj = 0;
9948 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9949 wxString result;
9950 void *argp1 = 0 ;
9951 int res1 = 0 ;
9952 PyObject *swig_obj[1] ;
9953
9954 if (!args) SWIG_fail;
9955 swig_obj[0] = args;
9956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
9957 if (!SWIG_IsOK(res1)) {
9958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9959 }
9960 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9961 {
9962 PyThreadState* __tstate = wxPyBeginAllowThreads();
9963 result = (arg1)->GetTip();
9964 wxPyEndAllowThreads(__tstate);
9965 if (PyErr_Occurred()) SWIG_fail;
9966 }
9967 {
9968 #if wxUSE_UNICODE
9969 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9970 #else
9971 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9972 #endif
9973 }
9974 return resultobj;
9975 fail:
9976 return NULL;
9977 }
9978
9979
9980 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9981 PyObject *resultobj = 0;
9982 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9983 size_t result;
9984 void *argp1 = 0 ;
9985 int res1 = 0 ;
9986 PyObject *swig_obj[1] ;
9987
9988 if (!args) SWIG_fail;
9989 swig_obj[0] = args;
9990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
9991 if (!SWIG_IsOK(res1)) {
9992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9993 }
9994 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9995 {
9996 PyThreadState* __tstate = wxPyBeginAllowThreads();
9997 result = (size_t)(arg1)->GetCurrentTip();
9998 wxPyEndAllowThreads(__tstate);
9999 if (PyErr_Occurred()) SWIG_fail;
10000 }
10001 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10002 return resultobj;
10003 fail:
10004 return NULL;
10005 }
10006
10007
10008 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10009 PyObject *resultobj = 0;
10010 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10011 wxString *arg2 = 0 ;
10012 wxString result;
10013 void *argp1 = 0 ;
10014 int res1 = 0 ;
10015 bool temp2 = false ;
10016 PyObject * obj0 = 0 ;
10017 PyObject * obj1 = 0 ;
10018 char * kwnames[] = {
10019 (char *) "self",(char *) "tip", NULL
10020 };
10021
10022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
10023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10024 if (!SWIG_IsOK(res1)) {
10025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10026 }
10027 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10028 {
10029 arg2 = wxString_in_helper(obj1);
10030 if (arg2 == NULL) SWIG_fail;
10031 temp2 = true;
10032 }
10033 {
10034 PyThreadState* __tstate = wxPyBeginAllowThreads();
10035 result = (arg1)->PreprocessTip((wxString const &)*arg2);
10036 wxPyEndAllowThreads(__tstate);
10037 if (PyErr_Occurred()) SWIG_fail;
10038 }
10039 {
10040 #if wxUSE_UNICODE
10041 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10042 #else
10043 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10044 #endif
10045 }
10046 {
10047 if (temp2)
10048 delete arg2;
10049 }
10050 return resultobj;
10051 fail:
10052 {
10053 if (temp2)
10054 delete arg2;
10055 }
10056 return NULL;
10057 }
10058
10059
10060 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10061 PyObject *obj;
10062 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10063 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
10064 return SWIG_Py_Void();
10065 }
10066
10067 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10068 PyObject *resultobj = 0;
10069 size_t arg1 ;
10070 wxPyTipProvider *result = 0 ;
10071 size_t val1 ;
10072 int ecode1 = 0 ;
10073 PyObject * obj0 = 0 ;
10074 char * kwnames[] = {
10075 (char *) "currentTip", NULL
10076 };
10077
10078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
10079 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10080 if (!SWIG_IsOK(ecode1)) {
10081 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
10082 }
10083 arg1 = static_cast< size_t >(val1);
10084 {
10085 PyThreadState* __tstate = wxPyBeginAllowThreads();
10086 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
10087 wxPyEndAllowThreads(__tstate);
10088 if (PyErr_Occurred()) SWIG_fail;
10089 }
10090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
10091 return resultobj;
10092 fail:
10093 return NULL;
10094 }
10095
10096
10097 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10098 PyObject *resultobj = 0;
10099 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
10100 PyObject *arg2 = (PyObject *) 0 ;
10101 PyObject *arg3 = (PyObject *) 0 ;
10102 void *argp1 = 0 ;
10103 int res1 = 0 ;
10104 PyObject * obj0 = 0 ;
10105 PyObject * obj1 = 0 ;
10106 PyObject * obj2 = 0 ;
10107 char * kwnames[] = {
10108 (char *) "self",(char *) "self",(char *) "_class", NULL
10109 };
10110
10111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
10113 if (!SWIG_IsOK(res1)) {
10114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
10115 }
10116 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
10117 arg2 = obj1;
10118 arg3 = obj2;
10119 {
10120 PyThreadState* __tstate = wxPyBeginAllowThreads();
10121 (arg1)->_setCallbackInfo(arg2,arg3);
10122 wxPyEndAllowThreads(__tstate);
10123 if (PyErr_Occurred()) SWIG_fail;
10124 }
10125 resultobj = SWIG_Py_Void();
10126 return resultobj;
10127 fail:
10128 return NULL;
10129 }
10130
10131
10132 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10133 PyObject *obj;
10134 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10135 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
10136 return SWIG_Py_Void();
10137 }
10138
10139 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10140 return SWIG_Python_InitShadowInstance(args);
10141 }
10142
10143 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10144 PyObject *resultobj = 0;
10145 wxWindow *arg1 = (wxWindow *) 0 ;
10146 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
10147 bool arg3 = (bool) true ;
10148 bool result;
10149 void *argp1 = 0 ;
10150 int res1 = 0 ;
10151 void *argp2 = 0 ;
10152 int res2 = 0 ;
10153 bool val3 ;
10154 int ecode3 = 0 ;
10155 PyObject * obj0 = 0 ;
10156 PyObject * obj1 = 0 ;
10157 PyObject * obj2 = 0 ;
10158 char * kwnames[] = {
10159 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
10160 };
10161
10162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10164 if (!SWIG_IsOK(res1)) {
10165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
10166 }
10167 arg1 = reinterpret_cast< wxWindow * >(argp1);
10168 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10169 if (!SWIG_IsOK(res2)) {
10170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
10171 }
10172 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
10173 if (obj2) {
10174 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10175 if (!SWIG_IsOK(ecode3)) {
10176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
10177 }
10178 arg3 = static_cast< bool >(val3);
10179 }
10180 {
10181 if (!wxPyCheckForApp()) SWIG_fail;
10182 PyThreadState* __tstate = wxPyBeginAllowThreads();
10183 result = (bool)wxShowTip(arg1,arg2,arg3);
10184 wxPyEndAllowThreads(__tstate);
10185 if (PyErr_Occurred()) SWIG_fail;
10186 }
10187 {
10188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10189 }
10190 return resultobj;
10191 fail:
10192 return NULL;
10193 }
10194
10195
10196 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10197 PyObject *resultobj = 0;
10198 wxString *arg1 = 0 ;
10199 size_t arg2 ;
10200 wxTipProvider *result = 0 ;
10201 bool temp1 = false ;
10202 size_t val2 ;
10203 int ecode2 = 0 ;
10204 PyObject * obj0 = 0 ;
10205 PyObject * obj1 = 0 ;
10206 char * kwnames[] = {
10207 (char *) "filename",(char *) "currentTip", NULL
10208 };
10209
10210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
10211 {
10212 arg1 = wxString_in_helper(obj0);
10213 if (arg1 == NULL) SWIG_fail;
10214 temp1 = true;
10215 }
10216 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10217 if (!SWIG_IsOK(ecode2)) {
10218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
10219 }
10220 arg2 = static_cast< size_t >(val2);
10221 {
10222 if (!wxPyCheckForApp()) SWIG_fail;
10223 PyThreadState* __tstate = wxPyBeginAllowThreads();
10224 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
10225 wxPyEndAllowThreads(__tstate);
10226 if (PyErr_Occurred()) SWIG_fail;
10227 }
10228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
10229 {
10230 if (temp1)
10231 delete arg1;
10232 }
10233 return resultobj;
10234 fail:
10235 {
10236 if (temp1)
10237 delete arg1;
10238 }
10239 return NULL;
10240 }
10241
10242
10243 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10244 PyObject *resultobj = 0;
10245 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10246 int arg2 = (int) wxID_ANY ;
10247 wxPyTimer *result = 0 ;
10248 void *argp1 = 0 ;
10249 int res1 = 0 ;
10250 int val2 ;
10251 int ecode2 = 0 ;
10252 PyObject * obj0 = 0 ;
10253 PyObject * obj1 = 0 ;
10254 char * kwnames[] = {
10255 (char *) "owner",(char *) "id", NULL
10256 };
10257
10258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
10259 if (obj0) {
10260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10261 if (!SWIG_IsOK(res1)) {
10262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
10263 }
10264 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
10265 }
10266 if (obj1) {
10267 ecode2 = SWIG_AsVal_int(obj1, &val2);
10268 if (!SWIG_IsOK(ecode2)) {
10269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
10270 }
10271 arg2 = static_cast< int >(val2);
10272 }
10273 {
10274 if (!wxPyCheckForApp()) SWIG_fail;
10275 PyThreadState* __tstate = wxPyBeginAllowThreads();
10276 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
10277 wxPyEndAllowThreads(__tstate);
10278 if (PyErr_Occurred()) SWIG_fail;
10279 }
10280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
10281 return resultobj;
10282 fail:
10283 return NULL;
10284 }
10285
10286
10287 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10288 PyObject *resultobj = 0;
10289 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10290 void *argp1 = 0 ;
10291 int res1 = 0 ;
10292 PyObject *swig_obj[1] ;
10293
10294 if (!args) SWIG_fail;
10295 swig_obj[0] = args;
10296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
10297 if (!SWIG_IsOK(res1)) {
10298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10299 }
10300 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10301 {
10302 PyThreadState* __tstate = wxPyBeginAllowThreads();
10303 delete arg1;
10304
10305 wxPyEndAllowThreads(__tstate);
10306 if (PyErr_Occurred()) SWIG_fail;
10307 }
10308 resultobj = SWIG_Py_Void();
10309 return resultobj;
10310 fail:
10311 return NULL;
10312 }
10313
10314
10315 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10316 PyObject *resultobj = 0;
10317 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10318 PyObject *arg2 = (PyObject *) 0 ;
10319 PyObject *arg3 = (PyObject *) 0 ;
10320 int arg4 = (int) 1 ;
10321 void *argp1 = 0 ;
10322 int res1 = 0 ;
10323 int val4 ;
10324 int ecode4 = 0 ;
10325 PyObject * obj0 = 0 ;
10326 PyObject * obj1 = 0 ;
10327 PyObject * obj2 = 0 ;
10328 PyObject * obj3 = 0 ;
10329 char * kwnames[] = {
10330 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10331 };
10332
10333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10335 if (!SWIG_IsOK(res1)) {
10336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10337 }
10338 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10339 arg2 = obj1;
10340 arg3 = obj2;
10341 if (obj3) {
10342 ecode4 = SWIG_AsVal_int(obj3, &val4);
10343 if (!SWIG_IsOK(ecode4)) {
10344 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
10345 }
10346 arg4 = static_cast< int >(val4);
10347 }
10348 {
10349 PyThreadState* __tstate = wxPyBeginAllowThreads();
10350 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10351 wxPyEndAllowThreads(__tstate);
10352 if (PyErr_Occurred()) SWIG_fail;
10353 }
10354 resultobj = SWIG_Py_Void();
10355 return resultobj;
10356 fail:
10357 return NULL;
10358 }
10359
10360
10361 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10362 PyObject *resultobj = 0;
10363 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10364 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
10365 int arg3 = (int) wxID_ANY ;
10366 void *argp1 = 0 ;
10367 int res1 = 0 ;
10368 void *argp2 = 0 ;
10369 int res2 = 0 ;
10370 int val3 ;
10371 int ecode3 = 0 ;
10372 PyObject * obj0 = 0 ;
10373 PyObject * obj1 = 0 ;
10374 PyObject * obj2 = 0 ;
10375 char * kwnames[] = {
10376 (char *) "self",(char *) "owner",(char *) "id", NULL
10377 };
10378
10379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10381 if (!SWIG_IsOK(res1)) {
10382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10383 }
10384 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10385 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10386 if (!SWIG_IsOK(res2)) {
10387 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
10388 }
10389 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
10390 if (obj2) {
10391 ecode3 = SWIG_AsVal_int(obj2, &val3);
10392 if (!SWIG_IsOK(ecode3)) {
10393 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
10394 }
10395 arg3 = static_cast< int >(val3);
10396 }
10397 {
10398 PyThreadState* __tstate = wxPyBeginAllowThreads();
10399 (arg1)->SetOwner(arg2,arg3);
10400 wxPyEndAllowThreads(__tstate);
10401 if (PyErr_Occurred()) SWIG_fail;
10402 }
10403 resultobj = SWIG_Py_Void();
10404 return resultobj;
10405 fail:
10406 return NULL;
10407 }
10408
10409
10410 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10411 PyObject *resultobj = 0;
10412 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10413 wxEvtHandler *result = 0 ;
10414 void *argp1 = 0 ;
10415 int res1 = 0 ;
10416 PyObject *swig_obj[1] ;
10417
10418 if (!args) SWIG_fail;
10419 swig_obj[0] = args;
10420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10421 if (!SWIG_IsOK(res1)) {
10422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10423 }
10424 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10425 {
10426 PyThreadState* __tstate = wxPyBeginAllowThreads();
10427 result = (wxEvtHandler *)(arg1)->GetOwner();
10428 wxPyEndAllowThreads(__tstate);
10429 if (PyErr_Occurred()) SWIG_fail;
10430 }
10431 {
10432 resultobj = wxPyMake_wxObject(result, 0);
10433 }
10434 return resultobj;
10435 fail:
10436 return NULL;
10437 }
10438
10439
10440 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10441 PyObject *resultobj = 0;
10442 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10443 int arg2 = (int) -1 ;
10444 bool arg3 = (bool) false ;
10445 bool result;
10446 void *argp1 = 0 ;
10447 int res1 = 0 ;
10448 int val2 ;
10449 int ecode2 = 0 ;
10450 bool val3 ;
10451 int ecode3 = 0 ;
10452 PyObject * obj0 = 0 ;
10453 PyObject * obj1 = 0 ;
10454 PyObject * obj2 = 0 ;
10455 char * kwnames[] = {
10456 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
10457 };
10458
10459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10461 if (!SWIG_IsOK(res1)) {
10462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10463 }
10464 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10465 if (obj1) {
10466 ecode2 = SWIG_AsVal_int(obj1, &val2);
10467 if (!SWIG_IsOK(ecode2)) {
10468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
10469 }
10470 arg2 = static_cast< int >(val2);
10471 }
10472 if (obj2) {
10473 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10474 if (!SWIG_IsOK(ecode3)) {
10475 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
10476 }
10477 arg3 = static_cast< bool >(val3);
10478 }
10479 {
10480 PyThreadState* __tstate = wxPyBeginAllowThreads();
10481 result = (bool)(arg1)->Start(arg2,arg3);
10482 wxPyEndAllowThreads(__tstate);
10483 if (PyErr_Occurred()) SWIG_fail;
10484 }
10485 {
10486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10487 }
10488 return resultobj;
10489 fail:
10490 return NULL;
10491 }
10492
10493
10494 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10495 PyObject *resultobj = 0;
10496 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10497 void *argp1 = 0 ;
10498 int res1 = 0 ;
10499 PyObject *swig_obj[1] ;
10500
10501 if (!args) SWIG_fail;
10502 swig_obj[0] = args;
10503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10504 if (!SWIG_IsOK(res1)) {
10505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10506 }
10507 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10508 {
10509 PyThreadState* __tstate = wxPyBeginAllowThreads();
10510 (arg1)->Stop();
10511 wxPyEndAllowThreads(__tstate);
10512 if (PyErr_Occurred()) SWIG_fail;
10513 }
10514 resultobj = SWIG_Py_Void();
10515 return resultobj;
10516 fail:
10517 return NULL;
10518 }
10519
10520
10521 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10522 PyObject *resultobj = 0;
10523 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10524 void *argp1 = 0 ;
10525 int res1 = 0 ;
10526 PyObject *swig_obj[1] ;
10527
10528 if (!args) SWIG_fail;
10529 swig_obj[0] = args;
10530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10531 if (!SWIG_IsOK(res1)) {
10532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10533 }
10534 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10535 {
10536 PyThreadState* __tstate = wxPyBeginAllowThreads();
10537 (arg1)->Notify();
10538 wxPyEndAllowThreads(__tstate);
10539 if (PyErr_Occurred()) SWIG_fail;
10540 }
10541 resultobj = SWIG_Py_Void();
10542 return resultobj;
10543 fail:
10544 return NULL;
10545 }
10546
10547
10548 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10549 PyObject *resultobj = 0;
10550 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10551 bool result;
10552 void *argp1 = 0 ;
10553 int res1 = 0 ;
10554 PyObject *swig_obj[1] ;
10555
10556 if (!args) SWIG_fail;
10557 swig_obj[0] = args;
10558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10559 if (!SWIG_IsOK(res1)) {
10560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10561 }
10562 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10563 {
10564 PyThreadState* __tstate = wxPyBeginAllowThreads();
10565 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
10566 wxPyEndAllowThreads(__tstate);
10567 if (PyErr_Occurred()) SWIG_fail;
10568 }
10569 {
10570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10571 }
10572 return resultobj;
10573 fail:
10574 return NULL;
10575 }
10576
10577
10578 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10579 PyObject *resultobj = 0;
10580 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10581 int result;
10582 void *argp1 = 0 ;
10583 int res1 = 0 ;
10584 PyObject *swig_obj[1] ;
10585
10586 if (!args) SWIG_fail;
10587 swig_obj[0] = args;
10588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10589 if (!SWIG_IsOK(res1)) {
10590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10591 }
10592 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10593 {
10594 PyThreadState* __tstate = wxPyBeginAllowThreads();
10595 result = (int)((wxPyTimer const *)arg1)->GetInterval();
10596 wxPyEndAllowThreads(__tstate);
10597 if (PyErr_Occurred()) SWIG_fail;
10598 }
10599 resultobj = SWIG_From_int(static_cast< int >(result));
10600 return resultobj;
10601 fail:
10602 return NULL;
10603 }
10604
10605
10606 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10607 PyObject *resultobj = 0;
10608 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10609 int result;
10610 void *argp1 = 0 ;
10611 int res1 = 0 ;
10612 PyObject *swig_obj[1] ;
10613
10614 if (!args) SWIG_fail;
10615 swig_obj[0] = args;
10616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10617 if (!SWIG_IsOK(res1)) {
10618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10619 }
10620 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10621 {
10622 PyThreadState* __tstate = wxPyBeginAllowThreads();
10623 result = (int)((wxPyTimer const *)arg1)->GetId();
10624 wxPyEndAllowThreads(__tstate);
10625 if (PyErr_Occurred()) SWIG_fail;
10626 }
10627 resultobj = SWIG_From_int(static_cast< int >(result));
10628 return resultobj;
10629 fail:
10630 return NULL;
10631 }
10632
10633
10634 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10635 PyObject *resultobj = 0;
10636 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10637 bool result;
10638 void *argp1 = 0 ;
10639 int res1 = 0 ;
10640 PyObject *swig_obj[1] ;
10641
10642 if (!args) SWIG_fail;
10643 swig_obj[0] = args;
10644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10645 if (!SWIG_IsOK(res1)) {
10646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10647 }
10648 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10649 {
10650 PyThreadState* __tstate = wxPyBeginAllowThreads();
10651 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
10652 wxPyEndAllowThreads(__tstate);
10653 if (PyErr_Occurred()) SWIG_fail;
10654 }
10655 {
10656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10657 }
10658 return resultobj;
10659 fail:
10660 return NULL;
10661 }
10662
10663
10664 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10665 PyObject *obj;
10666 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10667 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
10668 return SWIG_Py_Void();
10669 }
10670
10671 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10672 return SWIG_Python_InitShadowInstance(args);
10673 }
10674
10675 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10676 PyObject *resultobj = 0;
10677 int arg1 = (int) 0 ;
10678 int arg2 = (int) 0 ;
10679 wxTimerEvent *result = 0 ;
10680 int val1 ;
10681 int ecode1 = 0 ;
10682 int val2 ;
10683 int ecode2 = 0 ;
10684 PyObject * obj0 = 0 ;
10685 PyObject * obj1 = 0 ;
10686 char * kwnames[] = {
10687 (char *) "timerid",(char *) "interval", NULL
10688 };
10689
10690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
10691 if (obj0) {
10692 ecode1 = SWIG_AsVal_int(obj0, &val1);
10693 if (!SWIG_IsOK(ecode1)) {
10694 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
10695 }
10696 arg1 = static_cast< int >(val1);
10697 }
10698 if (obj1) {
10699 ecode2 = SWIG_AsVal_int(obj1, &val2);
10700 if (!SWIG_IsOK(ecode2)) {
10701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
10702 }
10703 arg2 = static_cast< int >(val2);
10704 }
10705 {
10706 PyThreadState* __tstate = wxPyBeginAllowThreads();
10707 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
10708 wxPyEndAllowThreads(__tstate);
10709 if (PyErr_Occurred()) SWIG_fail;
10710 }
10711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
10712 return resultobj;
10713 fail:
10714 return NULL;
10715 }
10716
10717
10718 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10719 PyObject *resultobj = 0;
10720 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
10721 int result;
10722 void *argp1 = 0 ;
10723 int res1 = 0 ;
10724 PyObject *swig_obj[1] ;
10725
10726 if (!args) SWIG_fail;
10727 swig_obj[0] = args;
10728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
10729 if (!SWIG_IsOK(res1)) {
10730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
10731 }
10732 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
10733 {
10734 PyThreadState* __tstate = wxPyBeginAllowThreads();
10735 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
10736 wxPyEndAllowThreads(__tstate);
10737 if (PyErr_Occurred()) SWIG_fail;
10738 }
10739 resultobj = SWIG_From_int(static_cast< int >(result));
10740 return resultobj;
10741 fail:
10742 return NULL;
10743 }
10744
10745
10746 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10747 PyObject *obj;
10748 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10749 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
10750 return SWIG_Py_Void();
10751 }
10752
10753 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10754 return SWIG_Python_InitShadowInstance(args);
10755 }
10756
10757 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10758 PyObject *resultobj = 0;
10759 wxTimer *arg1 = 0 ;
10760 wxTimerRunner *result = 0 ;
10761 void *argp1 = 0 ;
10762 int res1 = 0 ;
10763
10764 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
10765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10766 if (!SWIG_IsOK(res1)) {
10767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10768 }
10769 if (!argp1) {
10770 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10771 }
10772 arg1 = reinterpret_cast< wxTimer * >(argp1);
10773 {
10774 if (!wxPyCheckForApp()) SWIG_fail;
10775 PyThreadState* __tstate = wxPyBeginAllowThreads();
10776 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
10777 wxPyEndAllowThreads(__tstate);
10778 if (PyErr_Occurred()) SWIG_fail;
10779 }
10780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10781 return resultobj;
10782 fail:
10783 return NULL;
10784 }
10785
10786
10787 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10788 PyObject *resultobj = 0;
10789 wxTimer *arg1 = 0 ;
10790 int arg2 ;
10791 bool arg3 = (bool) false ;
10792 wxTimerRunner *result = 0 ;
10793 void *argp1 = 0 ;
10794 int res1 = 0 ;
10795 int val2 ;
10796 int ecode2 = 0 ;
10797 bool val3 ;
10798 int ecode3 = 0 ;
10799
10800 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
10801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10802 if (!SWIG_IsOK(res1)) {
10803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10804 }
10805 if (!argp1) {
10806 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10807 }
10808 arg1 = reinterpret_cast< wxTimer * >(argp1);
10809 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10810 if (!SWIG_IsOK(ecode2)) {
10811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
10812 }
10813 arg2 = static_cast< int >(val2);
10814 if (swig_obj[2]) {
10815 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
10816 if (!SWIG_IsOK(ecode3)) {
10817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
10818 }
10819 arg3 = static_cast< bool >(val3);
10820 }
10821 {
10822 if (!wxPyCheckForApp()) SWIG_fail;
10823 PyThreadState* __tstate = wxPyBeginAllowThreads();
10824 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
10825 wxPyEndAllowThreads(__tstate);
10826 if (PyErr_Occurred()) SWIG_fail;
10827 }
10828 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10829 return resultobj;
10830 fail:
10831 return NULL;
10832 }
10833
10834
10835 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
10836 int argc;
10837 PyObject *argv[4];
10838
10839 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
10840 --argc;
10841 if (argc == 1) {
10842 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
10843 }
10844 if ((argc >= 2) && (argc <= 3)) {
10845 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
10846 }
10847
10848 fail:
10849 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
10850 return NULL;
10851 }
10852
10853
10854 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10855 PyObject *resultobj = 0;
10856 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10857 void *argp1 = 0 ;
10858 int res1 = 0 ;
10859 PyObject *swig_obj[1] ;
10860
10861 if (!args) SWIG_fail;
10862 swig_obj[0] = args;
10863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
10864 if (!SWIG_IsOK(res1)) {
10865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10866 }
10867 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10868 {
10869 PyThreadState* __tstate = wxPyBeginAllowThreads();
10870 delete arg1;
10871
10872 wxPyEndAllowThreads(__tstate);
10873 if (PyErr_Occurred()) SWIG_fail;
10874 }
10875 resultobj = SWIG_Py_Void();
10876 return resultobj;
10877 fail:
10878 return NULL;
10879 }
10880
10881
10882 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10883 PyObject *resultobj = 0;
10884 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10885 int arg2 ;
10886 bool arg3 = (bool) false ;
10887 void *argp1 = 0 ;
10888 int res1 = 0 ;
10889 int val2 ;
10890 int ecode2 = 0 ;
10891 bool val3 ;
10892 int ecode3 = 0 ;
10893 PyObject * obj0 = 0 ;
10894 PyObject * obj1 = 0 ;
10895 PyObject * obj2 = 0 ;
10896 char * kwnames[] = {
10897 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
10898 };
10899
10900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
10902 if (!SWIG_IsOK(res1)) {
10903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10904 }
10905 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10906 ecode2 = SWIG_AsVal_int(obj1, &val2);
10907 if (!SWIG_IsOK(ecode2)) {
10908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
10909 }
10910 arg2 = static_cast< int >(val2);
10911 if (obj2) {
10912 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10913 if (!SWIG_IsOK(ecode3)) {
10914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
10915 }
10916 arg3 = static_cast< bool >(val3);
10917 }
10918 {
10919 PyThreadState* __tstate = wxPyBeginAllowThreads();
10920 (arg1)->Start(arg2,arg3);
10921 wxPyEndAllowThreads(__tstate);
10922 if (PyErr_Occurred()) SWIG_fail;
10923 }
10924 resultobj = SWIG_Py_Void();
10925 return resultobj;
10926 fail:
10927 return NULL;
10928 }
10929
10930
10931 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10932 PyObject *obj;
10933 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10934 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
10935 return SWIG_Py_Void();
10936 }
10937
10938 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10939 return SWIG_Python_InitShadowInstance(args);
10940 }
10941
10942 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10943 PyObject *resultobj = 0;
10944 wxLog *result = 0 ;
10945
10946 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
10947 {
10948 PyThreadState* __tstate = wxPyBeginAllowThreads();
10949 result = (wxLog *)new wxLog();
10950 wxPyEndAllowThreads(__tstate);
10951 if (PyErr_Occurred()) SWIG_fail;
10952 }
10953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
10954 return resultobj;
10955 fail:
10956 return NULL;
10957 }
10958
10959
10960 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10961 PyObject *resultobj = 0;
10962 wxLog *arg1 = (wxLog *) 0 ;
10963 void *argp1 = 0 ;
10964 int res1 = 0 ;
10965 PyObject *swig_obj[1] ;
10966
10967 if (!args) SWIG_fail;
10968 swig_obj[0] = args;
10969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
10970 if (!SWIG_IsOK(res1)) {
10971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
10972 }
10973 arg1 = reinterpret_cast< wxLog * >(argp1);
10974 {
10975 PyThreadState* __tstate = wxPyBeginAllowThreads();
10976 delete arg1;
10977
10978 wxPyEndAllowThreads(__tstate);
10979 if (PyErr_Occurred()) SWIG_fail;
10980 }
10981 resultobj = SWIG_Py_Void();
10982 return resultobj;
10983 fail:
10984 return NULL;
10985 }
10986
10987
10988 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10989 PyObject *resultobj = 0;
10990 bool result;
10991
10992 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
10993 {
10994 PyThreadState* __tstate = wxPyBeginAllowThreads();
10995 result = (bool)wxLog::IsEnabled();
10996 wxPyEndAllowThreads(__tstate);
10997 if (PyErr_Occurred()) SWIG_fail;
10998 }
10999 {
11000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11001 }
11002 return resultobj;
11003 fail:
11004 return NULL;
11005 }
11006
11007
11008 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11009 PyObject *resultobj = 0;
11010 bool arg1 = (bool) true ;
11011 bool result;
11012 bool val1 ;
11013 int ecode1 = 0 ;
11014 PyObject * obj0 = 0 ;
11015 char * kwnames[] = {
11016 (char *) "doIt", NULL
11017 };
11018
11019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
11020 if (obj0) {
11021 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11022 if (!SWIG_IsOK(ecode1)) {
11023 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
11024 }
11025 arg1 = static_cast< bool >(val1);
11026 }
11027 {
11028 PyThreadState* __tstate = wxPyBeginAllowThreads();
11029 result = (bool)wxLog::EnableLogging(arg1);
11030 wxPyEndAllowThreads(__tstate);
11031 if (PyErr_Occurred()) SWIG_fail;
11032 }
11033 {
11034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11035 }
11036 return resultobj;
11037 fail:
11038 return NULL;
11039 }
11040
11041
11042 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11043 PyObject *resultobj = 0;
11044 wxLogLevel arg1 ;
11045 wxChar *arg2 = (wxChar *) 0 ;
11046 time_t arg3 ;
11047 unsigned long val1 ;
11048 int ecode1 = 0 ;
11049 void *argp2 = 0 ;
11050 int res2 = 0 ;
11051 unsigned int val3 ;
11052 int ecode3 = 0 ;
11053 PyObject * obj0 = 0 ;
11054 PyObject * obj1 = 0 ;
11055 PyObject * obj2 = 0 ;
11056 char * kwnames[] = {
11057 (char *) "level",(char *) "szString",(char *) "t", NULL
11058 };
11059
11060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11061 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11062 if (!SWIG_IsOK(ecode1)) {
11063 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
11064 }
11065 arg1 = static_cast< wxLogLevel >(val1);
11066 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
11067 if (!SWIG_IsOK(res2)) {
11068 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
11069 }
11070 arg2 = reinterpret_cast< wxChar * >(argp2);
11071 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
11072 if (!SWIG_IsOK(ecode3)) {
11073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
11074 }
11075 arg3 = static_cast< time_t >(val3);
11076 {
11077 PyThreadState* __tstate = wxPyBeginAllowThreads();
11078 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
11079 wxPyEndAllowThreads(__tstate);
11080 if (PyErr_Occurred()) SWIG_fail;
11081 }
11082 resultobj = SWIG_Py_Void();
11083 return resultobj;
11084 fail:
11085 return NULL;
11086 }
11087
11088
11089 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11090 PyObject *resultobj = 0;
11091 wxLog *arg1 = (wxLog *) 0 ;
11092 void *argp1 = 0 ;
11093 int res1 = 0 ;
11094 PyObject *swig_obj[1] ;
11095
11096 if (!args) SWIG_fail;
11097 swig_obj[0] = args;
11098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11099 if (!SWIG_IsOK(res1)) {
11100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
11101 }
11102 arg1 = reinterpret_cast< wxLog * >(argp1);
11103 {
11104 PyThreadState* __tstate = wxPyBeginAllowThreads();
11105 (arg1)->Flush();
11106 wxPyEndAllowThreads(__tstate);
11107 if (PyErr_Occurred()) SWIG_fail;
11108 }
11109 resultobj = SWIG_Py_Void();
11110 return resultobj;
11111 fail:
11112 return NULL;
11113 }
11114
11115
11116 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11117 PyObject *resultobj = 0;
11118
11119 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
11120 {
11121 PyThreadState* __tstate = wxPyBeginAllowThreads();
11122 wxLog::FlushActive();
11123 wxPyEndAllowThreads(__tstate);
11124 if (PyErr_Occurred()) SWIG_fail;
11125 }
11126 resultobj = SWIG_Py_Void();
11127 return resultobj;
11128 fail:
11129 return NULL;
11130 }
11131
11132
11133 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11134 PyObject *resultobj = 0;
11135 wxLog *result = 0 ;
11136
11137 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
11138 {
11139 PyThreadState* __tstate = wxPyBeginAllowThreads();
11140 result = (wxLog *)wxLog::GetActiveTarget();
11141 wxPyEndAllowThreads(__tstate);
11142 if (PyErr_Occurred()) SWIG_fail;
11143 }
11144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11145 return resultobj;
11146 fail:
11147 return NULL;
11148 }
11149
11150
11151 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11152 PyObject *resultobj = 0;
11153 wxLog *arg1 = (wxLog *) 0 ;
11154 wxLog *result = 0 ;
11155 int res1 = 0 ;
11156 PyObject * obj0 = 0 ;
11157 char * kwnames[] = {
11158 (char *) "pLogger", NULL
11159 };
11160
11161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
11162 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11163 if (!SWIG_IsOK(res1)) {
11164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
11165 }
11166 {
11167 PyThreadState* __tstate = wxPyBeginAllowThreads();
11168 result = (wxLog *)wxLog::SetActiveTarget(arg1);
11169 wxPyEndAllowThreads(__tstate);
11170 if (PyErr_Occurred()) SWIG_fail;
11171 }
11172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
11173 return resultobj;
11174 fail:
11175 return NULL;
11176 }
11177
11178
11179 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11180 PyObject *resultobj = 0;
11181
11182 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
11183 {
11184 PyThreadState* __tstate = wxPyBeginAllowThreads();
11185 wxLog::Suspend();
11186 wxPyEndAllowThreads(__tstate);
11187 if (PyErr_Occurred()) SWIG_fail;
11188 }
11189 resultobj = SWIG_Py_Void();
11190 return resultobj;
11191 fail:
11192 return NULL;
11193 }
11194
11195
11196 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11197 PyObject *resultobj = 0;
11198
11199 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
11200 {
11201 PyThreadState* __tstate = wxPyBeginAllowThreads();
11202 wxLog::Resume();
11203 wxPyEndAllowThreads(__tstate);
11204 if (PyErr_Occurred()) SWIG_fail;
11205 }
11206 resultobj = SWIG_Py_Void();
11207 return resultobj;
11208 fail:
11209 return NULL;
11210 }
11211
11212
11213 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11214 PyObject *resultobj = 0;
11215 bool arg1 = (bool) true ;
11216 bool val1 ;
11217 int ecode1 = 0 ;
11218 PyObject * obj0 = 0 ;
11219 char * kwnames[] = {
11220 (char *) "bVerbose", NULL
11221 };
11222
11223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
11224 if (obj0) {
11225 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11226 if (!SWIG_IsOK(ecode1)) {
11227 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
11228 }
11229 arg1 = static_cast< bool >(val1);
11230 }
11231 {
11232 PyThreadState* __tstate = wxPyBeginAllowThreads();
11233 wxLog::SetVerbose(arg1);
11234 wxPyEndAllowThreads(__tstate);
11235 if (PyErr_Occurred()) SWIG_fail;
11236 }
11237 resultobj = SWIG_Py_Void();
11238 return resultobj;
11239 fail:
11240 return NULL;
11241 }
11242
11243
11244 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11245 PyObject *resultobj = 0;
11246 wxLogLevel arg1 ;
11247 unsigned long val1 ;
11248 int ecode1 = 0 ;
11249 PyObject * obj0 = 0 ;
11250 char * kwnames[] = {
11251 (char *) "logLevel", NULL
11252 };
11253
11254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
11255 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11256 if (!SWIG_IsOK(ecode1)) {
11257 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
11258 }
11259 arg1 = static_cast< wxLogLevel >(val1);
11260 {
11261 PyThreadState* __tstate = wxPyBeginAllowThreads();
11262 wxLog::SetLogLevel(arg1);
11263 wxPyEndAllowThreads(__tstate);
11264 if (PyErr_Occurred()) SWIG_fail;
11265 }
11266 resultobj = SWIG_Py_Void();
11267 return resultobj;
11268 fail:
11269 return NULL;
11270 }
11271
11272
11273 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11274 PyObject *resultobj = 0;
11275
11276 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
11277 {
11278 PyThreadState* __tstate = wxPyBeginAllowThreads();
11279 wxLog::DontCreateOnDemand();
11280 wxPyEndAllowThreads(__tstate);
11281 if (PyErr_Occurred()) SWIG_fail;
11282 }
11283 resultobj = SWIG_Py_Void();
11284 return resultobj;
11285 fail:
11286 return NULL;
11287 }
11288
11289
11290 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11291 PyObject *resultobj = 0;
11292 wxTraceMask arg1 ;
11293 unsigned long val1 ;
11294 int ecode1 = 0 ;
11295 PyObject * obj0 = 0 ;
11296 char * kwnames[] = {
11297 (char *) "ulMask", NULL
11298 };
11299
11300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
11301 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11302 if (!SWIG_IsOK(ecode1)) {
11303 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
11304 }
11305 arg1 = static_cast< wxTraceMask >(val1);
11306 {
11307 PyThreadState* __tstate = wxPyBeginAllowThreads();
11308 wxLog::SetTraceMask(arg1);
11309 wxPyEndAllowThreads(__tstate);
11310 if (PyErr_Occurred()) SWIG_fail;
11311 }
11312 resultobj = SWIG_Py_Void();
11313 return resultobj;
11314 fail:
11315 return NULL;
11316 }
11317
11318
11319 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11320 PyObject *resultobj = 0;
11321 wxString *arg1 = 0 ;
11322 bool temp1 = false ;
11323 PyObject * obj0 = 0 ;
11324 char * kwnames[] = {
11325 (char *) "str", NULL
11326 };
11327
11328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
11329 {
11330 arg1 = wxString_in_helper(obj0);
11331 if (arg1 == NULL) SWIG_fail;
11332 temp1 = true;
11333 }
11334 {
11335 PyThreadState* __tstate = wxPyBeginAllowThreads();
11336 wxLog::AddTraceMask((wxString const &)*arg1);
11337 wxPyEndAllowThreads(__tstate);
11338 if (PyErr_Occurred()) SWIG_fail;
11339 }
11340 resultobj = SWIG_Py_Void();
11341 {
11342 if (temp1)
11343 delete arg1;
11344 }
11345 return resultobj;
11346 fail:
11347 {
11348 if (temp1)
11349 delete arg1;
11350 }
11351 return NULL;
11352 }
11353
11354
11355 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11356 PyObject *resultobj = 0;
11357 wxString *arg1 = 0 ;
11358 bool temp1 = false ;
11359 PyObject * obj0 = 0 ;
11360 char * kwnames[] = {
11361 (char *) "str", NULL
11362 };
11363
11364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
11365 {
11366 arg1 = wxString_in_helper(obj0);
11367 if (arg1 == NULL) SWIG_fail;
11368 temp1 = true;
11369 }
11370 {
11371 PyThreadState* __tstate = wxPyBeginAllowThreads();
11372 wxLog::RemoveTraceMask((wxString const &)*arg1);
11373 wxPyEndAllowThreads(__tstate);
11374 if (PyErr_Occurred()) SWIG_fail;
11375 }
11376 resultobj = SWIG_Py_Void();
11377 {
11378 if (temp1)
11379 delete arg1;
11380 }
11381 return resultobj;
11382 fail:
11383 {
11384 if (temp1)
11385 delete arg1;
11386 }
11387 return NULL;
11388 }
11389
11390
11391 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11392 PyObject *resultobj = 0;
11393
11394 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
11395 {
11396 PyThreadState* __tstate = wxPyBeginAllowThreads();
11397 wxLog::ClearTraceMasks();
11398 wxPyEndAllowThreads(__tstate);
11399 if (PyErr_Occurred()) SWIG_fail;
11400 }
11401 resultobj = SWIG_Py_Void();
11402 return resultobj;
11403 fail:
11404 return NULL;
11405 }
11406
11407
11408 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11409 PyObject *resultobj = 0;
11410 wxArrayString *result = 0 ;
11411
11412 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
11413 {
11414 PyThreadState* __tstate = wxPyBeginAllowThreads();
11415 {
11416 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
11417 result = (wxArrayString *) &_result_ref;
11418 }
11419 wxPyEndAllowThreads(__tstate);
11420 if (PyErr_Occurred()) SWIG_fail;
11421 }
11422 {
11423 resultobj = wxArrayString2PyList_helper(*result);
11424 }
11425 return resultobj;
11426 fail:
11427 return NULL;
11428 }
11429
11430
11431 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11432 PyObject *resultobj = 0;
11433 wxChar *arg1 = (wxChar *) 0 ;
11434 void *argp1 = 0 ;
11435 int res1 = 0 ;
11436 PyObject * obj0 = 0 ;
11437 char * kwnames[] = {
11438 (char *) "ts", NULL
11439 };
11440
11441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
11442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11443 if (!SWIG_IsOK(res1)) {
11444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
11445 }
11446 arg1 = reinterpret_cast< wxChar * >(argp1);
11447 {
11448 PyThreadState* __tstate = wxPyBeginAllowThreads();
11449 wxLog::SetTimestamp((wxChar const *)arg1);
11450 wxPyEndAllowThreads(__tstate);
11451 if (PyErr_Occurred()) SWIG_fail;
11452 }
11453 resultobj = SWIG_Py_Void();
11454 return resultobj;
11455 fail:
11456 return NULL;
11457 }
11458
11459
11460 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11461 PyObject *resultobj = 0;
11462 bool result;
11463
11464 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
11465 {
11466 PyThreadState* __tstate = wxPyBeginAllowThreads();
11467 result = (bool)wxLog::GetVerbose();
11468 wxPyEndAllowThreads(__tstate);
11469 if (PyErr_Occurred()) SWIG_fail;
11470 }
11471 {
11472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11473 }
11474 return resultobj;
11475 fail:
11476 return NULL;
11477 }
11478
11479
11480 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11481 PyObject *resultobj = 0;
11482 wxTraceMask result;
11483
11484 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
11485 {
11486 PyThreadState* __tstate = wxPyBeginAllowThreads();
11487 result = (wxTraceMask)wxLog::GetTraceMask();
11488 wxPyEndAllowThreads(__tstate);
11489 if (PyErr_Occurred()) SWIG_fail;
11490 }
11491 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11492 return resultobj;
11493 fail:
11494 return NULL;
11495 }
11496
11497
11498 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11499 PyObject *resultobj = 0;
11500 wxChar *arg1 = (wxChar *) 0 ;
11501 bool result;
11502 void *argp1 = 0 ;
11503 int res1 = 0 ;
11504 PyObject * obj0 = 0 ;
11505 char * kwnames[] = {
11506 (char *) "mask", NULL
11507 };
11508
11509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
11510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11511 if (!SWIG_IsOK(res1)) {
11512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
11513 }
11514 arg1 = reinterpret_cast< wxChar * >(argp1);
11515 {
11516 PyThreadState* __tstate = wxPyBeginAllowThreads();
11517 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
11518 wxPyEndAllowThreads(__tstate);
11519 if (PyErr_Occurred()) SWIG_fail;
11520 }
11521 {
11522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11523 }
11524 return resultobj;
11525 fail:
11526 return NULL;
11527 }
11528
11529
11530 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11531 PyObject *resultobj = 0;
11532 wxLogLevel result;
11533
11534 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
11535 {
11536 PyThreadState* __tstate = wxPyBeginAllowThreads();
11537 result = (wxLogLevel)wxLog::GetLogLevel();
11538 wxPyEndAllowThreads(__tstate);
11539 if (PyErr_Occurred()) SWIG_fail;
11540 }
11541 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11542 return resultobj;
11543 fail:
11544 return NULL;
11545 }
11546
11547
11548 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11549 PyObject *resultobj = 0;
11550 wxChar *result = 0 ;
11551
11552 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
11553 {
11554 PyThreadState* __tstate = wxPyBeginAllowThreads();
11555 result = (wxChar *)wxLog::GetTimestamp();
11556 wxPyEndAllowThreads(__tstate);
11557 if (PyErr_Occurred()) SWIG_fail;
11558 }
11559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
11560 return resultobj;
11561 fail:
11562 return NULL;
11563 }
11564
11565
11566 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11567 PyObject *resultobj = 0;
11568 wxString result;
11569
11570 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
11571 {
11572 PyThreadState* __tstate = wxPyBeginAllowThreads();
11573 result = wxLog_TimeStamp();
11574 wxPyEndAllowThreads(__tstate);
11575 if (PyErr_Occurred()) SWIG_fail;
11576 }
11577 {
11578 #if wxUSE_UNICODE
11579 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11580 #else
11581 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11582 #endif
11583 }
11584 return resultobj;
11585 fail:
11586 return NULL;
11587 }
11588
11589
11590 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11591 PyObject *resultobj = 0;
11592 wxLog *arg1 = (wxLog *) 0 ;
11593 void *argp1 = 0 ;
11594 int res1 = 0 ;
11595 PyObject *swig_obj[1] ;
11596
11597 if (!args) SWIG_fail;
11598 swig_obj[0] = args;
11599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11600 if (!SWIG_IsOK(res1)) {
11601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
11602 }
11603 arg1 = reinterpret_cast< wxLog * >(argp1);
11604 {
11605 PyThreadState* __tstate = wxPyBeginAllowThreads();
11606 wxLog_Destroy(arg1);
11607 wxPyEndAllowThreads(__tstate);
11608 if (PyErr_Occurred()) SWIG_fail;
11609 }
11610 resultobj = SWIG_Py_Void();
11611 return resultobj;
11612 fail:
11613 return NULL;
11614 }
11615
11616
11617 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11618 PyObject *obj;
11619 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11620 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
11621 return SWIG_Py_Void();
11622 }
11623
11624 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11625 return SWIG_Python_InitShadowInstance(args);
11626 }
11627
11628 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11629 PyObject *resultobj = 0;
11630 wxLogStderr *result = 0 ;
11631
11632 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
11633 {
11634 PyThreadState* __tstate = wxPyBeginAllowThreads();
11635 result = (wxLogStderr *)new wxLogStderr();
11636 wxPyEndAllowThreads(__tstate);
11637 if (PyErr_Occurred()) SWIG_fail;
11638 }
11639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
11640 return resultobj;
11641 fail:
11642 return NULL;
11643 }
11644
11645
11646 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11647 PyObject *obj;
11648 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11649 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
11650 return SWIG_Py_Void();
11651 }
11652
11653 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11654 return SWIG_Python_InitShadowInstance(args);
11655 }
11656
11657 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11658 PyObject *resultobj = 0;
11659 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11660 wxLogTextCtrl *result = 0 ;
11661 void *argp1 = 0 ;
11662 int res1 = 0 ;
11663 PyObject * obj0 = 0 ;
11664 char * kwnames[] = {
11665 (char *) "pTextCtrl", NULL
11666 };
11667
11668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
11669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
11670 if (!SWIG_IsOK(res1)) {
11671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
11672 }
11673 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
11674 {
11675 PyThreadState* __tstate = wxPyBeginAllowThreads();
11676 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
11677 wxPyEndAllowThreads(__tstate);
11678 if (PyErr_Occurred()) SWIG_fail;
11679 }
11680 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
11681 return resultobj;
11682 fail:
11683 return NULL;
11684 }
11685
11686
11687 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11688 PyObject *obj;
11689 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11690 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
11691 return SWIG_Py_Void();
11692 }
11693
11694 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11695 return SWIG_Python_InitShadowInstance(args);
11696 }
11697
11698 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11699 PyObject *resultobj = 0;
11700 wxLogGui *result = 0 ;
11701
11702 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
11703 {
11704 PyThreadState* __tstate = wxPyBeginAllowThreads();
11705 result = (wxLogGui *)new wxLogGui();
11706 wxPyEndAllowThreads(__tstate);
11707 if (PyErr_Occurred()) SWIG_fail;
11708 }
11709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
11710 return resultobj;
11711 fail:
11712 return NULL;
11713 }
11714
11715
11716 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11717 PyObject *obj;
11718 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11719 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
11720 return SWIG_Py_Void();
11721 }
11722
11723 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11724 return SWIG_Python_InitShadowInstance(args);
11725 }
11726
11727 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11728 PyObject *resultobj = 0;
11729 wxFrame *arg1 = (wxFrame *) 0 ;
11730 wxString *arg2 = 0 ;
11731 bool arg3 = (bool) true ;
11732 bool arg4 = (bool) true ;
11733 wxLogWindow *result = 0 ;
11734 void *argp1 = 0 ;
11735 int res1 = 0 ;
11736 bool temp2 = false ;
11737 bool val3 ;
11738 int ecode3 = 0 ;
11739 bool val4 ;
11740 int ecode4 = 0 ;
11741 PyObject * obj0 = 0 ;
11742 PyObject * obj1 = 0 ;
11743 PyObject * obj2 = 0 ;
11744 PyObject * obj3 = 0 ;
11745 char * kwnames[] = {
11746 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
11747 };
11748
11749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
11751 if (!SWIG_IsOK(res1)) {
11752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
11753 }
11754 arg1 = reinterpret_cast< wxFrame * >(argp1);
11755 {
11756 arg2 = wxString_in_helper(obj1);
11757 if (arg2 == NULL) SWIG_fail;
11758 temp2 = true;
11759 }
11760 if (obj2) {
11761 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11762 if (!SWIG_IsOK(ecode3)) {
11763 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
11764 }
11765 arg3 = static_cast< bool >(val3);
11766 }
11767 if (obj3) {
11768 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11769 if (!SWIG_IsOK(ecode4)) {
11770 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
11771 }
11772 arg4 = static_cast< bool >(val4);
11773 }
11774 {
11775 PyThreadState* __tstate = wxPyBeginAllowThreads();
11776 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
11777 wxPyEndAllowThreads(__tstate);
11778 if (PyErr_Occurred()) SWIG_fail;
11779 }
11780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
11781 {
11782 if (temp2)
11783 delete arg2;
11784 }
11785 return resultobj;
11786 fail:
11787 {
11788 if (temp2)
11789 delete arg2;
11790 }
11791 return NULL;
11792 }
11793
11794
11795 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11796 PyObject *resultobj = 0;
11797 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11798 bool arg2 = (bool) true ;
11799 void *argp1 = 0 ;
11800 int res1 = 0 ;
11801 bool val2 ;
11802 int ecode2 = 0 ;
11803 PyObject * obj0 = 0 ;
11804 PyObject * obj1 = 0 ;
11805 char * kwnames[] = {
11806 (char *) "self",(char *) "bShow", NULL
11807 };
11808
11809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
11810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11811 if (!SWIG_IsOK(res1)) {
11812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11813 }
11814 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11815 if (obj1) {
11816 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11817 if (!SWIG_IsOK(ecode2)) {
11818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
11819 }
11820 arg2 = static_cast< bool >(val2);
11821 }
11822 {
11823 PyThreadState* __tstate = wxPyBeginAllowThreads();
11824 (arg1)->Show(arg2);
11825 wxPyEndAllowThreads(__tstate);
11826 if (PyErr_Occurred()) SWIG_fail;
11827 }
11828 resultobj = SWIG_Py_Void();
11829 return resultobj;
11830 fail:
11831 return NULL;
11832 }
11833
11834
11835 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11836 PyObject *resultobj = 0;
11837 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11838 wxFrame *result = 0 ;
11839 void *argp1 = 0 ;
11840 int res1 = 0 ;
11841 PyObject *swig_obj[1] ;
11842
11843 if (!args) SWIG_fail;
11844 swig_obj[0] = args;
11845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11846 if (!SWIG_IsOK(res1)) {
11847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11848 }
11849 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11850 {
11851 PyThreadState* __tstate = wxPyBeginAllowThreads();
11852 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
11853 wxPyEndAllowThreads(__tstate);
11854 if (PyErr_Occurred()) SWIG_fail;
11855 }
11856 {
11857 resultobj = wxPyMake_wxObject(result, (bool)0);
11858 }
11859 return resultobj;
11860 fail:
11861 return NULL;
11862 }
11863
11864
11865 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11866 PyObject *resultobj = 0;
11867 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11868 wxLog *result = 0 ;
11869 void *argp1 = 0 ;
11870 int res1 = 0 ;
11871 PyObject *swig_obj[1] ;
11872
11873 if (!args) SWIG_fail;
11874 swig_obj[0] = args;
11875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11876 if (!SWIG_IsOK(res1)) {
11877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11878 }
11879 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11880 {
11881 PyThreadState* __tstate = wxPyBeginAllowThreads();
11882 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
11883 wxPyEndAllowThreads(__tstate);
11884 if (PyErr_Occurred()) SWIG_fail;
11885 }
11886 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11887 return resultobj;
11888 fail:
11889 return NULL;
11890 }
11891
11892
11893 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11894 PyObject *resultobj = 0;
11895 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11896 bool result;
11897 void *argp1 = 0 ;
11898 int res1 = 0 ;
11899 PyObject *swig_obj[1] ;
11900
11901 if (!args) SWIG_fail;
11902 swig_obj[0] = args;
11903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11904 if (!SWIG_IsOK(res1)) {
11905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11906 }
11907 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11908 {
11909 PyThreadState* __tstate = wxPyBeginAllowThreads();
11910 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
11911 wxPyEndAllowThreads(__tstate);
11912 if (PyErr_Occurred()) SWIG_fail;
11913 }
11914 {
11915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11916 }
11917 return resultobj;
11918 fail:
11919 return NULL;
11920 }
11921
11922
11923 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11924 PyObject *resultobj = 0;
11925 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11926 bool arg2 ;
11927 void *argp1 = 0 ;
11928 int res1 = 0 ;
11929 bool val2 ;
11930 int ecode2 = 0 ;
11931 PyObject * obj0 = 0 ;
11932 PyObject * obj1 = 0 ;
11933 char * kwnames[] = {
11934 (char *) "self",(char *) "bDoPass", NULL
11935 };
11936
11937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
11938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11939 if (!SWIG_IsOK(res1)) {
11940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11941 }
11942 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11943 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11944 if (!SWIG_IsOK(ecode2)) {
11945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
11946 }
11947 arg2 = static_cast< bool >(val2);
11948 {
11949 PyThreadState* __tstate = wxPyBeginAllowThreads();
11950 (arg1)->PassMessages(arg2);
11951 wxPyEndAllowThreads(__tstate);
11952 if (PyErr_Occurred()) SWIG_fail;
11953 }
11954 resultobj = SWIG_Py_Void();
11955 return resultobj;
11956 fail:
11957 return NULL;
11958 }
11959
11960
11961 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11962 PyObject *obj;
11963 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11964 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
11965 return SWIG_Py_Void();
11966 }
11967
11968 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11969 return SWIG_Python_InitShadowInstance(args);
11970 }
11971
11972 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11973 PyObject *resultobj = 0;
11974 wxLog *arg1 = (wxLog *) 0 ;
11975 wxLogChain *result = 0 ;
11976 void *argp1 = 0 ;
11977 int res1 = 0 ;
11978 PyObject * obj0 = 0 ;
11979 char * kwnames[] = {
11980 (char *) "logger", NULL
11981 };
11982
11983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
11984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11985 if (!SWIG_IsOK(res1)) {
11986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
11987 }
11988 arg1 = reinterpret_cast< wxLog * >(argp1);
11989 {
11990 PyThreadState* __tstate = wxPyBeginAllowThreads();
11991 result = (wxLogChain *)new wxLogChain(arg1);
11992 wxPyEndAllowThreads(__tstate);
11993 if (PyErr_Occurred()) SWIG_fail;
11994 }
11995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
11996 return resultobj;
11997 fail:
11998 return NULL;
11999 }
12000
12001
12002 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12003 PyObject *resultobj = 0;
12004 wxLogChain *arg1 = (wxLogChain *) 0 ;
12005 wxLog *arg2 = (wxLog *) 0 ;
12006 void *argp1 = 0 ;
12007 int res1 = 0 ;
12008 void *argp2 = 0 ;
12009 int res2 = 0 ;
12010 PyObject * obj0 = 0 ;
12011 PyObject * obj1 = 0 ;
12012 char * kwnames[] = {
12013 (char *) "self",(char *) "logger", NULL
12014 };
12015
12016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
12017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12018 if (!SWIG_IsOK(res1)) {
12019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12020 }
12021 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12022 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
12023 if (!SWIG_IsOK(res2)) {
12024 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
12025 }
12026 arg2 = reinterpret_cast< wxLog * >(argp2);
12027 {
12028 PyThreadState* __tstate = wxPyBeginAllowThreads();
12029 (arg1)->SetLog(arg2);
12030 wxPyEndAllowThreads(__tstate);
12031 if (PyErr_Occurred()) SWIG_fail;
12032 }
12033 resultobj = SWIG_Py_Void();
12034 return resultobj;
12035 fail:
12036 return NULL;
12037 }
12038
12039
12040 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12041 PyObject *resultobj = 0;
12042 wxLogChain *arg1 = (wxLogChain *) 0 ;
12043 bool arg2 ;
12044 void *argp1 = 0 ;
12045 int res1 = 0 ;
12046 bool val2 ;
12047 int ecode2 = 0 ;
12048 PyObject * obj0 = 0 ;
12049 PyObject * obj1 = 0 ;
12050 char * kwnames[] = {
12051 (char *) "self",(char *) "bDoPass", NULL
12052 };
12053
12054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12056 if (!SWIG_IsOK(res1)) {
12057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12058 }
12059 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12060 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12061 if (!SWIG_IsOK(ecode2)) {
12062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12063 }
12064 arg2 = static_cast< bool >(val2);
12065 {
12066 PyThreadState* __tstate = wxPyBeginAllowThreads();
12067 (arg1)->PassMessages(arg2);
12068 wxPyEndAllowThreads(__tstate);
12069 if (PyErr_Occurred()) SWIG_fail;
12070 }
12071 resultobj = SWIG_Py_Void();
12072 return resultobj;
12073 fail:
12074 return NULL;
12075 }
12076
12077
12078 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12079 PyObject *resultobj = 0;
12080 wxLogChain *arg1 = (wxLogChain *) 0 ;
12081 bool result;
12082 void *argp1 = 0 ;
12083 int res1 = 0 ;
12084 PyObject *swig_obj[1] ;
12085
12086 if (!args) SWIG_fail;
12087 swig_obj[0] = args;
12088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12089 if (!SWIG_IsOK(res1)) {
12090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12091 }
12092 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12093 {
12094 PyThreadState* __tstate = wxPyBeginAllowThreads();
12095 result = (bool)(arg1)->IsPassingMessages();
12096 wxPyEndAllowThreads(__tstate);
12097 if (PyErr_Occurred()) SWIG_fail;
12098 }
12099 {
12100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12101 }
12102 return resultobj;
12103 fail:
12104 return NULL;
12105 }
12106
12107
12108 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12109 PyObject *resultobj = 0;
12110 wxLogChain *arg1 = (wxLogChain *) 0 ;
12111 wxLog *result = 0 ;
12112 void *argp1 = 0 ;
12113 int res1 = 0 ;
12114 PyObject *swig_obj[1] ;
12115
12116 if (!args) SWIG_fail;
12117 swig_obj[0] = args;
12118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12119 if (!SWIG_IsOK(res1)) {
12120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12121 }
12122 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12123 {
12124 PyThreadState* __tstate = wxPyBeginAllowThreads();
12125 result = (wxLog *)(arg1)->GetOldLog();
12126 wxPyEndAllowThreads(__tstate);
12127 if (PyErr_Occurred()) SWIG_fail;
12128 }
12129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12130 return resultobj;
12131 fail:
12132 return NULL;
12133 }
12134
12135
12136 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12137 PyObject *obj;
12138 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12139 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
12140 return SWIG_Py_Void();
12141 }
12142
12143 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12144 return SWIG_Python_InitShadowInstance(args);
12145 }
12146
12147 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12148 PyObject *resultobj = 0;
12149 wxLogBuffer *result = 0 ;
12150
12151 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
12152 {
12153 PyThreadState* __tstate = wxPyBeginAllowThreads();
12154 result = (wxLogBuffer *)new wxLogBuffer();
12155 wxPyEndAllowThreads(__tstate);
12156 if (PyErr_Occurred()) SWIG_fail;
12157 }
12158 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
12159 return resultobj;
12160 fail:
12161 return NULL;
12162 }
12163
12164
12165 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12166 PyObject *resultobj = 0;
12167 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
12168 wxString *result = 0 ;
12169 void *argp1 = 0 ;
12170 int res1 = 0 ;
12171 PyObject *swig_obj[1] ;
12172
12173 if (!args) SWIG_fail;
12174 swig_obj[0] = args;
12175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
12176 if (!SWIG_IsOK(res1)) {
12177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
12178 }
12179 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
12180 {
12181 PyThreadState* __tstate = wxPyBeginAllowThreads();
12182 {
12183 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
12184 result = (wxString *) &_result_ref;
12185 }
12186 wxPyEndAllowThreads(__tstate);
12187 if (PyErr_Occurred()) SWIG_fail;
12188 }
12189 {
12190 #if wxUSE_UNICODE
12191 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12192 #else
12193 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12194 #endif
12195 }
12196 return resultobj;
12197 fail:
12198 return NULL;
12199 }
12200
12201
12202 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12203 PyObject *obj;
12204 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12205 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
12206 return SWIG_Py_Void();
12207 }
12208
12209 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12210 return SWIG_Python_InitShadowInstance(args);
12211 }
12212
12213 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12214 PyObject *resultobj = 0;
12215 unsigned long result;
12216
12217 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
12218 {
12219 PyThreadState* __tstate = wxPyBeginAllowThreads();
12220 result = (unsigned long)wxSysErrorCode();
12221 wxPyEndAllowThreads(__tstate);
12222 if (PyErr_Occurred()) SWIG_fail;
12223 }
12224 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12225 return resultobj;
12226 fail:
12227 return NULL;
12228 }
12229
12230
12231 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12232 PyObject *resultobj = 0;
12233 unsigned long arg1 = (unsigned long) 0 ;
12234 wxString result;
12235 unsigned long val1 ;
12236 int ecode1 = 0 ;
12237 PyObject * obj0 = 0 ;
12238 char * kwnames[] = {
12239 (char *) "nErrCode", NULL
12240 };
12241
12242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
12243 if (obj0) {
12244 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12245 if (!SWIG_IsOK(ecode1)) {
12246 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
12247 }
12248 arg1 = static_cast< unsigned long >(val1);
12249 }
12250 {
12251 PyThreadState* __tstate = wxPyBeginAllowThreads();
12252 result = wxSysErrorMsg(arg1);
12253 wxPyEndAllowThreads(__tstate);
12254 if (PyErr_Occurred()) SWIG_fail;
12255 }
12256 {
12257 #if wxUSE_UNICODE
12258 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12259 #else
12260 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12261 #endif
12262 }
12263 return resultobj;
12264 fail:
12265 return NULL;
12266 }
12267
12268
12269 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12270 PyObject *resultobj = 0;
12271 wxString *arg1 = 0 ;
12272 bool temp1 = false ;
12273 PyObject * obj0 = 0 ;
12274 char * kwnames[] = {
12275 (char *) "msg", NULL
12276 };
12277
12278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
12279 {
12280 arg1 = wxString_in_helper(obj0);
12281 if (arg1 == NULL) SWIG_fail;
12282 temp1 = true;
12283 }
12284 {
12285 PyThreadState* __tstate = wxPyBeginAllowThreads();
12286 wxPyLogFatalError((wxString const &)*arg1);
12287 wxPyEndAllowThreads(__tstate);
12288 if (PyErr_Occurred()) SWIG_fail;
12289 }
12290 resultobj = SWIG_Py_Void();
12291 {
12292 if (temp1)
12293 delete arg1;
12294 }
12295 return resultobj;
12296 fail:
12297 {
12298 if (temp1)
12299 delete arg1;
12300 }
12301 return NULL;
12302 }
12303
12304
12305 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12306 PyObject *resultobj = 0;
12307 wxString *arg1 = 0 ;
12308 bool temp1 = false ;
12309 PyObject * obj0 = 0 ;
12310 char * kwnames[] = {
12311 (char *) "msg", NULL
12312 };
12313
12314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
12315 {
12316 arg1 = wxString_in_helper(obj0);
12317 if (arg1 == NULL) SWIG_fail;
12318 temp1 = true;
12319 }
12320 {
12321 PyThreadState* __tstate = wxPyBeginAllowThreads();
12322 wxPyLogError((wxString const &)*arg1);
12323 wxPyEndAllowThreads(__tstate);
12324 if (PyErr_Occurred()) SWIG_fail;
12325 }
12326 resultobj = SWIG_Py_Void();
12327 {
12328 if (temp1)
12329 delete arg1;
12330 }
12331 return resultobj;
12332 fail:
12333 {
12334 if (temp1)
12335 delete arg1;
12336 }
12337 return NULL;
12338 }
12339
12340
12341 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12342 PyObject *resultobj = 0;
12343 wxString *arg1 = 0 ;
12344 bool temp1 = false ;
12345 PyObject * obj0 = 0 ;
12346 char * kwnames[] = {
12347 (char *) "msg", NULL
12348 };
12349
12350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
12351 {
12352 arg1 = wxString_in_helper(obj0);
12353 if (arg1 == NULL) SWIG_fail;
12354 temp1 = true;
12355 }
12356 {
12357 PyThreadState* __tstate = wxPyBeginAllowThreads();
12358 wxPyLogWarning((wxString const &)*arg1);
12359 wxPyEndAllowThreads(__tstate);
12360 if (PyErr_Occurred()) SWIG_fail;
12361 }
12362 resultobj = SWIG_Py_Void();
12363 {
12364 if (temp1)
12365 delete arg1;
12366 }
12367 return resultobj;
12368 fail:
12369 {
12370 if (temp1)
12371 delete arg1;
12372 }
12373 return NULL;
12374 }
12375
12376
12377 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12378 PyObject *resultobj = 0;
12379 wxString *arg1 = 0 ;
12380 bool temp1 = false ;
12381 PyObject * obj0 = 0 ;
12382 char * kwnames[] = {
12383 (char *) "msg", NULL
12384 };
12385
12386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
12387 {
12388 arg1 = wxString_in_helper(obj0);
12389 if (arg1 == NULL) SWIG_fail;
12390 temp1 = true;
12391 }
12392 {
12393 PyThreadState* __tstate = wxPyBeginAllowThreads();
12394 wxPyLogMessage((wxString const &)*arg1);
12395 wxPyEndAllowThreads(__tstate);
12396 if (PyErr_Occurred()) SWIG_fail;
12397 }
12398 resultobj = SWIG_Py_Void();
12399 {
12400 if (temp1)
12401 delete arg1;
12402 }
12403 return resultobj;
12404 fail:
12405 {
12406 if (temp1)
12407 delete arg1;
12408 }
12409 return NULL;
12410 }
12411
12412
12413 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12414 PyObject *resultobj = 0;
12415 wxString *arg1 = 0 ;
12416 bool temp1 = false ;
12417 PyObject * obj0 = 0 ;
12418 char * kwnames[] = {
12419 (char *) "msg", NULL
12420 };
12421
12422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
12423 {
12424 arg1 = wxString_in_helper(obj0);
12425 if (arg1 == NULL) SWIG_fail;
12426 temp1 = true;
12427 }
12428 {
12429 PyThreadState* __tstate = wxPyBeginAllowThreads();
12430 wxPyLogInfo((wxString const &)*arg1);
12431 wxPyEndAllowThreads(__tstate);
12432 if (PyErr_Occurred()) SWIG_fail;
12433 }
12434 resultobj = SWIG_Py_Void();
12435 {
12436 if (temp1)
12437 delete arg1;
12438 }
12439 return resultobj;
12440 fail:
12441 {
12442 if (temp1)
12443 delete arg1;
12444 }
12445 return NULL;
12446 }
12447
12448
12449 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12450 PyObject *resultobj = 0;
12451 wxString *arg1 = 0 ;
12452 bool temp1 = false ;
12453 PyObject * obj0 = 0 ;
12454 char * kwnames[] = {
12455 (char *) "msg", NULL
12456 };
12457
12458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
12459 {
12460 arg1 = wxString_in_helper(obj0);
12461 if (arg1 == NULL) SWIG_fail;
12462 temp1 = true;
12463 }
12464 {
12465 PyThreadState* __tstate = wxPyBeginAllowThreads();
12466 wxPyLogDebug((wxString const &)*arg1);
12467 wxPyEndAllowThreads(__tstate);
12468 if (PyErr_Occurred()) SWIG_fail;
12469 }
12470 resultobj = SWIG_Py_Void();
12471 {
12472 if (temp1)
12473 delete arg1;
12474 }
12475 return resultobj;
12476 fail:
12477 {
12478 if (temp1)
12479 delete arg1;
12480 }
12481 return NULL;
12482 }
12483
12484
12485 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12486 PyObject *resultobj = 0;
12487 wxString *arg1 = 0 ;
12488 bool temp1 = false ;
12489 PyObject * obj0 = 0 ;
12490 char * kwnames[] = {
12491 (char *) "msg", NULL
12492 };
12493
12494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
12495 {
12496 arg1 = wxString_in_helper(obj0);
12497 if (arg1 == NULL) SWIG_fail;
12498 temp1 = true;
12499 }
12500 {
12501 PyThreadState* __tstate = wxPyBeginAllowThreads();
12502 wxPyLogVerbose((wxString const &)*arg1);
12503 wxPyEndAllowThreads(__tstate);
12504 if (PyErr_Occurred()) SWIG_fail;
12505 }
12506 resultobj = SWIG_Py_Void();
12507 {
12508 if (temp1)
12509 delete arg1;
12510 }
12511 return resultobj;
12512 fail:
12513 {
12514 if (temp1)
12515 delete arg1;
12516 }
12517 return NULL;
12518 }
12519
12520
12521 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12522 PyObject *resultobj = 0;
12523 wxString *arg1 = 0 ;
12524 bool temp1 = false ;
12525 PyObject * obj0 = 0 ;
12526 char * kwnames[] = {
12527 (char *) "msg", NULL
12528 };
12529
12530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
12531 {
12532 arg1 = wxString_in_helper(obj0);
12533 if (arg1 == NULL) SWIG_fail;
12534 temp1 = true;
12535 }
12536 {
12537 PyThreadState* __tstate = wxPyBeginAllowThreads();
12538 wxPyLogStatus((wxString const &)*arg1);
12539 wxPyEndAllowThreads(__tstate);
12540 if (PyErr_Occurred()) SWIG_fail;
12541 }
12542 resultobj = SWIG_Py_Void();
12543 {
12544 if (temp1)
12545 delete arg1;
12546 }
12547 return resultobj;
12548 fail:
12549 {
12550 if (temp1)
12551 delete arg1;
12552 }
12553 return NULL;
12554 }
12555
12556
12557 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12558 PyObject *resultobj = 0;
12559 wxFrame *arg1 = (wxFrame *) 0 ;
12560 wxString *arg2 = 0 ;
12561 void *argp1 = 0 ;
12562 int res1 = 0 ;
12563 bool temp2 = false ;
12564 PyObject * obj0 = 0 ;
12565 PyObject * obj1 = 0 ;
12566 char * kwnames[] = {
12567 (char *) "pFrame",(char *) "msg", NULL
12568 };
12569
12570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
12571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12572 if (!SWIG_IsOK(res1)) {
12573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
12574 }
12575 arg1 = reinterpret_cast< wxFrame * >(argp1);
12576 {
12577 arg2 = wxString_in_helper(obj1);
12578 if (arg2 == NULL) SWIG_fail;
12579 temp2 = true;
12580 }
12581 {
12582 PyThreadState* __tstate = wxPyBeginAllowThreads();
12583 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
12584 wxPyEndAllowThreads(__tstate);
12585 if (PyErr_Occurred()) SWIG_fail;
12586 }
12587 resultobj = SWIG_Py_Void();
12588 {
12589 if (temp2)
12590 delete arg2;
12591 }
12592 return resultobj;
12593 fail:
12594 {
12595 if (temp2)
12596 delete arg2;
12597 }
12598 return NULL;
12599 }
12600
12601
12602 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12603 PyObject *resultobj = 0;
12604 wxString *arg1 = 0 ;
12605 bool temp1 = false ;
12606 PyObject * obj0 = 0 ;
12607 char * kwnames[] = {
12608 (char *) "msg", NULL
12609 };
12610
12611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
12612 {
12613 arg1 = wxString_in_helper(obj0);
12614 if (arg1 == NULL) SWIG_fail;
12615 temp1 = true;
12616 }
12617 {
12618 PyThreadState* __tstate = wxPyBeginAllowThreads();
12619 wxPyLogSysError((wxString const &)*arg1);
12620 wxPyEndAllowThreads(__tstate);
12621 if (PyErr_Occurred()) SWIG_fail;
12622 }
12623 resultobj = SWIG_Py_Void();
12624 {
12625 if (temp1)
12626 delete arg1;
12627 }
12628 return resultobj;
12629 fail:
12630 {
12631 if (temp1)
12632 delete arg1;
12633 }
12634 return NULL;
12635 }
12636
12637
12638 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12639 PyObject *resultobj = 0;
12640 unsigned long arg1 ;
12641 wxString *arg2 = 0 ;
12642 unsigned long val1 ;
12643 int ecode1 = 0 ;
12644 bool temp2 = false ;
12645 PyObject * obj0 = 0 ;
12646 PyObject * obj1 = 0 ;
12647 char * kwnames[] = {
12648 (char *) "level",(char *) "msg", NULL
12649 };
12650
12651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
12652 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12653 if (!SWIG_IsOK(ecode1)) {
12654 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
12655 }
12656 arg1 = static_cast< unsigned long >(val1);
12657 {
12658 arg2 = wxString_in_helper(obj1);
12659 if (arg2 == NULL) SWIG_fail;
12660 temp2 = true;
12661 }
12662 {
12663 PyThreadState* __tstate = wxPyBeginAllowThreads();
12664 wxPyLogGeneric(arg1,(wxString const &)*arg2);
12665 wxPyEndAllowThreads(__tstate);
12666 if (PyErr_Occurred()) SWIG_fail;
12667 }
12668 resultobj = SWIG_Py_Void();
12669 {
12670 if (temp2)
12671 delete arg2;
12672 }
12673 return resultobj;
12674 fail:
12675 {
12676 if (temp2)
12677 delete arg2;
12678 }
12679 return NULL;
12680 }
12681
12682
12683 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12684 PyObject *resultobj = 0;
12685 unsigned long arg1 ;
12686 wxString *arg2 = 0 ;
12687 unsigned long val1 ;
12688 int ecode1 = 0 ;
12689 bool temp2 = false ;
12690
12691 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12692 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
12693 if (!SWIG_IsOK(ecode1)) {
12694 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
12695 }
12696 arg1 = static_cast< unsigned long >(val1);
12697 {
12698 arg2 = wxString_in_helper(swig_obj[1]);
12699 if (arg2 == NULL) SWIG_fail;
12700 temp2 = true;
12701 }
12702 {
12703 PyThreadState* __tstate = wxPyBeginAllowThreads();
12704 wxPyLogTrace(arg1,(wxString const &)*arg2);
12705 wxPyEndAllowThreads(__tstate);
12706 if (PyErr_Occurred()) SWIG_fail;
12707 }
12708 resultobj = SWIG_Py_Void();
12709 {
12710 if (temp2)
12711 delete arg2;
12712 }
12713 return resultobj;
12714 fail:
12715 {
12716 if (temp2)
12717 delete arg2;
12718 }
12719 return NULL;
12720 }
12721
12722
12723 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12724 PyObject *resultobj = 0;
12725 wxString *arg1 = 0 ;
12726 wxString *arg2 = 0 ;
12727 bool temp1 = false ;
12728 bool temp2 = false ;
12729
12730 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12731 {
12732 arg1 = wxString_in_helper(swig_obj[0]);
12733 if (arg1 == NULL) SWIG_fail;
12734 temp1 = true;
12735 }
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((wxString const &)*arg1,(wxString const &)*arg2);
12744 wxPyEndAllowThreads(__tstate);
12745 if (PyErr_Occurred()) SWIG_fail;
12746 }
12747 resultobj = SWIG_Py_Void();
12748 {
12749 if (temp1)
12750 delete arg1;
12751 }
12752 {
12753 if (temp2)
12754 delete arg2;
12755 }
12756 return resultobj;
12757 fail:
12758 {
12759 if (temp1)
12760 delete arg1;
12761 }
12762 {
12763 if (temp2)
12764 delete arg2;
12765 }
12766 return NULL;
12767 }
12768
12769
12770 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
12771 int argc;
12772 PyObject *argv[3];
12773
12774 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
12775 --argc;
12776 if (argc == 2) {
12777 int _v = 0;
12778 {
12779 {
12780 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12781 }
12782 }
12783 if (!_v) goto check_1;
12784 return _wrap_LogTrace__SWIG_1(self, argc, argv);
12785 }
12786 check_1:
12787
12788 if (argc == 2) {
12789 return _wrap_LogTrace__SWIG_0(self, argc, argv);
12790 }
12791
12792 fail:
12793 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
12794 return NULL;
12795 }
12796
12797
12798 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12799 PyObject *resultobj = 0;
12800 wxString *arg1 = 0 ;
12801 wxString *arg2 = 0 ;
12802 bool temp1 = false ;
12803 bool temp2 = false ;
12804 PyObject * obj0 = 0 ;
12805 PyObject * obj1 = 0 ;
12806 char * kwnames[] = {
12807 (char *) "title",(char *) "text", NULL
12808 };
12809
12810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
12811 {
12812 arg1 = wxString_in_helper(obj0);
12813 if (arg1 == NULL) SWIG_fail;
12814 temp1 = true;
12815 }
12816 {
12817 arg2 = wxString_in_helper(obj1);
12818 if (arg2 == NULL) SWIG_fail;
12819 temp2 = true;
12820 }
12821 {
12822 PyThreadState* __tstate = wxPyBeginAllowThreads();
12823 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
12824 wxPyEndAllowThreads(__tstate);
12825 if (PyErr_Occurred()) SWIG_fail;
12826 }
12827 resultobj = SWIG_Py_Void();
12828 {
12829 if (temp1)
12830 delete arg1;
12831 }
12832 {
12833 if (temp2)
12834 delete arg2;
12835 }
12836 return resultobj;
12837 fail:
12838 {
12839 if (temp1)
12840 delete arg1;
12841 }
12842 {
12843 if (temp2)
12844 delete arg2;
12845 }
12846 return NULL;
12847 }
12848
12849
12850 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12851 PyObject *resultobj = 0;
12852 wxLogNull *result = 0 ;
12853
12854 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
12855 {
12856 PyThreadState* __tstate = wxPyBeginAllowThreads();
12857 result = (wxLogNull *)new wxLogNull();
12858 wxPyEndAllowThreads(__tstate);
12859 if (PyErr_Occurred()) SWIG_fail;
12860 }
12861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
12862 return resultobj;
12863 fail:
12864 return NULL;
12865 }
12866
12867
12868 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12869 PyObject *resultobj = 0;
12870 wxLogNull *arg1 = (wxLogNull *) 0 ;
12871 void *argp1 = 0 ;
12872 int res1 = 0 ;
12873 PyObject *swig_obj[1] ;
12874
12875 if (!args) SWIG_fail;
12876 swig_obj[0] = args;
12877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
12878 if (!SWIG_IsOK(res1)) {
12879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
12880 }
12881 arg1 = reinterpret_cast< wxLogNull * >(argp1);
12882 {
12883 PyThreadState* __tstate = wxPyBeginAllowThreads();
12884 delete arg1;
12885
12886 wxPyEndAllowThreads(__tstate);
12887 if (PyErr_Occurred()) SWIG_fail;
12888 }
12889 resultobj = SWIG_Py_Void();
12890 return resultobj;
12891 fail:
12892 return NULL;
12893 }
12894
12895
12896 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12897 PyObject *obj;
12898 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12899 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
12900 return SWIG_Py_Void();
12901 }
12902
12903 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12904 return SWIG_Python_InitShadowInstance(args);
12905 }
12906
12907 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12908 PyObject *resultobj = 0;
12909 wxPyLog *result = 0 ;
12910
12911 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
12912 {
12913 PyThreadState* __tstate = wxPyBeginAllowThreads();
12914 result = (wxPyLog *)new wxPyLog();
12915 wxPyEndAllowThreads(__tstate);
12916 if (PyErr_Occurred()) SWIG_fail;
12917 }
12918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
12919 return resultobj;
12920 fail:
12921 return NULL;
12922 }
12923
12924
12925 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12926 PyObject *resultobj = 0;
12927 wxPyLog *arg1 = (wxPyLog *) 0 ;
12928 PyObject *arg2 = (PyObject *) 0 ;
12929 PyObject *arg3 = (PyObject *) 0 ;
12930 void *argp1 = 0 ;
12931 int res1 = 0 ;
12932 PyObject * obj0 = 0 ;
12933 PyObject * obj1 = 0 ;
12934 PyObject * obj2 = 0 ;
12935 char * kwnames[] = {
12936 (char *) "self",(char *) "self",(char *) "_class", NULL
12937 };
12938
12939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
12941 if (!SWIG_IsOK(res1)) {
12942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
12943 }
12944 arg1 = reinterpret_cast< wxPyLog * >(argp1);
12945 arg2 = obj1;
12946 arg3 = obj2;
12947 {
12948 PyThreadState* __tstate = wxPyBeginAllowThreads();
12949 (arg1)->_setCallbackInfo(arg2,arg3);
12950 wxPyEndAllowThreads(__tstate);
12951 if (PyErr_Occurred()) SWIG_fail;
12952 }
12953 resultobj = SWIG_Py_Void();
12954 return resultobj;
12955 fail:
12956 return NULL;
12957 }
12958
12959
12960 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12961 PyObject *obj;
12962 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12963 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
12964 return SWIG_Py_Void();
12965 }
12966
12967 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12968 return SWIG_Python_InitShadowInstance(args);
12969 }
12970
12971 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12972 PyObject *resultobj = 0;
12973 int arg1 ;
12974 wxSignal arg2 = (wxSignal) wxSIGTERM ;
12975 int arg3 = (int) wxKILL_NOCHILDREN ;
12976 wxKillError result;
12977 int val1 ;
12978 int ecode1 = 0 ;
12979 int val2 ;
12980 int ecode2 = 0 ;
12981 int val3 ;
12982 int ecode3 = 0 ;
12983 PyObject * obj0 = 0 ;
12984 PyObject * obj1 = 0 ;
12985 PyObject * obj2 = 0 ;
12986 char * kwnames[] = {
12987 (char *) "pid",(char *) "sig",(char *) "flags", NULL
12988 };
12989
12990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12991 ecode1 = SWIG_AsVal_int(obj0, &val1);
12992 if (!SWIG_IsOK(ecode1)) {
12993 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
12994 }
12995 arg1 = static_cast< int >(val1);
12996 if (obj1) {
12997 ecode2 = SWIG_AsVal_int(obj1, &val2);
12998 if (!SWIG_IsOK(ecode2)) {
12999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13000 }
13001 arg2 = static_cast< wxSignal >(val2);
13002 }
13003 if (obj2) {
13004 ecode3 = SWIG_AsVal_int(obj2, &val3);
13005 if (!SWIG_IsOK(ecode3)) {
13006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
13007 }
13008 arg3 = static_cast< int >(val3);
13009 }
13010 {
13011 PyThreadState* __tstate = wxPyBeginAllowThreads();
13012 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
13013 wxPyEndAllowThreads(__tstate);
13014 if (PyErr_Occurred()) SWIG_fail;
13015 }
13016 resultobj = SWIG_From_int(static_cast< int >(result));
13017 return resultobj;
13018 fail:
13019 return NULL;
13020 }
13021
13022
13023 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13024 PyObject *resultobj = 0;
13025 int arg1 ;
13026 bool result;
13027 int val1 ;
13028 int ecode1 = 0 ;
13029 PyObject * obj0 = 0 ;
13030 char * kwnames[] = {
13031 (char *) "pid", NULL
13032 };
13033
13034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
13035 ecode1 = SWIG_AsVal_int(obj0, &val1);
13036 if (!SWIG_IsOK(ecode1)) {
13037 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
13038 }
13039 arg1 = static_cast< int >(val1);
13040 {
13041 PyThreadState* __tstate = wxPyBeginAllowThreads();
13042 result = (bool)wxPyProcess::Exists(arg1);
13043 wxPyEndAllowThreads(__tstate);
13044 if (PyErr_Occurred()) SWIG_fail;
13045 }
13046 {
13047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13048 }
13049 return resultobj;
13050 fail:
13051 return NULL;
13052 }
13053
13054
13055 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13056 PyObject *resultobj = 0;
13057 wxString *arg1 = 0 ;
13058 int arg2 = (int) wxEXEC_ASYNC ;
13059 wxPyProcess *result = 0 ;
13060 bool temp1 = false ;
13061 int val2 ;
13062 int ecode2 = 0 ;
13063 PyObject * obj0 = 0 ;
13064 PyObject * obj1 = 0 ;
13065 char * kwnames[] = {
13066 (char *) "cmd",(char *) "flags", NULL
13067 };
13068
13069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
13070 {
13071 arg1 = wxString_in_helper(obj0);
13072 if (arg1 == NULL) SWIG_fail;
13073 temp1 = true;
13074 }
13075 if (obj1) {
13076 ecode2 = SWIG_AsVal_int(obj1, &val2);
13077 if (!SWIG_IsOK(ecode2)) {
13078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
13079 }
13080 arg2 = static_cast< int >(val2);
13081 }
13082 {
13083 PyThreadState* __tstate = wxPyBeginAllowThreads();
13084 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
13085 wxPyEndAllowThreads(__tstate);
13086 if (PyErr_Occurred()) SWIG_fail;
13087 }
13088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
13089 {
13090 if (temp1)
13091 delete arg1;
13092 }
13093 return resultobj;
13094 fail:
13095 {
13096 if (temp1)
13097 delete arg1;
13098 }
13099 return NULL;
13100 }
13101
13102
13103 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13104 PyObject *resultobj = 0;
13105 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
13106 int arg2 = (int) -1 ;
13107 wxPyProcess *result = 0 ;
13108 void *argp1 = 0 ;
13109 int res1 = 0 ;
13110 int val2 ;
13111 int ecode2 = 0 ;
13112 PyObject * obj0 = 0 ;
13113 PyObject * obj1 = 0 ;
13114 char * kwnames[] = {
13115 (char *) "parent",(char *) "id", NULL
13116 };
13117
13118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
13119 if (obj0) {
13120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
13121 if (!SWIG_IsOK(res1)) {
13122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
13123 }
13124 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
13125 }
13126 if (obj1) {
13127 ecode2 = SWIG_AsVal_int(obj1, &val2);
13128 if (!SWIG_IsOK(ecode2)) {
13129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
13130 }
13131 arg2 = static_cast< int >(val2);
13132 }
13133 {
13134 PyThreadState* __tstate = wxPyBeginAllowThreads();
13135 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
13136 wxPyEndAllowThreads(__tstate);
13137 if (PyErr_Occurred()) SWIG_fail;
13138 }
13139 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
13140 return resultobj;
13141 fail:
13142 return NULL;
13143 }
13144
13145
13146 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13147 PyObject *resultobj = 0;
13148 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13149 PyObject *arg2 = (PyObject *) 0 ;
13150 PyObject *arg3 = (PyObject *) 0 ;
13151 void *argp1 = 0 ;
13152 int res1 = 0 ;
13153 PyObject * obj0 = 0 ;
13154 PyObject * obj1 = 0 ;
13155 PyObject * obj2 = 0 ;
13156 char * kwnames[] = {
13157 (char *) "self",(char *) "self",(char *) "_class", NULL
13158 };
13159
13160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13162 if (!SWIG_IsOK(res1)) {
13163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13164 }
13165 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13166 arg2 = obj1;
13167 arg3 = obj2;
13168 {
13169 PyThreadState* __tstate = wxPyBeginAllowThreads();
13170 (arg1)->_setCallbackInfo(arg2,arg3);
13171 wxPyEndAllowThreads(__tstate);
13172 if (PyErr_Occurred()) SWIG_fail;
13173 }
13174 resultobj = SWIG_Py_Void();
13175 return resultobj;
13176 fail:
13177 return NULL;
13178 }
13179
13180
13181 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13182 PyObject *resultobj = 0;
13183 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13184 int arg2 ;
13185 int arg3 ;
13186 void *argp1 = 0 ;
13187 int res1 = 0 ;
13188 int val2 ;
13189 int ecode2 = 0 ;
13190 int val3 ;
13191 int ecode3 = 0 ;
13192 PyObject * obj0 = 0 ;
13193 PyObject * obj1 = 0 ;
13194 PyObject * obj2 = 0 ;
13195 char * kwnames[] = {
13196 (char *) "self",(char *) "pid",(char *) "status", NULL
13197 };
13198
13199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",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_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13203 }
13204 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13205 ecode2 = SWIG_AsVal_int(obj1, &val2);
13206 if (!SWIG_IsOK(ecode2)) {
13207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
13208 }
13209 arg2 = static_cast< int >(val2);
13210 ecode3 = SWIG_AsVal_int(obj2, &val3);
13211 if (!SWIG_IsOK(ecode3)) {
13212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
13213 }
13214 arg3 = static_cast< int >(val3);
13215 {
13216 PyThreadState* __tstate = wxPyBeginAllowThreads();
13217 (arg1)->OnTerminate(arg2,arg3);
13218 wxPyEndAllowThreads(__tstate);
13219 if (PyErr_Occurred()) SWIG_fail;
13220 }
13221 resultobj = SWIG_Py_Void();
13222 return resultobj;
13223 fail:
13224 return NULL;
13225 }
13226
13227
13228 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13229 PyObject *resultobj = 0;
13230 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13231 void *argp1 = 0 ;
13232 int res1 = 0 ;
13233 PyObject *swig_obj[1] ;
13234
13235 if (!args) SWIG_fail;
13236 swig_obj[0] = args;
13237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13238 if (!SWIG_IsOK(res1)) {
13239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13240 }
13241 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13242 {
13243 PyThreadState* __tstate = wxPyBeginAllowThreads();
13244 (arg1)->Redirect();
13245 wxPyEndAllowThreads(__tstate);
13246 if (PyErr_Occurred()) SWIG_fail;
13247 }
13248 resultobj = SWIG_Py_Void();
13249 return resultobj;
13250 fail:
13251 return NULL;
13252 }
13253
13254
13255 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13256 PyObject *resultobj = 0;
13257 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13258 bool result;
13259 void *argp1 = 0 ;
13260 int res1 = 0 ;
13261 PyObject *swig_obj[1] ;
13262
13263 if (!args) SWIG_fail;
13264 swig_obj[0] = args;
13265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13266 if (!SWIG_IsOK(res1)) {
13267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13268 }
13269 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13270 {
13271 PyThreadState* __tstate = wxPyBeginAllowThreads();
13272 result = (bool)(arg1)->IsRedirected();
13273 wxPyEndAllowThreads(__tstate);
13274 if (PyErr_Occurred()) SWIG_fail;
13275 }
13276 {
13277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13278 }
13279 return resultobj;
13280 fail:
13281 return NULL;
13282 }
13283
13284
13285 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13286 PyObject *resultobj = 0;
13287 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13288 void *argp1 = 0 ;
13289 int res1 = 0 ;
13290 PyObject *swig_obj[1] ;
13291
13292 if (!args) SWIG_fail;
13293 swig_obj[0] = args;
13294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13295 if (!SWIG_IsOK(res1)) {
13296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13297 }
13298 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13299 {
13300 PyThreadState* __tstate = wxPyBeginAllowThreads();
13301 (arg1)->Detach();
13302 wxPyEndAllowThreads(__tstate);
13303 if (PyErr_Occurred()) SWIG_fail;
13304 }
13305 resultobj = SWIG_Py_Void();
13306 return resultobj;
13307 fail:
13308 return NULL;
13309 }
13310
13311
13312 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13313 PyObject *resultobj = 0;
13314 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13315 wxInputStream *result = 0 ;
13316 void *argp1 = 0 ;
13317 int res1 = 0 ;
13318 PyObject *swig_obj[1] ;
13319
13320 if (!args) SWIG_fail;
13321 swig_obj[0] = args;
13322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13323 if (!SWIG_IsOK(res1)) {
13324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13325 }
13326 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13327 {
13328 PyThreadState* __tstate = wxPyBeginAllowThreads();
13329 result = (wxInputStream *)(arg1)->GetInputStream();
13330 wxPyEndAllowThreads(__tstate);
13331 if (PyErr_Occurred()) SWIG_fail;
13332 }
13333 {
13334 wxPyInputStream * _ptr = NULL;
13335
13336 if (result) {
13337 _ptr = new wxPyInputStream(result);
13338 }
13339 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13340 }
13341 return resultobj;
13342 fail:
13343 return NULL;
13344 }
13345
13346
13347 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13348 PyObject *resultobj = 0;
13349 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13350 wxInputStream *result = 0 ;
13351 void *argp1 = 0 ;
13352 int res1 = 0 ;
13353 PyObject *swig_obj[1] ;
13354
13355 if (!args) SWIG_fail;
13356 swig_obj[0] = args;
13357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13358 if (!SWIG_IsOK(res1)) {
13359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13360 }
13361 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13362 {
13363 PyThreadState* __tstate = wxPyBeginAllowThreads();
13364 result = (wxInputStream *)(arg1)->GetErrorStream();
13365 wxPyEndAllowThreads(__tstate);
13366 if (PyErr_Occurred()) SWIG_fail;
13367 }
13368 {
13369 wxPyInputStream * _ptr = NULL;
13370
13371 if (result) {
13372 _ptr = new wxPyInputStream(result);
13373 }
13374 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13375 }
13376 return resultobj;
13377 fail:
13378 return NULL;
13379 }
13380
13381
13382 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13383 PyObject *resultobj = 0;
13384 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13385 wxOutputStream *result = 0 ;
13386 void *argp1 = 0 ;
13387 int res1 = 0 ;
13388 PyObject *swig_obj[1] ;
13389
13390 if (!args) SWIG_fail;
13391 swig_obj[0] = args;
13392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13393 if (!SWIG_IsOK(res1)) {
13394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13395 }
13396 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13397 {
13398 PyThreadState* __tstate = wxPyBeginAllowThreads();
13399 result = (wxOutputStream *)(arg1)->GetOutputStream();
13400 wxPyEndAllowThreads(__tstate);
13401 if (PyErr_Occurred()) SWIG_fail;
13402 }
13403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
13404 return resultobj;
13405 fail:
13406 return NULL;
13407 }
13408
13409
13410 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13411 PyObject *resultobj = 0;
13412 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13413 void *argp1 = 0 ;
13414 int res1 = 0 ;
13415 PyObject *swig_obj[1] ;
13416
13417 if (!args) SWIG_fail;
13418 swig_obj[0] = args;
13419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13420 if (!SWIG_IsOK(res1)) {
13421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13422 }
13423 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13424 {
13425 PyThreadState* __tstate = wxPyBeginAllowThreads();
13426 (arg1)->CloseOutput();
13427 wxPyEndAllowThreads(__tstate);
13428 if (PyErr_Occurred()) SWIG_fail;
13429 }
13430 resultobj = SWIG_Py_Void();
13431 return resultobj;
13432 fail:
13433 return NULL;
13434 }
13435
13436
13437 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13438 PyObject *resultobj = 0;
13439 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13440 bool result;
13441 void *argp1 = 0 ;
13442 int res1 = 0 ;
13443 PyObject *swig_obj[1] ;
13444
13445 if (!args) SWIG_fail;
13446 swig_obj[0] = args;
13447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13448 if (!SWIG_IsOK(res1)) {
13449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13450 }
13451 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13452 {
13453 PyThreadState* __tstate = wxPyBeginAllowThreads();
13454 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
13455 wxPyEndAllowThreads(__tstate);
13456 if (PyErr_Occurred()) SWIG_fail;
13457 }
13458 {
13459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13460 }
13461 return resultobj;
13462 fail:
13463 return NULL;
13464 }
13465
13466
13467 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13468 PyObject *resultobj = 0;
13469 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13470 bool result;
13471 void *argp1 = 0 ;
13472 int res1 = 0 ;
13473 PyObject *swig_obj[1] ;
13474
13475 if (!args) SWIG_fail;
13476 swig_obj[0] = args;
13477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13478 if (!SWIG_IsOK(res1)) {
13479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13480 }
13481 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13482 {
13483 PyThreadState* __tstate = wxPyBeginAllowThreads();
13484 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
13485 wxPyEndAllowThreads(__tstate);
13486 if (PyErr_Occurred()) SWIG_fail;
13487 }
13488 {
13489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13490 }
13491 return resultobj;
13492 fail:
13493 return NULL;
13494 }
13495
13496
13497 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13498 PyObject *resultobj = 0;
13499 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13500 bool result;
13501 void *argp1 = 0 ;
13502 int res1 = 0 ;
13503 PyObject *swig_obj[1] ;
13504
13505 if (!args) SWIG_fail;
13506 swig_obj[0] = args;
13507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13508 if (!SWIG_IsOK(res1)) {
13509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13510 }
13511 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13512 {
13513 PyThreadState* __tstate = wxPyBeginAllowThreads();
13514 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
13515 wxPyEndAllowThreads(__tstate);
13516 if (PyErr_Occurred()) SWIG_fail;
13517 }
13518 {
13519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13520 }
13521 return resultobj;
13522 fail:
13523 return NULL;
13524 }
13525
13526
13527 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13528 PyObject *obj;
13529 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13530 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
13531 return SWIG_Py_Void();
13532 }
13533
13534 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13535 return SWIG_Python_InitShadowInstance(args);
13536 }
13537
13538 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13539 PyObject *resultobj = 0;
13540 int arg1 = (int) 0 ;
13541 int arg2 = (int) 0 ;
13542 int arg3 = (int) 0 ;
13543 wxProcessEvent *result = 0 ;
13544 int val1 ;
13545 int ecode1 = 0 ;
13546 int val2 ;
13547 int ecode2 = 0 ;
13548 int val3 ;
13549 int ecode3 = 0 ;
13550 PyObject * obj0 = 0 ;
13551 PyObject * obj1 = 0 ;
13552 PyObject * obj2 = 0 ;
13553 char * kwnames[] = {
13554 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
13555 };
13556
13557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13558 if (obj0) {
13559 ecode1 = SWIG_AsVal_int(obj0, &val1);
13560 if (!SWIG_IsOK(ecode1)) {
13561 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
13562 }
13563 arg1 = static_cast< int >(val1);
13564 }
13565 if (obj1) {
13566 ecode2 = SWIG_AsVal_int(obj1, &val2);
13567 if (!SWIG_IsOK(ecode2)) {
13568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
13569 }
13570 arg2 = static_cast< int >(val2);
13571 }
13572 if (obj2) {
13573 ecode3 = SWIG_AsVal_int(obj2, &val3);
13574 if (!SWIG_IsOK(ecode3)) {
13575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
13576 }
13577 arg3 = static_cast< int >(val3);
13578 }
13579 {
13580 PyThreadState* __tstate = wxPyBeginAllowThreads();
13581 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
13582 wxPyEndAllowThreads(__tstate);
13583 if (PyErr_Occurred()) SWIG_fail;
13584 }
13585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
13586 return resultobj;
13587 fail:
13588 return NULL;
13589 }
13590
13591
13592 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13593 PyObject *resultobj = 0;
13594 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13595 int result;
13596 void *argp1 = 0 ;
13597 int res1 = 0 ;
13598 PyObject *swig_obj[1] ;
13599
13600 if (!args) SWIG_fail;
13601 swig_obj[0] = args;
13602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13603 if (!SWIG_IsOK(res1)) {
13604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13605 }
13606 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13607 {
13608 PyThreadState* __tstate = wxPyBeginAllowThreads();
13609 result = (int)(arg1)->GetPid();
13610 wxPyEndAllowThreads(__tstate);
13611 if (PyErr_Occurred()) SWIG_fail;
13612 }
13613 resultobj = SWIG_From_int(static_cast< int >(result));
13614 return resultobj;
13615 fail:
13616 return NULL;
13617 }
13618
13619
13620 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13621 PyObject *resultobj = 0;
13622 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13623 int result;
13624 void *argp1 = 0 ;
13625 int res1 = 0 ;
13626 PyObject *swig_obj[1] ;
13627
13628 if (!args) SWIG_fail;
13629 swig_obj[0] = args;
13630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13631 if (!SWIG_IsOK(res1)) {
13632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13633 }
13634 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13635 {
13636 PyThreadState* __tstate = wxPyBeginAllowThreads();
13637 result = (int)(arg1)->GetExitCode();
13638 wxPyEndAllowThreads(__tstate);
13639 if (PyErr_Occurred()) SWIG_fail;
13640 }
13641 resultobj = SWIG_From_int(static_cast< int >(result));
13642 return resultobj;
13643 fail:
13644 return NULL;
13645 }
13646
13647
13648 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13649 PyObject *resultobj = 0;
13650 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13651 int arg2 ;
13652 void *argp1 = 0 ;
13653 int res1 = 0 ;
13654 int val2 ;
13655 int ecode2 = 0 ;
13656 PyObject *swig_obj[2] ;
13657
13658 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
13659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13660 if (!SWIG_IsOK(res1)) {
13661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13662 }
13663 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13664 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13665 if (!SWIG_IsOK(ecode2)) {
13666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
13667 }
13668 arg2 = static_cast< int >(val2);
13669 if (arg1) (arg1)->m_pid = arg2;
13670
13671 resultobj = SWIG_Py_Void();
13672 return resultobj;
13673 fail:
13674 return NULL;
13675 }
13676
13677
13678 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13679 PyObject *resultobj = 0;
13680 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13681 int result;
13682 void *argp1 = 0 ;
13683 int res1 = 0 ;
13684 PyObject *swig_obj[1] ;
13685
13686 if (!args) SWIG_fail;
13687 swig_obj[0] = args;
13688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13689 if (!SWIG_IsOK(res1)) {
13690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13691 }
13692 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13693 result = (int) ((arg1)->m_pid);
13694 resultobj = SWIG_From_int(static_cast< int >(result));
13695 return resultobj;
13696 fail:
13697 return NULL;
13698 }
13699
13700
13701 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13702 PyObject *resultobj = 0;
13703 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13704 int arg2 ;
13705 void *argp1 = 0 ;
13706 int res1 = 0 ;
13707 int val2 ;
13708 int ecode2 = 0 ;
13709 PyObject *swig_obj[2] ;
13710
13711 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
13712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13713 if (!SWIG_IsOK(res1)) {
13714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13715 }
13716 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13717 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13718 if (!SWIG_IsOK(ecode2)) {
13719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
13720 }
13721 arg2 = static_cast< int >(val2);
13722 if (arg1) (arg1)->m_exitcode = arg2;
13723
13724 resultobj = SWIG_Py_Void();
13725 return resultobj;
13726 fail:
13727 return NULL;
13728 }
13729
13730
13731 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13732 PyObject *resultobj = 0;
13733 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13734 int result;
13735 void *argp1 = 0 ;
13736 int res1 = 0 ;
13737 PyObject *swig_obj[1] ;
13738
13739 if (!args) SWIG_fail;
13740 swig_obj[0] = args;
13741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13742 if (!SWIG_IsOK(res1)) {
13743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13744 }
13745 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13746 result = (int) ((arg1)->m_exitcode);
13747 resultobj = SWIG_From_int(static_cast< int >(result));
13748 return resultobj;
13749 fail:
13750 return NULL;
13751 }
13752
13753
13754 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13755 PyObject *obj;
13756 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13757 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
13758 return SWIG_Py_Void();
13759 }
13760
13761 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13762 return SWIG_Python_InitShadowInstance(args);
13763 }
13764
13765 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13766 PyObject *resultobj = 0;
13767 wxString *arg1 = 0 ;
13768 int arg2 = (int) wxEXEC_ASYNC ;
13769 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
13770 long result;
13771 bool temp1 = false ;
13772 int val2 ;
13773 int ecode2 = 0 ;
13774 void *argp3 = 0 ;
13775 int res3 = 0 ;
13776 PyObject * obj0 = 0 ;
13777 PyObject * obj1 = 0 ;
13778 PyObject * obj2 = 0 ;
13779 char * kwnames[] = {
13780 (char *) "command",(char *) "flags",(char *) "process", NULL
13781 };
13782
13783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13784 {
13785 arg1 = wxString_in_helper(obj0);
13786 if (arg1 == NULL) SWIG_fail;
13787 temp1 = true;
13788 }
13789 if (obj1) {
13790 ecode2 = SWIG_AsVal_int(obj1, &val2);
13791 if (!SWIG_IsOK(ecode2)) {
13792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
13793 }
13794 arg2 = static_cast< int >(val2);
13795 }
13796 if (obj2) {
13797 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13798 if (!SWIG_IsOK(res3)) {
13799 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
13800 }
13801 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
13802 }
13803 {
13804 if (!wxPyCheckForApp()) SWIG_fail;
13805 PyThreadState* __tstate = wxPyBeginAllowThreads();
13806 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
13807 wxPyEndAllowThreads(__tstate);
13808 if (PyErr_Occurred()) SWIG_fail;
13809 }
13810 resultobj = SWIG_From_long(static_cast< long >(result));
13811 {
13812 if (temp1)
13813 delete arg1;
13814 }
13815 return resultobj;
13816 fail:
13817 {
13818 if (temp1)
13819 delete arg1;
13820 }
13821 return NULL;
13822 }
13823
13824
13825 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13826 PyObject *resultobj = 0;
13827 long arg1 ;
13828 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13829 wxKillError *arg3 = (wxKillError *) 0 ;
13830 int arg4 = (int) wxKILL_NOCHILDREN ;
13831 int result;
13832 long val1 ;
13833 int ecode1 = 0 ;
13834 int val2 ;
13835 int ecode2 = 0 ;
13836 wxKillError temp3 ;
13837 int val4 ;
13838 int ecode4 = 0 ;
13839 PyObject * obj0 = 0 ;
13840 PyObject * obj1 = 0 ;
13841 PyObject * obj2 = 0 ;
13842 char * kwnames[] = {
13843 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13844 };
13845
13846 {
13847 arg3 = &temp3;
13848 }
13849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13850 ecode1 = SWIG_AsVal_long(obj0, &val1);
13851 if (!SWIG_IsOK(ecode1)) {
13852 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
13853 }
13854 arg1 = static_cast< long >(val1);
13855 if (obj1) {
13856 ecode2 = SWIG_AsVal_int(obj1, &val2);
13857 if (!SWIG_IsOK(ecode2)) {
13858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13859 }
13860 arg2 = static_cast< wxSignal >(val2);
13861 }
13862 if (obj2) {
13863 ecode4 = SWIG_AsVal_int(obj2, &val4);
13864 if (!SWIG_IsOK(ecode4)) {
13865 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
13866 }
13867 arg4 = static_cast< int >(val4);
13868 }
13869 {
13870 PyThreadState* __tstate = wxPyBeginAllowThreads();
13871 result = (int)wxKill(arg1,arg2,arg3,arg4);
13872 wxPyEndAllowThreads(__tstate);
13873 if (PyErr_Occurred()) SWIG_fail;
13874 }
13875 resultobj = SWIG_From_int(static_cast< int >(result));
13876 {
13877 PyObject* o;
13878 o = PyInt_FromLong((long) (*arg3));
13879
13880
13881
13882 resultobj = SWIG_Python_AppendOutput(resultobj, o);
13883
13884 }
13885 return resultobj;
13886 fail:
13887 return NULL;
13888 }
13889
13890
13891 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13892 PyObject *resultobj = 0;
13893 int arg1 = (int) wxJOYSTICK1 ;
13894 wxJoystick *result = 0 ;
13895 int val1 ;
13896 int ecode1 = 0 ;
13897 PyObject * obj0 = 0 ;
13898 char * kwnames[] = {
13899 (char *) "joystick", NULL
13900 };
13901
13902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
13903 if (obj0) {
13904 ecode1 = SWIG_AsVal_int(obj0, &val1);
13905 if (!SWIG_IsOK(ecode1)) {
13906 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
13907 }
13908 arg1 = static_cast< int >(val1);
13909 }
13910 {
13911 if (!wxPyCheckForApp()) SWIG_fail;
13912 PyThreadState* __tstate = wxPyBeginAllowThreads();
13913 result = (wxJoystick *)new wxJoystick(arg1);
13914 wxPyEndAllowThreads(__tstate);
13915 if (PyErr_Occurred()) SWIG_fail;
13916 }
13917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
13918 return resultobj;
13919 fail:
13920 return NULL;
13921 }
13922
13923
13924 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13925 PyObject *resultobj = 0;
13926 wxJoystick *arg1 = (wxJoystick *) 0 ;
13927 void *argp1 = 0 ;
13928 int res1 = 0 ;
13929 PyObject *swig_obj[1] ;
13930
13931 if (!args) SWIG_fail;
13932 swig_obj[0] = args;
13933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
13934 if (!SWIG_IsOK(res1)) {
13935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
13936 }
13937 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13938 {
13939 PyThreadState* __tstate = wxPyBeginAllowThreads();
13940 delete arg1;
13941
13942 wxPyEndAllowThreads(__tstate);
13943 if (PyErr_Occurred()) SWIG_fail;
13944 }
13945 resultobj = SWIG_Py_Void();
13946 return resultobj;
13947 fail:
13948 return NULL;
13949 }
13950
13951
13952 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13953 PyObject *resultobj = 0;
13954 wxJoystick *arg1 = (wxJoystick *) 0 ;
13955 wxPoint result;
13956 void *argp1 = 0 ;
13957 int res1 = 0 ;
13958 PyObject *swig_obj[1] ;
13959
13960 if (!args) SWIG_fail;
13961 swig_obj[0] = args;
13962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
13963 if (!SWIG_IsOK(res1)) {
13964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
13965 }
13966 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13967 {
13968 PyThreadState* __tstate = wxPyBeginAllowThreads();
13969 result = (arg1)->GetPosition();
13970 wxPyEndAllowThreads(__tstate);
13971 if (PyErr_Occurred()) SWIG_fail;
13972 }
13973 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
13974 return resultobj;
13975 fail:
13976 return NULL;
13977 }
13978
13979
13980 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13981 PyObject *resultobj = 0;
13982 wxJoystick *arg1 = (wxJoystick *) 0 ;
13983 int result;
13984 void *argp1 = 0 ;
13985 int res1 = 0 ;
13986 PyObject *swig_obj[1] ;
13987
13988 if (!args) SWIG_fail;
13989 swig_obj[0] = args;
13990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
13991 if (!SWIG_IsOK(res1)) {
13992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
13993 }
13994 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13995 {
13996 PyThreadState* __tstate = wxPyBeginAllowThreads();
13997 result = (int)(arg1)->GetZPosition();
13998 wxPyEndAllowThreads(__tstate);
13999 if (PyErr_Occurred()) SWIG_fail;
14000 }
14001 resultobj = SWIG_From_int(static_cast< int >(result));
14002 return resultobj;
14003 fail:
14004 return NULL;
14005 }
14006
14007
14008 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14009 PyObject *resultobj = 0;
14010 wxJoystick *arg1 = (wxJoystick *) 0 ;
14011 int result;
14012 void *argp1 = 0 ;
14013 int res1 = 0 ;
14014 PyObject *swig_obj[1] ;
14015
14016 if (!args) SWIG_fail;
14017 swig_obj[0] = args;
14018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14019 if (!SWIG_IsOK(res1)) {
14020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
14021 }
14022 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14023 {
14024 PyThreadState* __tstate = wxPyBeginAllowThreads();
14025 result = (int)(arg1)->GetButtonState();
14026 wxPyEndAllowThreads(__tstate);
14027 if (PyErr_Occurred()) SWIG_fail;
14028 }
14029 resultobj = SWIG_From_int(static_cast< int >(result));
14030 return resultobj;
14031 fail:
14032 return NULL;
14033 }
14034
14035
14036 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14037 PyObject *resultobj = 0;
14038 wxJoystick *arg1 = (wxJoystick *) 0 ;
14039 int result;
14040 void *argp1 = 0 ;
14041 int res1 = 0 ;
14042 PyObject *swig_obj[1] ;
14043
14044 if (!args) SWIG_fail;
14045 swig_obj[0] = args;
14046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14047 if (!SWIG_IsOK(res1)) {
14048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14049 }
14050 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14051 {
14052 PyThreadState* __tstate = wxPyBeginAllowThreads();
14053 result = (int)(arg1)->GetPOVPosition();
14054 wxPyEndAllowThreads(__tstate);
14055 if (PyErr_Occurred()) SWIG_fail;
14056 }
14057 resultobj = SWIG_From_int(static_cast< int >(result));
14058 return resultobj;
14059 fail:
14060 return NULL;
14061 }
14062
14063
14064 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14065 PyObject *resultobj = 0;
14066 wxJoystick *arg1 = (wxJoystick *) 0 ;
14067 int result;
14068 void *argp1 = 0 ;
14069 int res1 = 0 ;
14070 PyObject *swig_obj[1] ;
14071
14072 if (!args) SWIG_fail;
14073 swig_obj[0] = args;
14074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14075 if (!SWIG_IsOK(res1)) {
14076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14077 }
14078 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14079 {
14080 PyThreadState* __tstate = wxPyBeginAllowThreads();
14081 result = (int)(arg1)->GetPOVCTSPosition();
14082 wxPyEndAllowThreads(__tstate);
14083 if (PyErr_Occurred()) SWIG_fail;
14084 }
14085 resultobj = SWIG_From_int(static_cast< int >(result));
14086 return resultobj;
14087 fail:
14088 return NULL;
14089 }
14090
14091
14092 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14093 PyObject *resultobj = 0;
14094 wxJoystick *arg1 = (wxJoystick *) 0 ;
14095 int result;
14096 void *argp1 = 0 ;
14097 int res1 = 0 ;
14098 PyObject *swig_obj[1] ;
14099
14100 if (!args) SWIG_fail;
14101 swig_obj[0] = args;
14102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14103 if (!SWIG_IsOK(res1)) {
14104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14105 }
14106 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14107 {
14108 PyThreadState* __tstate = wxPyBeginAllowThreads();
14109 result = (int)(arg1)->GetRudderPosition();
14110 wxPyEndAllowThreads(__tstate);
14111 if (PyErr_Occurred()) SWIG_fail;
14112 }
14113 resultobj = SWIG_From_int(static_cast< int >(result));
14114 return resultobj;
14115 fail:
14116 return NULL;
14117 }
14118
14119
14120 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14121 PyObject *resultobj = 0;
14122 wxJoystick *arg1 = (wxJoystick *) 0 ;
14123 int result;
14124 void *argp1 = 0 ;
14125 int res1 = 0 ;
14126 PyObject *swig_obj[1] ;
14127
14128 if (!args) SWIG_fail;
14129 swig_obj[0] = args;
14130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14131 if (!SWIG_IsOK(res1)) {
14132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14133 }
14134 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14135 {
14136 PyThreadState* __tstate = wxPyBeginAllowThreads();
14137 result = (int)(arg1)->GetUPosition();
14138 wxPyEndAllowThreads(__tstate);
14139 if (PyErr_Occurred()) SWIG_fail;
14140 }
14141 resultobj = SWIG_From_int(static_cast< int >(result));
14142 return resultobj;
14143 fail:
14144 return NULL;
14145 }
14146
14147
14148 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14149 PyObject *resultobj = 0;
14150 wxJoystick *arg1 = (wxJoystick *) 0 ;
14151 int result;
14152 void *argp1 = 0 ;
14153 int res1 = 0 ;
14154 PyObject *swig_obj[1] ;
14155
14156 if (!args) SWIG_fail;
14157 swig_obj[0] = args;
14158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14159 if (!SWIG_IsOK(res1)) {
14160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14161 }
14162 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14163 {
14164 PyThreadState* __tstate = wxPyBeginAllowThreads();
14165 result = (int)(arg1)->GetVPosition();
14166 wxPyEndAllowThreads(__tstate);
14167 if (PyErr_Occurred()) SWIG_fail;
14168 }
14169 resultobj = SWIG_From_int(static_cast< int >(result));
14170 return resultobj;
14171 fail:
14172 return NULL;
14173 }
14174
14175
14176 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14177 PyObject *resultobj = 0;
14178 wxJoystick *arg1 = (wxJoystick *) 0 ;
14179 int result;
14180 void *argp1 = 0 ;
14181 int res1 = 0 ;
14182 PyObject *swig_obj[1] ;
14183
14184 if (!args) SWIG_fail;
14185 swig_obj[0] = args;
14186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14187 if (!SWIG_IsOK(res1)) {
14188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14189 }
14190 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14191 {
14192 PyThreadState* __tstate = wxPyBeginAllowThreads();
14193 result = (int)(arg1)->GetMovementThreshold();
14194 wxPyEndAllowThreads(__tstate);
14195 if (PyErr_Occurred()) SWIG_fail;
14196 }
14197 resultobj = SWIG_From_int(static_cast< int >(result));
14198 return resultobj;
14199 fail:
14200 return NULL;
14201 }
14202
14203
14204 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14205 PyObject *resultobj = 0;
14206 wxJoystick *arg1 = (wxJoystick *) 0 ;
14207 int arg2 ;
14208 void *argp1 = 0 ;
14209 int res1 = 0 ;
14210 int val2 ;
14211 int ecode2 = 0 ;
14212 PyObject * obj0 = 0 ;
14213 PyObject * obj1 = 0 ;
14214 char * kwnames[] = {
14215 (char *) "self",(char *) "threshold", NULL
14216 };
14217
14218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
14219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14220 if (!SWIG_IsOK(res1)) {
14221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14222 }
14223 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14224 ecode2 = SWIG_AsVal_int(obj1, &val2);
14225 if (!SWIG_IsOK(ecode2)) {
14226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
14227 }
14228 arg2 = static_cast< int >(val2);
14229 {
14230 PyThreadState* __tstate = wxPyBeginAllowThreads();
14231 (arg1)->SetMovementThreshold(arg2);
14232 wxPyEndAllowThreads(__tstate);
14233 if (PyErr_Occurred()) SWIG_fail;
14234 }
14235 resultobj = SWIG_Py_Void();
14236 return resultobj;
14237 fail:
14238 return NULL;
14239 }
14240
14241
14242 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14243 PyObject *resultobj = 0;
14244 wxJoystick *arg1 = (wxJoystick *) 0 ;
14245 bool result;
14246 void *argp1 = 0 ;
14247 int res1 = 0 ;
14248 PyObject *swig_obj[1] ;
14249
14250 if (!args) SWIG_fail;
14251 swig_obj[0] = args;
14252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14253 if (!SWIG_IsOK(res1)) {
14254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
14255 }
14256 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14257 {
14258 PyThreadState* __tstate = wxPyBeginAllowThreads();
14259 result = (bool)(arg1)->IsOk();
14260 wxPyEndAllowThreads(__tstate);
14261 if (PyErr_Occurred()) SWIG_fail;
14262 }
14263 {
14264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14265 }
14266 return resultobj;
14267 fail:
14268 return NULL;
14269 }
14270
14271
14272 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14273 PyObject *resultobj = 0;
14274 wxJoystick *arg1 = (wxJoystick *) 0 ;
14275 int result;
14276 void *argp1 = 0 ;
14277 int res1 = 0 ;
14278 PyObject *swig_obj[1] ;
14279
14280 if (!args) SWIG_fail;
14281 swig_obj[0] = args;
14282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14283 if (!SWIG_IsOK(res1)) {
14284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
14285 }
14286 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14287 {
14288 PyThreadState* __tstate = wxPyBeginAllowThreads();
14289 result = (int)(arg1)->GetNumberJoysticks();
14290 wxPyEndAllowThreads(__tstate);
14291 if (PyErr_Occurred()) SWIG_fail;
14292 }
14293 resultobj = SWIG_From_int(static_cast< int >(result));
14294 return resultobj;
14295 fail:
14296 return NULL;
14297 }
14298
14299
14300 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14301 PyObject *resultobj = 0;
14302 wxJoystick *arg1 = (wxJoystick *) 0 ;
14303 int result;
14304 void *argp1 = 0 ;
14305 int res1 = 0 ;
14306 PyObject *swig_obj[1] ;
14307
14308 if (!args) SWIG_fail;
14309 swig_obj[0] = args;
14310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14311 if (!SWIG_IsOK(res1)) {
14312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14313 }
14314 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14315 {
14316 PyThreadState* __tstate = wxPyBeginAllowThreads();
14317 result = (int)(arg1)->GetManufacturerId();
14318 wxPyEndAllowThreads(__tstate);
14319 if (PyErr_Occurred()) SWIG_fail;
14320 }
14321 resultobj = SWIG_From_int(static_cast< int >(result));
14322 return resultobj;
14323 fail:
14324 return NULL;
14325 }
14326
14327
14328 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14329 PyObject *resultobj = 0;
14330 wxJoystick *arg1 = (wxJoystick *) 0 ;
14331 int result;
14332 void *argp1 = 0 ;
14333 int res1 = 0 ;
14334 PyObject *swig_obj[1] ;
14335
14336 if (!args) SWIG_fail;
14337 swig_obj[0] = args;
14338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14339 if (!SWIG_IsOK(res1)) {
14340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14341 }
14342 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14343 {
14344 PyThreadState* __tstate = wxPyBeginAllowThreads();
14345 result = (int)(arg1)->GetProductId();
14346 wxPyEndAllowThreads(__tstate);
14347 if (PyErr_Occurred()) SWIG_fail;
14348 }
14349 resultobj = SWIG_From_int(static_cast< int >(result));
14350 return resultobj;
14351 fail:
14352 return NULL;
14353 }
14354
14355
14356 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14357 PyObject *resultobj = 0;
14358 wxJoystick *arg1 = (wxJoystick *) 0 ;
14359 wxString result;
14360 void *argp1 = 0 ;
14361 int res1 = 0 ;
14362 PyObject *swig_obj[1] ;
14363
14364 if (!args) SWIG_fail;
14365 swig_obj[0] = args;
14366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14367 if (!SWIG_IsOK(res1)) {
14368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
14369 }
14370 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14371 {
14372 PyThreadState* __tstate = wxPyBeginAllowThreads();
14373 result = (arg1)->GetProductName();
14374 wxPyEndAllowThreads(__tstate);
14375 if (PyErr_Occurred()) SWIG_fail;
14376 }
14377 {
14378 #if wxUSE_UNICODE
14379 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14380 #else
14381 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14382 #endif
14383 }
14384 return resultobj;
14385 fail:
14386 return NULL;
14387 }
14388
14389
14390 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14391 PyObject *resultobj = 0;
14392 wxJoystick *arg1 = (wxJoystick *) 0 ;
14393 int result;
14394 void *argp1 = 0 ;
14395 int res1 = 0 ;
14396 PyObject *swig_obj[1] ;
14397
14398 if (!args) SWIG_fail;
14399 swig_obj[0] = args;
14400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14401 if (!SWIG_IsOK(res1)) {
14402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14403 }
14404 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14405 {
14406 PyThreadState* __tstate = wxPyBeginAllowThreads();
14407 result = (int)(arg1)->GetXMin();
14408 wxPyEndAllowThreads(__tstate);
14409 if (PyErr_Occurred()) SWIG_fail;
14410 }
14411 resultobj = SWIG_From_int(static_cast< int >(result));
14412 return resultobj;
14413 fail:
14414 return NULL;
14415 }
14416
14417
14418 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14419 PyObject *resultobj = 0;
14420 wxJoystick *arg1 = (wxJoystick *) 0 ;
14421 int result;
14422 void *argp1 = 0 ;
14423 int res1 = 0 ;
14424 PyObject *swig_obj[1] ;
14425
14426 if (!args) SWIG_fail;
14427 swig_obj[0] = args;
14428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14429 if (!SWIG_IsOK(res1)) {
14430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14431 }
14432 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14433 {
14434 PyThreadState* __tstate = wxPyBeginAllowThreads();
14435 result = (int)(arg1)->GetYMin();
14436 wxPyEndAllowThreads(__tstate);
14437 if (PyErr_Occurred()) SWIG_fail;
14438 }
14439 resultobj = SWIG_From_int(static_cast< int >(result));
14440 return resultobj;
14441 fail:
14442 return NULL;
14443 }
14444
14445
14446 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14447 PyObject *resultobj = 0;
14448 wxJoystick *arg1 = (wxJoystick *) 0 ;
14449 int result;
14450 void *argp1 = 0 ;
14451 int res1 = 0 ;
14452 PyObject *swig_obj[1] ;
14453
14454 if (!args) SWIG_fail;
14455 swig_obj[0] = args;
14456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14457 if (!SWIG_IsOK(res1)) {
14458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14459 }
14460 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14461 {
14462 PyThreadState* __tstate = wxPyBeginAllowThreads();
14463 result = (int)(arg1)->GetZMin();
14464 wxPyEndAllowThreads(__tstate);
14465 if (PyErr_Occurred()) SWIG_fail;
14466 }
14467 resultobj = SWIG_From_int(static_cast< int >(result));
14468 return resultobj;
14469 fail:
14470 return NULL;
14471 }
14472
14473
14474 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14475 PyObject *resultobj = 0;
14476 wxJoystick *arg1 = (wxJoystick *) 0 ;
14477 int result;
14478 void *argp1 = 0 ;
14479 int res1 = 0 ;
14480 PyObject *swig_obj[1] ;
14481
14482 if (!args) SWIG_fail;
14483 swig_obj[0] = args;
14484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14485 if (!SWIG_IsOK(res1)) {
14486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14487 }
14488 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14489 {
14490 PyThreadState* __tstate = wxPyBeginAllowThreads();
14491 result = (int)(arg1)->GetXMax();
14492 wxPyEndAllowThreads(__tstate);
14493 if (PyErr_Occurred()) SWIG_fail;
14494 }
14495 resultobj = SWIG_From_int(static_cast< int >(result));
14496 return resultobj;
14497 fail:
14498 return NULL;
14499 }
14500
14501
14502 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14503 PyObject *resultobj = 0;
14504 wxJoystick *arg1 = (wxJoystick *) 0 ;
14505 int result;
14506 void *argp1 = 0 ;
14507 int res1 = 0 ;
14508 PyObject *swig_obj[1] ;
14509
14510 if (!args) SWIG_fail;
14511 swig_obj[0] = args;
14512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14513 if (!SWIG_IsOK(res1)) {
14514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14515 }
14516 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14517 {
14518 PyThreadState* __tstate = wxPyBeginAllowThreads();
14519 result = (int)(arg1)->GetYMax();
14520 wxPyEndAllowThreads(__tstate);
14521 if (PyErr_Occurred()) SWIG_fail;
14522 }
14523 resultobj = SWIG_From_int(static_cast< int >(result));
14524 return resultobj;
14525 fail:
14526 return NULL;
14527 }
14528
14529
14530 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14531 PyObject *resultobj = 0;
14532 wxJoystick *arg1 = (wxJoystick *) 0 ;
14533 int result;
14534 void *argp1 = 0 ;
14535 int res1 = 0 ;
14536 PyObject *swig_obj[1] ;
14537
14538 if (!args) SWIG_fail;
14539 swig_obj[0] = args;
14540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14541 if (!SWIG_IsOK(res1)) {
14542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14543 }
14544 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14545 {
14546 PyThreadState* __tstate = wxPyBeginAllowThreads();
14547 result = (int)(arg1)->GetZMax();
14548 wxPyEndAllowThreads(__tstate);
14549 if (PyErr_Occurred()) SWIG_fail;
14550 }
14551 resultobj = SWIG_From_int(static_cast< int >(result));
14552 return resultobj;
14553 fail:
14554 return NULL;
14555 }
14556
14557
14558 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14559 PyObject *resultobj = 0;
14560 wxJoystick *arg1 = (wxJoystick *) 0 ;
14561 int result;
14562 void *argp1 = 0 ;
14563 int res1 = 0 ;
14564 PyObject *swig_obj[1] ;
14565
14566 if (!args) SWIG_fail;
14567 swig_obj[0] = args;
14568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14569 if (!SWIG_IsOK(res1)) {
14570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14571 }
14572 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14573 {
14574 PyThreadState* __tstate = wxPyBeginAllowThreads();
14575 result = (int)(arg1)->GetNumberButtons();
14576 wxPyEndAllowThreads(__tstate);
14577 if (PyErr_Occurred()) SWIG_fail;
14578 }
14579 resultobj = SWIG_From_int(static_cast< int >(result));
14580 return resultobj;
14581 fail:
14582 return NULL;
14583 }
14584
14585
14586 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14587 PyObject *resultobj = 0;
14588 wxJoystick *arg1 = (wxJoystick *) 0 ;
14589 int result;
14590 void *argp1 = 0 ;
14591 int res1 = 0 ;
14592 PyObject *swig_obj[1] ;
14593
14594 if (!args) SWIG_fail;
14595 swig_obj[0] = args;
14596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14597 if (!SWIG_IsOK(res1)) {
14598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14599 }
14600 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14601 {
14602 PyThreadState* __tstate = wxPyBeginAllowThreads();
14603 result = (int)(arg1)->GetNumberAxes();
14604 wxPyEndAllowThreads(__tstate);
14605 if (PyErr_Occurred()) SWIG_fail;
14606 }
14607 resultobj = SWIG_From_int(static_cast< int >(result));
14608 return resultobj;
14609 fail:
14610 return NULL;
14611 }
14612
14613
14614 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14615 PyObject *resultobj = 0;
14616 wxJoystick *arg1 = (wxJoystick *) 0 ;
14617 int result;
14618 void *argp1 = 0 ;
14619 int res1 = 0 ;
14620 PyObject *swig_obj[1] ;
14621
14622 if (!args) SWIG_fail;
14623 swig_obj[0] = args;
14624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14625 if (!SWIG_IsOK(res1)) {
14626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14627 }
14628 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14629 {
14630 PyThreadState* __tstate = wxPyBeginAllowThreads();
14631 result = (int)(arg1)->GetMaxButtons();
14632 wxPyEndAllowThreads(__tstate);
14633 if (PyErr_Occurred()) SWIG_fail;
14634 }
14635 resultobj = SWIG_From_int(static_cast< int >(result));
14636 return resultobj;
14637 fail:
14638 return NULL;
14639 }
14640
14641
14642 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14643 PyObject *resultobj = 0;
14644 wxJoystick *arg1 = (wxJoystick *) 0 ;
14645 int result;
14646 void *argp1 = 0 ;
14647 int res1 = 0 ;
14648 PyObject *swig_obj[1] ;
14649
14650 if (!args) SWIG_fail;
14651 swig_obj[0] = args;
14652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14653 if (!SWIG_IsOK(res1)) {
14654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14655 }
14656 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14657 {
14658 PyThreadState* __tstate = wxPyBeginAllowThreads();
14659 result = (int)(arg1)->GetMaxAxes();
14660 wxPyEndAllowThreads(__tstate);
14661 if (PyErr_Occurred()) SWIG_fail;
14662 }
14663 resultobj = SWIG_From_int(static_cast< int >(result));
14664 return resultobj;
14665 fail:
14666 return NULL;
14667 }
14668
14669
14670 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14671 PyObject *resultobj = 0;
14672 wxJoystick *arg1 = (wxJoystick *) 0 ;
14673 int result;
14674 void *argp1 = 0 ;
14675 int res1 = 0 ;
14676 PyObject *swig_obj[1] ;
14677
14678 if (!args) SWIG_fail;
14679 swig_obj[0] = args;
14680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14681 if (!SWIG_IsOK(res1)) {
14682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14683 }
14684 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14685 {
14686 PyThreadState* __tstate = wxPyBeginAllowThreads();
14687 result = (int)(arg1)->GetPollingMin();
14688 wxPyEndAllowThreads(__tstate);
14689 if (PyErr_Occurred()) SWIG_fail;
14690 }
14691 resultobj = SWIG_From_int(static_cast< int >(result));
14692 return resultobj;
14693 fail:
14694 return NULL;
14695 }
14696
14697
14698 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14699 PyObject *resultobj = 0;
14700 wxJoystick *arg1 = (wxJoystick *) 0 ;
14701 int result;
14702 void *argp1 = 0 ;
14703 int res1 = 0 ;
14704 PyObject *swig_obj[1] ;
14705
14706 if (!args) SWIG_fail;
14707 swig_obj[0] = args;
14708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14709 if (!SWIG_IsOK(res1)) {
14710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14711 }
14712 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14713 {
14714 PyThreadState* __tstate = wxPyBeginAllowThreads();
14715 result = (int)(arg1)->GetPollingMax();
14716 wxPyEndAllowThreads(__tstate);
14717 if (PyErr_Occurred()) SWIG_fail;
14718 }
14719 resultobj = SWIG_From_int(static_cast< int >(result));
14720 return resultobj;
14721 fail:
14722 return NULL;
14723 }
14724
14725
14726 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14727 PyObject *resultobj = 0;
14728 wxJoystick *arg1 = (wxJoystick *) 0 ;
14729 int result;
14730 void *argp1 = 0 ;
14731 int res1 = 0 ;
14732 PyObject *swig_obj[1] ;
14733
14734 if (!args) SWIG_fail;
14735 swig_obj[0] = args;
14736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14737 if (!SWIG_IsOK(res1)) {
14738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14739 }
14740 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14741 {
14742 PyThreadState* __tstate = wxPyBeginAllowThreads();
14743 result = (int)(arg1)->GetRudderMin();
14744 wxPyEndAllowThreads(__tstate);
14745 if (PyErr_Occurred()) SWIG_fail;
14746 }
14747 resultobj = SWIG_From_int(static_cast< int >(result));
14748 return resultobj;
14749 fail:
14750 return NULL;
14751 }
14752
14753
14754 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14755 PyObject *resultobj = 0;
14756 wxJoystick *arg1 = (wxJoystick *) 0 ;
14757 int result;
14758 void *argp1 = 0 ;
14759 int res1 = 0 ;
14760 PyObject *swig_obj[1] ;
14761
14762 if (!args) SWIG_fail;
14763 swig_obj[0] = args;
14764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14765 if (!SWIG_IsOK(res1)) {
14766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14767 }
14768 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14769 {
14770 PyThreadState* __tstate = wxPyBeginAllowThreads();
14771 result = (int)(arg1)->GetRudderMax();
14772 wxPyEndAllowThreads(__tstate);
14773 if (PyErr_Occurred()) SWIG_fail;
14774 }
14775 resultobj = SWIG_From_int(static_cast< int >(result));
14776 return resultobj;
14777 fail:
14778 return NULL;
14779 }
14780
14781
14782 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14783 PyObject *resultobj = 0;
14784 wxJoystick *arg1 = (wxJoystick *) 0 ;
14785 int result;
14786 void *argp1 = 0 ;
14787 int res1 = 0 ;
14788 PyObject *swig_obj[1] ;
14789
14790 if (!args) SWIG_fail;
14791 swig_obj[0] = args;
14792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14793 if (!SWIG_IsOK(res1)) {
14794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14795 }
14796 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14797 {
14798 PyThreadState* __tstate = wxPyBeginAllowThreads();
14799 result = (int)(arg1)->GetUMin();
14800 wxPyEndAllowThreads(__tstate);
14801 if (PyErr_Occurred()) SWIG_fail;
14802 }
14803 resultobj = SWIG_From_int(static_cast< int >(result));
14804 return resultobj;
14805 fail:
14806 return NULL;
14807 }
14808
14809
14810 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14811 PyObject *resultobj = 0;
14812 wxJoystick *arg1 = (wxJoystick *) 0 ;
14813 int result;
14814 void *argp1 = 0 ;
14815 int res1 = 0 ;
14816 PyObject *swig_obj[1] ;
14817
14818 if (!args) SWIG_fail;
14819 swig_obj[0] = args;
14820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14821 if (!SWIG_IsOK(res1)) {
14822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14823 }
14824 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14825 {
14826 PyThreadState* __tstate = wxPyBeginAllowThreads();
14827 result = (int)(arg1)->GetUMax();
14828 wxPyEndAllowThreads(__tstate);
14829 if (PyErr_Occurred()) SWIG_fail;
14830 }
14831 resultobj = SWIG_From_int(static_cast< int >(result));
14832 return resultobj;
14833 fail:
14834 return NULL;
14835 }
14836
14837
14838 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14839 PyObject *resultobj = 0;
14840 wxJoystick *arg1 = (wxJoystick *) 0 ;
14841 int result;
14842 void *argp1 = 0 ;
14843 int res1 = 0 ;
14844 PyObject *swig_obj[1] ;
14845
14846 if (!args) SWIG_fail;
14847 swig_obj[0] = args;
14848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14849 if (!SWIG_IsOK(res1)) {
14850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14851 }
14852 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14853 {
14854 PyThreadState* __tstate = wxPyBeginAllowThreads();
14855 result = (int)(arg1)->GetVMin();
14856 wxPyEndAllowThreads(__tstate);
14857 if (PyErr_Occurred()) SWIG_fail;
14858 }
14859 resultobj = SWIG_From_int(static_cast< int >(result));
14860 return resultobj;
14861 fail:
14862 return NULL;
14863 }
14864
14865
14866 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14867 PyObject *resultobj = 0;
14868 wxJoystick *arg1 = (wxJoystick *) 0 ;
14869 int result;
14870 void *argp1 = 0 ;
14871 int res1 = 0 ;
14872 PyObject *swig_obj[1] ;
14873
14874 if (!args) SWIG_fail;
14875 swig_obj[0] = args;
14876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14877 if (!SWIG_IsOK(res1)) {
14878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14879 }
14880 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14881 {
14882 PyThreadState* __tstate = wxPyBeginAllowThreads();
14883 result = (int)(arg1)->GetVMax();
14884 wxPyEndAllowThreads(__tstate);
14885 if (PyErr_Occurred()) SWIG_fail;
14886 }
14887 resultobj = SWIG_From_int(static_cast< int >(result));
14888 return resultobj;
14889 fail:
14890 return NULL;
14891 }
14892
14893
14894 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14895 PyObject *resultobj = 0;
14896 wxJoystick *arg1 = (wxJoystick *) 0 ;
14897 bool result;
14898 void *argp1 = 0 ;
14899 int res1 = 0 ;
14900 PyObject *swig_obj[1] ;
14901
14902 if (!args) SWIG_fail;
14903 swig_obj[0] = args;
14904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14905 if (!SWIG_IsOK(res1)) {
14906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
14907 }
14908 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14909 {
14910 PyThreadState* __tstate = wxPyBeginAllowThreads();
14911 result = (bool)(arg1)->HasRudder();
14912 wxPyEndAllowThreads(__tstate);
14913 if (PyErr_Occurred()) SWIG_fail;
14914 }
14915 {
14916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14917 }
14918 return resultobj;
14919 fail:
14920 return NULL;
14921 }
14922
14923
14924 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14925 PyObject *resultobj = 0;
14926 wxJoystick *arg1 = (wxJoystick *) 0 ;
14927 bool result;
14928 void *argp1 = 0 ;
14929 int res1 = 0 ;
14930 PyObject *swig_obj[1] ;
14931
14932 if (!args) SWIG_fail;
14933 swig_obj[0] = args;
14934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14935 if (!SWIG_IsOK(res1)) {
14936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
14937 }
14938 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14939 {
14940 PyThreadState* __tstate = wxPyBeginAllowThreads();
14941 result = (bool)(arg1)->HasZ();
14942 wxPyEndAllowThreads(__tstate);
14943 if (PyErr_Occurred()) SWIG_fail;
14944 }
14945 {
14946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14947 }
14948 return resultobj;
14949 fail:
14950 return NULL;
14951 }
14952
14953
14954 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14955 PyObject *resultobj = 0;
14956 wxJoystick *arg1 = (wxJoystick *) 0 ;
14957 bool result;
14958 void *argp1 = 0 ;
14959 int res1 = 0 ;
14960 PyObject *swig_obj[1] ;
14961
14962 if (!args) SWIG_fail;
14963 swig_obj[0] = args;
14964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14965 if (!SWIG_IsOK(res1)) {
14966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
14967 }
14968 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14969 {
14970 PyThreadState* __tstate = wxPyBeginAllowThreads();
14971 result = (bool)(arg1)->HasU();
14972 wxPyEndAllowThreads(__tstate);
14973 if (PyErr_Occurred()) SWIG_fail;
14974 }
14975 {
14976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14977 }
14978 return resultobj;
14979 fail:
14980 return NULL;
14981 }
14982
14983
14984 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14985 PyObject *resultobj = 0;
14986 wxJoystick *arg1 = (wxJoystick *) 0 ;
14987 bool result;
14988 void *argp1 = 0 ;
14989 int res1 = 0 ;
14990 PyObject *swig_obj[1] ;
14991
14992 if (!args) SWIG_fail;
14993 swig_obj[0] = args;
14994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14995 if (!SWIG_IsOK(res1)) {
14996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
14997 }
14998 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14999 {
15000 PyThreadState* __tstate = wxPyBeginAllowThreads();
15001 result = (bool)(arg1)->HasV();
15002 wxPyEndAllowThreads(__tstate);
15003 if (PyErr_Occurred()) SWIG_fail;
15004 }
15005 {
15006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15007 }
15008 return resultobj;
15009 fail:
15010 return NULL;
15011 }
15012
15013
15014 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15015 PyObject *resultobj = 0;
15016 wxJoystick *arg1 = (wxJoystick *) 0 ;
15017 bool result;
15018 void *argp1 = 0 ;
15019 int res1 = 0 ;
15020 PyObject *swig_obj[1] ;
15021
15022 if (!args) SWIG_fail;
15023 swig_obj[0] = args;
15024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15025 if (!SWIG_IsOK(res1)) {
15026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15027 }
15028 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15029 {
15030 PyThreadState* __tstate = wxPyBeginAllowThreads();
15031 result = (bool)(arg1)->HasPOV();
15032 wxPyEndAllowThreads(__tstate);
15033 if (PyErr_Occurred()) SWIG_fail;
15034 }
15035 {
15036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15037 }
15038 return resultobj;
15039 fail:
15040 return NULL;
15041 }
15042
15043
15044 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15045 PyObject *resultobj = 0;
15046 wxJoystick *arg1 = (wxJoystick *) 0 ;
15047 bool result;
15048 void *argp1 = 0 ;
15049 int res1 = 0 ;
15050 PyObject *swig_obj[1] ;
15051
15052 if (!args) SWIG_fail;
15053 swig_obj[0] = args;
15054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15055 if (!SWIG_IsOK(res1)) {
15056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
15057 }
15058 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15059 {
15060 PyThreadState* __tstate = wxPyBeginAllowThreads();
15061 result = (bool)(arg1)->HasPOV4Dir();
15062 wxPyEndAllowThreads(__tstate);
15063 if (PyErr_Occurred()) SWIG_fail;
15064 }
15065 {
15066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15067 }
15068 return resultobj;
15069 fail:
15070 return NULL;
15071 }
15072
15073
15074 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15075 PyObject *resultobj = 0;
15076 wxJoystick *arg1 = (wxJoystick *) 0 ;
15077 bool result;
15078 void *argp1 = 0 ;
15079 int res1 = 0 ;
15080 PyObject *swig_obj[1] ;
15081
15082 if (!args) SWIG_fail;
15083 swig_obj[0] = args;
15084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15085 if (!SWIG_IsOK(res1)) {
15086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
15087 }
15088 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15089 {
15090 PyThreadState* __tstate = wxPyBeginAllowThreads();
15091 result = (bool)(arg1)->HasPOVCTS();
15092 wxPyEndAllowThreads(__tstate);
15093 if (PyErr_Occurred()) SWIG_fail;
15094 }
15095 {
15096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15097 }
15098 return resultobj;
15099 fail:
15100 return NULL;
15101 }
15102
15103
15104 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15105 PyObject *resultobj = 0;
15106 wxJoystick *arg1 = (wxJoystick *) 0 ;
15107 wxWindow *arg2 = (wxWindow *) 0 ;
15108 int arg3 = (int) 0 ;
15109 bool result;
15110 void *argp1 = 0 ;
15111 int res1 = 0 ;
15112 void *argp2 = 0 ;
15113 int res2 = 0 ;
15114 int val3 ;
15115 int ecode3 = 0 ;
15116 PyObject * obj0 = 0 ;
15117 PyObject * obj1 = 0 ;
15118 PyObject * obj2 = 0 ;
15119 char * kwnames[] = {
15120 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
15121 };
15122
15123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15125 if (!SWIG_IsOK(res1)) {
15126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15127 }
15128 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15129 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
15130 if (!SWIG_IsOK(res2)) {
15131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
15132 }
15133 arg2 = reinterpret_cast< wxWindow * >(argp2);
15134 if (obj2) {
15135 ecode3 = SWIG_AsVal_int(obj2, &val3);
15136 if (!SWIG_IsOK(ecode3)) {
15137 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
15138 }
15139 arg3 = static_cast< int >(val3);
15140 }
15141 {
15142 PyThreadState* __tstate = wxPyBeginAllowThreads();
15143 result = (bool)(arg1)->SetCapture(arg2,arg3);
15144 wxPyEndAllowThreads(__tstate);
15145 if (PyErr_Occurred()) SWIG_fail;
15146 }
15147 {
15148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15149 }
15150 return resultobj;
15151 fail:
15152 return NULL;
15153 }
15154
15155
15156 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15157 PyObject *resultobj = 0;
15158 wxJoystick *arg1 = (wxJoystick *) 0 ;
15159 bool result;
15160 void *argp1 = 0 ;
15161 int res1 = 0 ;
15162 PyObject *swig_obj[1] ;
15163
15164 if (!args) SWIG_fail;
15165 swig_obj[0] = args;
15166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15167 if (!SWIG_IsOK(res1)) {
15168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15169 }
15170 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15171 {
15172 PyThreadState* __tstate = wxPyBeginAllowThreads();
15173 result = (bool)(arg1)->ReleaseCapture();
15174 wxPyEndAllowThreads(__tstate);
15175 if (PyErr_Occurred()) SWIG_fail;
15176 }
15177 {
15178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15179 }
15180 return resultobj;
15181 fail:
15182 return NULL;
15183 }
15184
15185
15186 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15187 PyObject *obj;
15188 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15189 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
15190 return SWIG_Py_Void();
15191 }
15192
15193 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15194 return SWIG_Python_InitShadowInstance(args);
15195 }
15196
15197 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15198 PyObject *resultobj = 0;
15199 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15200 int arg2 = (int) 0 ;
15201 int arg3 = (int) wxJOYSTICK1 ;
15202 int arg4 = (int) 0 ;
15203 wxJoystickEvent *result = 0 ;
15204 int val1 ;
15205 int ecode1 = 0 ;
15206 int val2 ;
15207 int ecode2 = 0 ;
15208 int val3 ;
15209 int ecode3 = 0 ;
15210 int val4 ;
15211 int ecode4 = 0 ;
15212 PyObject * obj0 = 0 ;
15213 PyObject * obj1 = 0 ;
15214 PyObject * obj2 = 0 ;
15215 PyObject * obj3 = 0 ;
15216 char * kwnames[] = {
15217 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
15218 };
15219
15220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15221 if (obj0) {
15222 ecode1 = SWIG_AsVal_int(obj0, &val1);
15223 if (!SWIG_IsOK(ecode1)) {
15224 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
15225 }
15226 arg1 = static_cast< wxEventType >(val1);
15227 }
15228 if (obj1) {
15229 ecode2 = SWIG_AsVal_int(obj1, &val2);
15230 if (!SWIG_IsOK(ecode2)) {
15231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
15232 }
15233 arg2 = static_cast< int >(val2);
15234 }
15235 if (obj2) {
15236 ecode3 = SWIG_AsVal_int(obj2, &val3);
15237 if (!SWIG_IsOK(ecode3)) {
15238 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
15239 }
15240 arg3 = static_cast< int >(val3);
15241 }
15242 if (obj3) {
15243 ecode4 = SWIG_AsVal_int(obj3, &val4);
15244 if (!SWIG_IsOK(ecode4)) {
15245 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
15246 }
15247 arg4 = static_cast< int >(val4);
15248 }
15249 {
15250 PyThreadState* __tstate = wxPyBeginAllowThreads();
15251 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
15252 wxPyEndAllowThreads(__tstate);
15253 if (PyErr_Occurred()) SWIG_fail;
15254 }
15255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
15256 return resultobj;
15257 fail:
15258 return NULL;
15259 }
15260
15261
15262 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15263 PyObject *resultobj = 0;
15264 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15265 wxPoint result;
15266 void *argp1 = 0 ;
15267 int res1 = 0 ;
15268 PyObject *swig_obj[1] ;
15269
15270 if (!args) SWIG_fail;
15271 swig_obj[0] = args;
15272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15273 if (!SWIG_IsOK(res1)) {
15274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15275 }
15276 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15277 {
15278 PyThreadState* __tstate = wxPyBeginAllowThreads();
15279 result = ((wxJoystickEvent const *)arg1)->GetPosition();
15280 wxPyEndAllowThreads(__tstate);
15281 if (PyErr_Occurred()) SWIG_fail;
15282 }
15283 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15284 return resultobj;
15285 fail:
15286 return NULL;
15287 }
15288
15289
15290 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15291 PyObject *resultobj = 0;
15292 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15293 int result;
15294 void *argp1 = 0 ;
15295 int res1 = 0 ;
15296 PyObject *swig_obj[1] ;
15297
15298 if (!args) SWIG_fail;
15299 swig_obj[0] = args;
15300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15301 if (!SWIG_IsOK(res1)) {
15302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15303 }
15304 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15305 {
15306 PyThreadState* __tstate = wxPyBeginAllowThreads();
15307 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
15308 wxPyEndAllowThreads(__tstate);
15309 if (PyErr_Occurred()) SWIG_fail;
15310 }
15311 resultobj = SWIG_From_int(static_cast< int >(result));
15312 return resultobj;
15313 fail:
15314 return NULL;
15315 }
15316
15317
15318 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15319 PyObject *resultobj = 0;
15320 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15321 int result;
15322 void *argp1 = 0 ;
15323 int res1 = 0 ;
15324 PyObject *swig_obj[1] ;
15325
15326 if (!args) SWIG_fail;
15327 swig_obj[0] = args;
15328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15329 if (!SWIG_IsOK(res1)) {
15330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15331 }
15332 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15333 {
15334 PyThreadState* __tstate = wxPyBeginAllowThreads();
15335 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
15336 wxPyEndAllowThreads(__tstate);
15337 if (PyErr_Occurred()) SWIG_fail;
15338 }
15339 resultobj = SWIG_From_int(static_cast< int >(result));
15340 return resultobj;
15341 fail:
15342 return NULL;
15343 }
15344
15345
15346 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15347 PyObject *resultobj = 0;
15348 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15349 int result;
15350 void *argp1 = 0 ;
15351 int res1 = 0 ;
15352 PyObject *swig_obj[1] ;
15353
15354 if (!args) SWIG_fail;
15355 swig_obj[0] = args;
15356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15357 if (!SWIG_IsOK(res1)) {
15358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15359 }
15360 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15361 {
15362 PyThreadState* __tstate = wxPyBeginAllowThreads();
15363 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
15364 wxPyEndAllowThreads(__tstate);
15365 if (PyErr_Occurred()) SWIG_fail;
15366 }
15367 resultobj = SWIG_From_int(static_cast< int >(result));
15368 return resultobj;
15369 fail:
15370 return NULL;
15371 }
15372
15373
15374 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15375 PyObject *resultobj = 0;
15376 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15377 int result;
15378 void *argp1 = 0 ;
15379 int res1 = 0 ;
15380 PyObject *swig_obj[1] ;
15381
15382 if (!args) SWIG_fail;
15383 swig_obj[0] = args;
15384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15385 if (!SWIG_IsOK(res1)) {
15386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15387 }
15388 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15389 {
15390 PyThreadState* __tstate = wxPyBeginAllowThreads();
15391 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
15392 wxPyEndAllowThreads(__tstate);
15393 if (PyErr_Occurred()) SWIG_fail;
15394 }
15395 resultobj = SWIG_From_int(static_cast< int >(result));
15396 return resultobj;
15397 fail:
15398 return NULL;
15399 }
15400
15401
15402 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15403 PyObject *resultobj = 0;
15404 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15405 int arg2 ;
15406 void *argp1 = 0 ;
15407 int res1 = 0 ;
15408 int val2 ;
15409 int ecode2 = 0 ;
15410 PyObject * obj0 = 0 ;
15411 PyObject * obj1 = 0 ;
15412 char * kwnames[] = {
15413 (char *) "self",(char *) "stick", NULL
15414 };
15415
15416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
15417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15418 if (!SWIG_IsOK(res1)) {
15419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15420 }
15421 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15422 ecode2 = SWIG_AsVal_int(obj1, &val2);
15423 if (!SWIG_IsOK(ecode2)) {
15424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
15425 }
15426 arg2 = static_cast< int >(val2);
15427 {
15428 PyThreadState* __tstate = wxPyBeginAllowThreads();
15429 (arg1)->SetJoystick(arg2);
15430 wxPyEndAllowThreads(__tstate);
15431 if (PyErr_Occurred()) SWIG_fail;
15432 }
15433 resultobj = SWIG_Py_Void();
15434 return resultobj;
15435 fail:
15436 return NULL;
15437 }
15438
15439
15440 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15441 PyObject *resultobj = 0;
15442 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15443 int arg2 ;
15444 void *argp1 = 0 ;
15445 int res1 = 0 ;
15446 int val2 ;
15447 int ecode2 = 0 ;
15448 PyObject * obj0 = 0 ;
15449 PyObject * obj1 = 0 ;
15450 char * kwnames[] = {
15451 (char *) "self",(char *) "state", NULL
15452 };
15453
15454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
15455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15456 if (!SWIG_IsOK(res1)) {
15457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15458 }
15459 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15460 ecode2 = SWIG_AsVal_int(obj1, &val2);
15461 if (!SWIG_IsOK(ecode2)) {
15462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
15463 }
15464 arg2 = static_cast< int >(val2);
15465 {
15466 PyThreadState* __tstate = wxPyBeginAllowThreads();
15467 (arg1)->SetButtonState(arg2);
15468 wxPyEndAllowThreads(__tstate);
15469 if (PyErr_Occurred()) SWIG_fail;
15470 }
15471 resultobj = SWIG_Py_Void();
15472 return resultobj;
15473 fail:
15474 return NULL;
15475 }
15476
15477
15478 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15479 PyObject *resultobj = 0;
15480 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15481 int arg2 ;
15482 void *argp1 = 0 ;
15483 int res1 = 0 ;
15484 int val2 ;
15485 int ecode2 = 0 ;
15486 PyObject * obj0 = 0 ;
15487 PyObject * obj1 = 0 ;
15488 char * kwnames[] = {
15489 (char *) "self",(char *) "change", NULL
15490 };
15491
15492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
15493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15494 if (!SWIG_IsOK(res1)) {
15495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15496 }
15497 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15498 ecode2 = SWIG_AsVal_int(obj1, &val2);
15499 if (!SWIG_IsOK(ecode2)) {
15500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
15501 }
15502 arg2 = static_cast< int >(val2);
15503 {
15504 PyThreadState* __tstate = wxPyBeginAllowThreads();
15505 (arg1)->SetButtonChange(arg2);
15506 wxPyEndAllowThreads(__tstate);
15507 if (PyErr_Occurred()) SWIG_fail;
15508 }
15509 resultobj = SWIG_Py_Void();
15510 return resultobj;
15511 fail:
15512 return NULL;
15513 }
15514
15515
15516 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15517 PyObject *resultobj = 0;
15518 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15519 wxPoint *arg2 = 0 ;
15520 void *argp1 = 0 ;
15521 int res1 = 0 ;
15522 wxPoint temp2 ;
15523 PyObject * obj0 = 0 ;
15524 PyObject * obj1 = 0 ;
15525 char * kwnames[] = {
15526 (char *) "self",(char *) "pos", NULL
15527 };
15528
15529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15531 if (!SWIG_IsOK(res1)) {
15532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15533 }
15534 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15535 {
15536 arg2 = &temp2;
15537 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15538 }
15539 {
15540 PyThreadState* __tstate = wxPyBeginAllowThreads();
15541 (arg1)->SetPosition((wxPoint const &)*arg2);
15542 wxPyEndAllowThreads(__tstate);
15543 if (PyErr_Occurred()) SWIG_fail;
15544 }
15545 resultobj = SWIG_Py_Void();
15546 return resultobj;
15547 fail:
15548 return NULL;
15549 }
15550
15551
15552 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15553 PyObject *resultobj = 0;
15554 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15555 int arg2 ;
15556 void *argp1 = 0 ;
15557 int res1 = 0 ;
15558 int val2 ;
15559 int ecode2 = 0 ;
15560 PyObject * obj0 = 0 ;
15561 PyObject * obj1 = 0 ;
15562 char * kwnames[] = {
15563 (char *) "self",(char *) "zPos", NULL
15564 };
15565
15566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15568 if (!SWIG_IsOK(res1)) {
15569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15570 }
15571 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15572 ecode2 = SWIG_AsVal_int(obj1, &val2);
15573 if (!SWIG_IsOK(ecode2)) {
15574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
15575 }
15576 arg2 = static_cast< int >(val2);
15577 {
15578 PyThreadState* __tstate = wxPyBeginAllowThreads();
15579 (arg1)->SetZPosition(arg2);
15580 wxPyEndAllowThreads(__tstate);
15581 if (PyErr_Occurred()) SWIG_fail;
15582 }
15583 resultobj = SWIG_Py_Void();
15584 return resultobj;
15585 fail:
15586 return NULL;
15587 }
15588
15589
15590 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15591 PyObject *resultobj = 0;
15592 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15593 bool result;
15594 void *argp1 = 0 ;
15595 int res1 = 0 ;
15596 PyObject *swig_obj[1] ;
15597
15598 if (!args) SWIG_fail;
15599 swig_obj[0] = args;
15600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15601 if (!SWIG_IsOK(res1)) {
15602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15603 }
15604 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15605 {
15606 PyThreadState* __tstate = wxPyBeginAllowThreads();
15607 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
15608 wxPyEndAllowThreads(__tstate);
15609 if (PyErr_Occurred()) SWIG_fail;
15610 }
15611 {
15612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15613 }
15614 return resultobj;
15615 fail:
15616 return NULL;
15617 }
15618
15619
15620 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15621 PyObject *resultobj = 0;
15622 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15623 bool result;
15624 void *argp1 = 0 ;
15625 int res1 = 0 ;
15626 PyObject *swig_obj[1] ;
15627
15628 if (!args) SWIG_fail;
15629 swig_obj[0] = args;
15630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15631 if (!SWIG_IsOK(res1)) {
15632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15633 }
15634 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15635 {
15636 PyThreadState* __tstate = wxPyBeginAllowThreads();
15637 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
15638 wxPyEndAllowThreads(__tstate);
15639 if (PyErr_Occurred()) SWIG_fail;
15640 }
15641 {
15642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15643 }
15644 return resultobj;
15645 fail:
15646 return NULL;
15647 }
15648
15649
15650 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15651 PyObject *resultobj = 0;
15652 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15653 bool result;
15654 void *argp1 = 0 ;
15655 int res1 = 0 ;
15656 PyObject *swig_obj[1] ;
15657
15658 if (!args) SWIG_fail;
15659 swig_obj[0] = args;
15660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15661 if (!SWIG_IsOK(res1)) {
15662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15663 }
15664 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15665 {
15666 PyThreadState* __tstate = wxPyBeginAllowThreads();
15667 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
15668 wxPyEndAllowThreads(__tstate);
15669 if (PyErr_Occurred()) SWIG_fail;
15670 }
15671 {
15672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15673 }
15674 return resultobj;
15675 fail:
15676 return NULL;
15677 }
15678
15679
15680 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15681 PyObject *resultobj = 0;
15682 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15683 int arg2 = (int) wxJOY_BUTTON_ANY ;
15684 bool result;
15685 void *argp1 = 0 ;
15686 int res1 = 0 ;
15687 int val2 ;
15688 int ecode2 = 0 ;
15689 PyObject * obj0 = 0 ;
15690 PyObject * obj1 = 0 ;
15691 char * kwnames[] = {
15692 (char *) "self",(char *) "but", NULL
15693 };
15694
15695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
15696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15697 if (!SWIG_IsOK(res1)) {
15698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15699 }
15700 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15701 if (obj1) {
15702 ecode2 = SWIG_AsVal_int(obj1, &val2);
15703 if (!SWIG_IsOK(ecode2)) {
15704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
15705 }
15706 arg2 = static_cast< int >(val2);
15707 }
15708 {
15709 PyThreadState* __tstate = wxPyBeginAllowThreads();
15710 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
15711 wxPyEndAllowThreads(__tstate);
15712 if (PyErr_Occurred()) SWIG_fail;
15713 }
15714 {
15715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15716 }
15717 return resultobj;
15718 fail:
15719 return NULL;
15720 }
15721
15722
15723 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15724 PyObject *resultobj = 0;
15725 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15726 int arg2 = (int) wxJOY_BUTTON_ANY ;
15727 bool result;
15728 void *argp1 = 0 ;
15729 int res1 = 0 ;
15730 int val2 ;
15731 int ecode2 = 0 ;
15732 PyObject * obj0 = 0 ;
15733 PyObject * obj1 = 0 ;
15734 char * kwnames[] = {
15735 (char *) "self",(char *) "but", NULL
15736 };
15737
15738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
15739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15740 if (!SWIG_IsOK(res1)) {
15741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15742 }
15743 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15744 if (obj1) {
15745 ecode2 = SWIG_AsVal_int(obj1, &val2);
15746 if (!SWIG_IsOK(ecode2)) {
15747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
15748 }
15749 arg2 = static_cast< int >(val2);
15750 }
15751 {
15752 PyThreadState* __tstate = wxPyBeginAllowThreads();
15753 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
15754 wxPyEndAllowThreads(__tstate);
15755 if (PyErr_Occurred()) SWIG_fail;
15756 }
15757 {
15758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15759 }
15760 return resultobj;
15761 fail:
15762 return NULL;
15763 }
15764
15765
15766 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15767 PyObject *resultobj = 0;
15768 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15769 int arg2 = (int) wxJOY_BUTTON_ANY ;
15770 bool result;
15771 void *argp1 = 0 ;
15772 int res1 = 0 ;
15773 int val2 ;
15774 int ecode2 = 0 ;
15775 PyObject * obj0 = 0 ;
15776 PyObject * obj1 = 0 ;
15777 char * kwnames[] = {
15778 (char *) "self",(char *) "but", NULL
15779 };
15780
15781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
15782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15783 if (!SWIG_IsOK(res1)) {
15784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15785 }
15786 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15787 if (obj1) {
15788 ecode2 = SWIG_AsVal_int(obj1, &val2);
15789 if (!SWIG_IsOK(ecode2)) {
15790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
15791 }
15792 arg2 = static_cast< int >(val2);
15793 }
15794 {
15795 PyThreadState* __tstate = wxPyBeginAllowThreads();
15796 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
15797 wxPyEndAllowThreads(__tstate);
15798 if (PyErr_Occurred()) SWIG_fail;
15799 }
15800 {
15801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15802 }
15803 return resultobj;
15804 fail:
15805 return NULL;
15806 }
15807
15808
15809 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15810 PyObject *obj;
15811 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15812 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
15813 return SWIG_Py_Void();
15814 }
15815
15816 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15817 return SWIG_Python_InitShadowInstance(args);
15818 }
15819
15820 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15821 PyObject *resultobj = 0;
15822 wxString const &arg1_defvalue = wxPyEmptyString ;
15823 wxString *arg1 = (wxString *) &arg1_defvalue ;
15824 wxSound *result = 0 ;
15825 bool temp1 = false ;
15826 PyObject * obj0 = 0 ;
15827 char * kwnames[] = {
15828 (char *) "fileName", NULL
15829 };
15830
15831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
15832 if (obj0) {
15833 {
15834 arg1 = wxString_in_helper(obj0);
15835 if (arg1 == NULL) SWIG_fail;
15836 temp1 = true;
15837 }
15838 }
15839 {
15840 if (!wxPyCheckForApp()) SWIG_fail;
15841 PyThreadState* __tstate = wxPyBeginAllowThreads();
15842 result = (wxSound *)new_wxSound((wxString const &)*arg1);
15843 wxPyEndAllowThreads(__tstate);
15844 if (PyErr_Occurred()) SWIG_fail;
15845 }
15846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
15847 {
15848 if (temp1)
15849 delete arg1;
15850 }
15851 return resultobj;
15852 fail:
15853 {
15854 if (temp1)
15855 delete arg1;
15856 }
15857 return NULL;
15858 }
15859
15860
15861 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15862 PyObject *resultobj = 0;
15863 PyObject *arg1 = (PyObject *) 0 ;
15864 wxSound *result = 0 ;
15865 PyObject * obj0 = 0 ;
15866 char * kwnames[] = {
15867 (char *) "data", NULL
15868 };
15869
15870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
15871 arg1 = obj0;
15872 {
15873 if (!wxPyCheckForApp()) SWIG_fail;
15874 PyThreadState* __tstate = wxPyBeginAllowThreads();
15875 result = (wxSound *)new_wxSound(arg1);
15876 wxPyEndAllowThreads(__tstate);
15877 if (PyErr_Occurred()) SWIG_fail;
15878 }
15879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
15880 return resultobj;
15881 fail:
15882 return NULL;
15883 }
15884
15885
15886 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15887 PyObject *resultobj = 0;
15888 wxSound *arg1 = (wxSound *) 0 ;
15889 void *argp1 = 0 ;
15890 int res1 = 0 ;
15891 PyObject *swig_obj[1] ;
15892
15893 if (!args) SWIG_fail;
15894 swig_obj[0] = args;
15895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
15896 if (!SWIG_IsOK(res1)) {
15897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
15898 }
15899 arg1 = reinterpret_cast< wxSound * >(argp1);
15900 {
15901 PyThreadState* __tstate = wxPyBeginAllowThreads();
15902 delete arg1;
15903
15904 wxPyEndAllowThreads(__tstate);
15905 if (PyErr_Occurred()) SWIG_fail;
15906 }
15907 resultobj = SWIG_Py_Void();
15908 return resultobj;
15909 fail:
15910 return NULL;
15911 }
15912
15913
15914 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15915 PyObject *resultobj = 0;
15916 wxSound *arg1 = (wxSound *) 0 ;
15917 wxString *arg2 = 0 ;
15918 bool result;
15919 void *argp1 = 0 ;
15920 int res1 = 0 ;
15921 bool temp2 = false ;
15922 PyObject * obj0 = 0 ;
15923 PyObject * obj1 = 0 ;
15924 char * kwnames[] = {
15925 (char *) "self",(char *) "fileName", NULL
15926 };
15927
15928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
15929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15930 if (!SWIG_IsOK(res1)) {
15931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
15932 }
15933 arg1 = reinterpret_cast< wxSound * >(argp1);
15934 {
15935 arg2 = wxString_in_helper(obj1);
15936 if (arg2 == NULL) SWIG_fail;
15937 temp2 = true;
15938 }
15939 {
15940 PyThreadState* __tstate = wxPyBeginAllowThreads();
15941 result = (bool)(arg1)->Create((wxString const &)*arg2);
15942 wxPyEndAllowThreads(__tstate);
15943 if (PyErr_Occurred()) SWIG_fail;
15944 }
15945 {
15946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15947 }
15948 {
15949 if (temp2)
15950 delete arg2;
15951 }
15952 return resultobj;
15953 fail:
15954 {
15955 if (temp2)
15956 delete arg2;
15957 }
15958 return NULL;
15959 }
15960
15961
15962 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15963 PyObject *resultobj = 0;
15964 wxSound *arg1 = (wxSound *) 0 ;
15965 PyObject *arg2 = (PyObject *) 0 ;
15966 bool result;
15967 void *argp1 = 0 ;
15968 int res1 = 0 ;
15969 PyObject * obj0 = 0 ;
15970 PyObject * obj1 = 0 ;
15971 char * kwnames[] = {
15972 (char *) "self",(char *) "data", NULL
15973 };
15974
15975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
15976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15977 if (!SWIG_IsOK(res1)) {
15978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
15979 }
15980 arg1 = reinterpret_cast< wxSound * >(argp1);
15981 arg2 = obj1;
15982 {
15983 PyThreadState* __tstate = wxPyBeginAllowThreads();
15984 result = (bool)wxSound_CreateFromData(arg1,arg2);
15985 wxPyEndAllowThreads(__tstate);
15986 if (PyErr_Occurred()) SWIG_fail;
15987 }
15988 {
15989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15990 }
15991 return resultobj;
15992 fail:
15993 return NULL;
15994 }
15995
15996
15997 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15998 PyObject *resultobj = 0;
15999 wxSound *arg1 = (wxSound *) 0 ;
16000 bool result;
16001 void *argp1 = 0 ;
16002 int res1 = 0 ;
16003 PyObject *swig_obj[1] ;
16004
16005 if (!args) SWIG_fail;
16006 swig_obj[0] = args;
16007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16008 if (!SWIG_IsOK(res1)) {
16009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
16010 }
16011 arg1 = reinterpret_cast< wxSound * >(argp1);
16012 {
16013 PyThreadState* __tstate = wxPyBeginAllowThreads();
16014 result = (bool)(arg1)->IsOk();
16015 wxPyEndAllowThreads(__tstate);
16016 if (PyErr_Occurred()) SWIG_fail;
16017 }
16018 {
16019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16020 }
16021 return resultobj;
16022 fail:
16023 return NULL;
16024 }
16025
16026
16027 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16028 PyObject *resultobj = 0;
16029 wxSound *arg1 = (wxSound *) 0 ;
16030 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16031 bool result;
16032 void *argp1 = 0 ;
16033 int res1 = 0 ;
16034 unsigned int val2 ;
16035 int ecode2 = 0 ;
16036 PyObject * obj0 = 0 ;
16037 PyObject * obj1 = 0 ;
16038 char * kwnames[] = {
16039 (char *) "self",(char *) "flags", NULL
16040 };
16041
16042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
16043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16044 if (!SWIG_IsOK(res1)) {
16045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
16046 }
16047 arg1 = reinterpret_cast< wxSound * >(argp1);
16048 if (obj1) {
16049 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16050 if (!SWIG_IsOK(ecode2)) {
16051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
16052 }
16053 arg2 = static_cast< unsigned int >(val2);
16054 }
16055 {
16056 if (!wxPyCheckForApp()) SWIG_fail;
16057 PyThreadState* __tstate = wxPyBeginAllowThreads();
16058 result = (bool)((wxSound const *)arg1)->Play(arg2);
16059 wxPyEndAllowThreads(__tstate);
16060 if (PyErr_Occurred()) SWIG_fail;
16061 }
16062 {
16063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16064 }
16065 return resultobj;
16066 fail:
16067 return NULL;
16068 }
16069
16070
16071 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16072 PyObject *resultobj = 0;
16073 wxString *arg1 = 0 ;
16074 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16075 bool result;
16076 bool temp1 = false ;
16077 unsigned int val2 ;
16078 int ecode2 = 0 ;
16079 PyObject * obj0 = 0 ;
16080 PyObject * obj1 = 0 ;
16081 char * kwnames[] = {
16082 (char *) "filename",(char *) "flags", NULL
16083 };
16084
16085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
16086 {
16087 arg1 = wxString_in_helper(obj0);
16088 if (arg1 == NULL) SWIG_fail;
16089 temp1 = true;
16090 }
16091 if (obj1) {
16092 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16093 if (!SWIG_IsOK(ecode2)) {
16094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
16095 }
16096 arg2 = static_cast< unsigned int >(val2);
16097 }
16098 {
16099 if (!wxPyCheckForApp()) SWIG_fail;
16100 PyThreadState* __tstate = wxPyBeginAllowThreads();
16101 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
16102 wxPyEndAllowThreads(__tstate);
16103 if (PyErr_Occurred()) SWIG_fail;
16104 }
16105 {
16106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16107 }
16108 {
16109 if (temp1)
16110 delete arg1;
16111 }
16112 return resultobj;
16113 fail:
16114 {
16115 if (temp1)
16116 delete arg1;
16117 }
16118 return NULL;
16119 }
16120
16121
16122 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16123 PyObject *resultobj = 0;
16124
16125 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
16126 {
16127 if (!wxPyCheckForApp()) SWIG_fail;
16128 PyThreadState* __tstate = wxPyBeginAllowThreads();
16129 wxSound::Stop();
16130 wxPyEndAllowThreads(__tstate);
16131 if (PyErr_Occurred()) SWIG_fail;
16132 }
16133 resultobj = SWIG_Py_Void();
16134 return resultobj;
16135 fail:
16136 return NULL;
16137 }
16138
16139
16140 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16141 PyObject *obj;
16142 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16143 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
16144 return SWIG_Py_Void();
16145 }
16146
16147 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16148 return SWIG_Python_InitShadowInstance(args);
16149 }
16150
16151 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16152 PyObject *resultobj = 0;
16153 wxString *arg1 = 0 ;
16154 wxString *arg2 = 0 ;
16155 wxString *arg3 = 0 ;
16156 wxString *arg4 = 0 ;
16157 wxFileTypeInfo *result = 0 ;
16158 bool temp1 = false ;
16159 bool temp2 = false ;
16160 bool temp3 = false ;
16161 bool temp4 = false ;
16162 PyObject * obj0 = 0 ;
16163 PyObject * obj1 = 0 ;
16164 PyObject * obj2 = 0 ;
16165 PyObject * obj3 = 0 ;
16166 char * kwnames[] = {
16167 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
16168 };
16169
16170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16171 {
16172 arg1 = wxString_in_helper(obj0);
16173 if (arg1 == NULL) SWIG_fail;
16174 temp1 = true;
16175 }
16176 {
16177 arg2 = wxString_in_helper(obj1);
16178 if (arg2 == NULL) SWIG_fail;
16179 temp2 = true;
16180 }
16181 {
16182 arg3 = wxString_in_helper(obj2);
16183 if (arg3 == NULL) SWIG_fail;
16184 temp3 = true;
16185 }
16186 {
16187 arg4 = wxString_in_helper(obj3);
16188 if (arg4 == NULL) SWIG_fail;
16189 temp4 = true;
16190 }
16191 {
16192 PyThreadState* __tstate = wxPyBeginAllowThreads();
16193 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
16194 wxPyEndAllowThreads(__tstate);
16195 if (PyErr_Occurred()) SWIG_fail;
16196 }
16197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
16198 {
16199 if (temp1)
16200 delete arg1;
16201 }
16202 {
16203 if (temp2)
16204 delete arg2;
16205 }
16206 {
16207 if (temp3)
16208 delete arg3;
16209 }
16210 {
16211 if (temp4)
16212 delete arg4;
16213 }
16214 return resultobj;
16215 fail:
16216 {
16217 if (temp1)
16218 delete arg1;
16219 }
16220 {
16221 if (temp2)
16222 delete arg2;
16223 }
16224 {
16225 if (temp3)
16226 delete arg3;
16227 }
16228 {
16229 if (temp4)
16230 delete arg4;
16231 }
16232 return NULL;
16233 }
16234
16235
16236 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16237 PyObject *resultobj = 0;
16238 wxArrayString *arg1 = 0 ;
16239 wxFileTypeInfo *result = 0 ;
16240 bool temp1 = false ;
16241 PyObject * obj0 = 0 ;
16242 char * kwnames[] = {
16243 (char *) "sArray", NULL
16244 };
16245
16246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
16247 {
16248 if (! PySequence_Check(obj0)) {
16249 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
16250 SWIG_fail;
16251 }
16252 arg1 = new wxArrayString;
16253 temp1 = true;
16254 int i, len=PySequence_Length(obj0);
16255 for (i=0; i<len; i++) {
16256 PyObject* item = PySequence_GetItem(obj0, i);
16257 wxString* s = wxString_in_helper(item);
16258 if (PyErr_Occurred()) SWIG_fail;
16259 arg1->Add(*s);
16260 delete s;
16261 Py_DECREF(item);
16262 }
16263 }
16264 {
16265 PyThreadState* __tstate = wxPyBeginAllowThreads();
16266 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
16267 wxPyEndAllowThreads(__tstate);
16268 if (PyErr_Occurred()) SWIG_fail;
16269 }
16270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16271 {
16272 if (temp1) delete arg1;
16273 }
16274 return resultobj;
16275 fail:
16276 {
16277 if (temp1) delete arg1;
16278 }
16279 return NULL;
16280 }
16281
16282
16283 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16284 PyObject *resultobj = 0;
16285 wxFileTypeInfo *result = 0 ;
16286
16287 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
16288 {
16289 PyThreadState* __tstate = wxPyBeginAllowThreads();
16290 result = (wxFileTypeInfo *)new wxFileTypeInfo();
16291 wxPyEndAllowThreads(__tstate);
16292 if (PyErr_Occurred()) SWIG_fail;
16293 }
16294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16295 return resultobj;
16296 fail:
16297 return NULL;
16298 }
16299
16300
16301 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16302 PyObject *resultobj = 0;
16303 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16304 bool result;
16305 void *argp1 = 0 ;
16306 int res1 = 0 ;
16307 PyObject *swig_obj[1] ;
16308
16309 if (!args) SWIG_fail;
16310 swig_obj[0] = args;
16311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16312 if (!SWIG_IsOK(res1)) {
16313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16314 }
16315 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16316 {
16317 PyThreadState* __tstate = wxPyBeginAllowThreads();
16318 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
16319 wxPyEndAllowThreads(__tstate);
16320 if (PyErr_Occurred()) SWIG_fail;
16321 }
16322 {
16323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16324 }
16325 return resultobj;
16326 fail:
16327 return NULL;
16328 }
16329
16330
16331 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16332 PyObject *resultobj = 0;
16333 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16334 wxString *arg2 = 0 ;
16335 int arg3 = (int) 0 ;
16336 void *argp1 = 0 ;
16337 int res1 = 0 ;
16338 bool temp2 = false ;
16339 int val3 ;
16340 int ecode3 = 0 ;
16341 PyObject * obj0 = 0 ;
16342 PyObject * obj1 = 0 ;
16343 PyObject * obj2 = 0 ;
16344 char * kwnames[] = {
16345 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
16346 };
16347
16348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16350 if (!SWIG_IsOK(res1)) {
16351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16352 }
16353 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16354 {
16355 arg2 = wxString_in_helper(obj1);
16356 if (arg2 == NULL) SWIG_fail;
16357 temp2 = true;
16358 }
16359 if (obj2) {
16360 ecode3 = SWIG_AsVal_int(obj2, &val3);
16361 if (!SWIG_IsOK(ecode3)) {
16362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
16363 }
16364 arg3 = static_cast< int >(val3);
16365 }
16366 {
16367 PyThreadState* __tstate = wxPyBeginAllowThreads();
16368 (arg1)->SetIcon((wxString const &)*arg2,arg3);
16369 wxPyEndAllowThreads(__tstate);
16370 if (PyErr_Occurred()) SWIG_fail;
16371 }
16372 resultobj = SWIG_Py_Void();
16373 {
16374 if (temp2)
16375 delete arg2;
16376 }
16377 return resultobj;
16378 fail:
16379 {
16380 if (temp2)
16381 delete arg2;
16382 }
16383 return NULL;
16384 }
16385
16386
16387 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16388 PyObject *resultobj = 0;
16389 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16390 wxString *arg2 = 0 ;
16391 void *argp1 = 0 ;
16392 int res1 = 0 ;
16393 bool temp2 = false ;
16394 PyObject * obj0 = 0 ;
16395 PyObject * obj1 = 0 ;
16396 char * kwnames[] = {
16397 (char *) "self",(char *) "shortDesc", NULL
16398 };
16399
16400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
16401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16402 if (!SWIG_IsOK(res1)) {
16403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16404 }
16405 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16406 {
16407 arg2 = wxString_in_helper(obj1);
16408 if (arg2 == NULL) SWIG_fail;
16409 temp2 = true;
16410 }
16411 {
16412 PyThreadState* __tstate = wxPyBeginAllowThreads();
16413 (arg1)->SetShortDesc((wxString const &)*arg2);
16414 wxPyEndAllowThreads(__tstate);
16415 if (PyErr_Occurred()) SWIG_fail;
16416 }
16417 resultobj = SWIG_Py_Void();
16418 {
16419 if (temp2)
16420 delete arg2;
16421 }
16422 return resultobj;
16423 fail:
16424 {
16425 if (temp2)
16426 delete arg2;
16427 }
16428 return NULL;
16429 }
16430
16431
16432 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16433 PyObject *resultobj = 0;
16434 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16435 wxString *result = 0 ;
16436 void *argp1 = 0 ;
16437 int res1 = 0 ;
16438 PyObject *swig_obj[1] ;
16439
16440 if (!args) SWIG_fail;
16441 swig_obj[0] = args;
16442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16443 if (!SWIG_IsOK(res1)) {
16444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16445 }
16446 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16447 {
16448 PyThreadState* __tstate = wxPyBeginAllowThreads();
16449 {
16450 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
16451 result = (wxString *) &_result_ref;
16452 }
16453 wxPyEndAllowThreads(__tstate);
16454 if (PyErr_Occurred()) SWIG_fail;
16455 }
16456 {
16457 #if wxUSE_UNICODE
16458 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16459 #else
16460 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16461 #endif
16462 }
16463 return resultobj;
16464 fail:
16465 return NULL;
16466 }
16467
16468
16469 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16470 PyObject *resultobj = 0;
16471 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16472 wxString *result = 0 ;
16473 void *argp1 = 0 ;
16474 int res1 = 0 ;
16475 PyObject *swig_obj[1] ;
16476
16477 if (!args) SWIG_fail;
16478 swig_obj[0] = args;
16479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16480 if (!SWIG_IsOK(res1)) {
16481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16482 }
16483 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16484 {
16485 PyThreadState* __tstate = wxPyBeginAllowThreads();
16486 {
16487 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
16488 result = (wxString *) &_result_ref;
16489 }
16490 wxPyEndAllowThreads(__tstate);
16491 if (PyErr_Occurred()) SWIG_fail;
16492 }
16493 {
16494 #if wxUSE_UNICODE
16495 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16496 #else
16497 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16498 #endif
16499 }
16500 return resultobj;
16501 fail:
16502 return NULL;
16503 }
16504
16505
16506 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16507 PyObject *resultobj = 0;
16508 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16509 wxString *result = 0 ;
16510 void *argp1 = 0 ;
16511 int res1 = 0 ;
16512 PyObject *swig_obj[1] ;
16513
16514 if (!args) SWIG_fail;
16515 swig_obj[0] = args;
16516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16517 if (!SWIG_IsOK(res1)) {
16518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16519 }
16520 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16521 {
16522 PyThreadState* __tstate = wxPyBeginAllowThreads();
16523 {
16524 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
16525 result = (wxString *) &_result_ref;
16526 }
16527 wxPyEndAllowThreads(__tstate);
16528 if (PyErr_Occurred()) SWIG_fail;
16529 }
16530 {
16531 #if wxUSE_UNICODE
16532 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16533 #else
16534 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16535 #endif
16536 }
16537 return resultobj;
16538 fail:
16539 return NULL;
16540 }
16541
16542
16543 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16544 PyObject *resultobj = 0;
16545 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16546 wxString *result = 0 ;
16547 void *argp1 = 0 ;
16548 int res1 = 0 ;
16549 PyObject *swig_obj[1] ;
16550
16551 if (!args) SWIG_fail;
16552 swig_obj[0] = args;
16553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16554 if (!SWIG_IsOK(res1)) {
16555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16556 }
16557 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16558 {
16559 PyThreadState* __tstate = wxPyBeginAllowThreads();
16560 {
16561 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
16562 result = (wxString *) &_result_ref;
16563 }
16564 wxPyEndAllowThreads(__tstate);
16565 if (PyErr_Occurred()) SWIG_fail;
16566 }
16567 {
16568 #if wxUSE_UNICODE
16569 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16570 #else
16571 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16572 #endif
16573 }
16574 return resultobj;
16575 fail:
16576 return NULL;
16577 }
16578
16579
16580 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16581 PyObject *resultobj = 0;
16582 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16583 wxString *result = 0 ;
16584 void *argp1 = 0 ;
16585 int res1 = 0 ;
16586 PyObject *swig_obj[1] ;
16587
16588 if (!args) SWIG_fail;
16589 swig_obj[0] = args;
16590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16591 if (!SWIG_IsOK(res1)) {
16592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16593 }
16594 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16595 {
16596 PyThreadState* __tstate = wxPyBeginAllowThreads();
16597 {
16598 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
16599 result = (wxString *) &_result_ref;
16600 }
16601 wxPyEndAllowThreads(__tstate);
16602 if (PyErr_Occurred()) SWIG_fail;
16603 }
16604 {
16605 #if wxUSE_UNICODE
16606 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16607 #else
16608 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16609 #endif
16610 }
16611 return resultobj;
16612 fail:
16613 return NULL;
16614 }
16615
16616
16617 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16618 PyObject *resultobj = 0;
16619 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16620 wxArrayString *result = 0 ;
16621 void *argp1 = 0 ;
16622 int res1 = 0 ;
16623 PyObject *swig_obj[1] ;
16624
16625 if (!args) SWIG_fail;
16626 swig_obj[0] = args;
16627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16628 if (!SWIG_IsOK(res1)) {
16629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16630 }
16631 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16632 {
16633 PyThreadState* __tstate = wxPyBeginAllowThreads();
16634 {
16635 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
16636 result = (wxArrayString *) &_result_ref;
16637 }
16638 wxPyEndAllowThreads(__tstate);
16639 if (PyErr_Occurred()) SWIG_fail;
16640 }
16641 {
16642 resultobj = wxArrayString2PyList_helper(*result);
16643 }
16644 return resultobj;
16645 fail:
16646 return NULL;
16647 }
16648
16649
16650 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16651 PyObject *resultobj = 0;
16652 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16653 size_t result;
16654 void *argp1 = 0 ;
16655 int res1 = 0 ;
16656 PyObject *swig_obj[1] ;
16657
16658 if (!args) SWIG_fail;
16659 swig_obj[0] = args;
16660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16661 if (!SWIG_IsOK(res1)) {
16662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16663 }
16664 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16665 {
16666 PyThreadState* __tstate = wxPyBeginAllowThreads();
16667 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
16668 wxPyEndAllowThreads(__tstate);
16669 if (PyErr_Occurred()) SWIG_fail;
16670 }
16671 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16672 return resultobj;
16673 fail:
16674 return NULL;
16675 }
16676
16677
16678 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16679 PyObject *resultobj = 0;
16680 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16681 wxString *result = 0 ;
16682 void *argp1 = 0 ;
16683 int res1 = 0 ;
16684 PyObject *swig_obj[1] ;
16685
16686 if (!args) SWIG_fail;
16687 swig_obj[0] = args;
16688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16689 if (!SWIG_IsOK(res1)) {
16690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16691 }
16692 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16693 {
16694 PyThreadState* __tstate = wxPyBeginAllowThreads();
16695 {
16696 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
16697 result = (wxString *) &_result_ref;
16698 }
16699 wxPyEndAllowThreads(__tstate);
16700 if (PyErr_Occurred()) SWIG_fail;
16701 }
16702 {
16703 #if wxUSE_UNICODE
16704 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16705 #else
16706 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16707 #endif
16708 }
16709 return resultobj;
16710 fail:
16711 return NULL;
16712 }
16713
16714
16715 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16716 PyObject *resultobj = 0;
16717 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16718 int result;
16719 void *argp1 = 0 ;
16720 int res1 = 0 ;
16721 PyObject *swig_obj[1] ;
16722
16723 if (!args) SWIG_fail;
16724 swig_obj[0] = args;
16725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16726 if (!SWIG_IsOK(res1)) {
16727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16728 }
16729 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16730 {
16731 PyThreadState* __tstate = wxPyBeginAllowThreads();
16732 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
16733 wxPyEndAllowThreads(__tstate);
16734 if (PyErr_Occurred()) SWIG_fail;
16735 }
16736 resultobj = SWIG_From_int(static_cast< int >(result));
16737 return resultobj;
16738 fail:
16739 return NULL;
16740 }
16741
16742
16743 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16744 PyObject *obj;
16745 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16746 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
16747 return SWIG_Py_Void();
16748 }
16749
16750 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16751 return SWIG_Python_InitShadowInstance(args);
16752 }
16753
16754 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16755 PyObject *resultobj = 0;
16756 wxFileTypeInfo *arg1 = 0 ;
16757 wxFileType *result = 0 ;
16758 void *argp1 = 0 ;
16759 int res1 = 0 ;
16760 PyObject * obj0 = 0 ;
16761 char * kwnames[] = {
16762 (char *) "ftInfo", NULL
16763 };
16764
16765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
16766 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
16767 if (!SWIG_IsOK(res1)) {
16768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16769 }
16770 if (!argp1) {
16771 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16772 }
16773 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16774 {
16775 PyThreadState* __tstate = wxPyBeginAllowThreads();
16776 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
16777 wxPyEndAllowThreads(__tstate);
16778 if (PyErr_Occurred()) SWIG_fail;
16779 }
16780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
16781 return resultobj;
16782 fail:
16783 return NULL;
16784 }
16785
16786
16787 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16788 PyObject *resultobj = 0;
16789 wxFileType *arg1 = (wxFileType *) 0 ;
16790 void *argp1 = 0 ;
16791 int res1 = 0 ;
16792 PyObject *swig_obj[1] ;
16793
16794 if (!args) SWIG_fail;
16795 swig_obj[0] = args;
16796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
16797 if (!SWIG_IsOK(res1)) {
16798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
16799 }
16800 arg1 = reinterpret_cast< wxFileType * >(argp1);
16801 {
16802 PyThreadState* __tstate = wxPyBeginAllowThreads();
16803 delete arg1;
16804
16805 wxPyEndAllowThreads(__tstate);
16806 if (PyErr_Occurred()) SWIG_fail;
16807 }
16808 resultobj = SWIG_Py_Void();
16809 return resultobj;
16810 fail:
16811 return NULL;
16812 }
16813
16814
16815 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16816 PyObject *resultobj = 0;
16817 wxFileType *arg1 = (wxFileType *) 0 ;
16818 PyObject *result = 0 ;
16819 void *argp1 = 0 ;
16820 int res1 = 0 ;
16821 PyObject *swig_obj[1] ;
16822
16823 if (!args) SWIG_fail;
16824 swig_obj[0] = args;
16825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16826 if (!SWIG_IsOK(res1)) {
16827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
16828 }
16829 arg1 = reinterpret_cast< wxFileType * >(argp1);
16830 {
16831 PyThreadState* __tstate = wxPyBeginAllowThreads();
16832 result = (PyObject *)wxFileType_GetMimeType(arg1);
16833 wxPyEndAllowThreads(__tstate);
16834 if (PyErr_Occurred()) SWIG_fail;
16835 }
16836 resultobj = result;
16837 return resultobj;
16838 fail:
16839 return NULL;
16840 }
16841
16842
16843 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16844 PyObject *resultobj = 0;
16845 wxFileType *arg1 = (wxFileType *) 0 ;
16846 PyObject *result = 0 ;
16847 void *argp1 = 0 ;
16848 int res1 = 0 ;
16849 PyObject *swig_obj[1] ;
16850
16851 if (!args) SWIG_fail;
16852 swig_obj[0] = args;
16853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16854 if (!SWIG_IsOK(res1)) {
16855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
16856 }
16857 arg1 = reinterpret_cast< wxFileType * >(argp1);
16858 {
16859 PyThreadState* __tstate = wxPyBeginAllowThreads();
16860 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
16861 wxPyEndAllowThreads(__tstate);
16862 if (PyErr_Occurred()) SWIG_fail;
16863 }
16864 resultobj = result;
16865 return resultobj;
16866 fail:
16867 return NULL;
16868 }
16869
16870
16871 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16872 PyObject *resultobj = 0;
16873 wxFileType *arg1 = (wxFileType *) 0 ;
16874 PyObject *result = 0 ;
16875 void *argp1 = 0 ;
16876 int res1 = 0 ;
16877 PyObject *swig_obj[1] ;
16878
16879 if (!args) SWIG_fail;
16880 swig_obj[0] = args;
16881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16882 if (!SWIG_IsOK(res1)) {
16883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
16884 }
16885 arg1 = reinterpret_cast< wxFileType * >(argp1);
16886 {
16887 PyThreadState* __tstate = wxPyBeginAllowThreads();
16888 result = (PyObject *)wxFileType_GetExtensions(arg1);
16889 wxPyEndAllowThreads(__tstate);
16890 if (PyErr_Occurred()) SWIG_fail;
16891 }
16892 resultobj = result;
16893 return resultobj;
16894 fail:
16895 return NULL;
16896 }
16897
16898
16899 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16900 PyObject *resultobj = 0;
16901 wxFileType *arg1 = (wxFileType *) 0 ;
16902 wxIcon *result = 0 ;
16903 void *argp1 = 0 ;
16904 int res1 = 0 ;
16905 PyObject *swig_obj[1] ;
16906
16907 if (!args) SWIG_fail;
16908 swig_obj[0] = args;
16909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16910 if (!SWIG_IsOK(res1)) {
16911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
16912 }
16913 arg1 = reinterpret_cast< wxFileType * >(argp1);
16914 {
16915 PyThreadState* __tstate = wxPyBeginAllowThreads();
16916 result = (wxIcon *)wxFileType_GetIcon(arg1);
16917 wxPyEndAllowThreads(__tstate);
16918 if (PyErr_Occurred()) SWIG_fail;
16919 }
16920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
16921 return resultobj;
16922 fail:
16923 return NULL;
16924 }
16925
16926
16927 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16928 PyObject *resultobj = 0;
16929 wxFileType *arg1 = (wxFileType *) 0 ;
16930 PyObject *result = 0 ;
16931 void *argp1 = 0 ;
16932 int res1 = 0 ;
16933 PyObject *swig_obj[1] ;
16934
16935 if (!args) SWIG_fail;
16936 swig_obj[0] = args;
16937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16938 if (!SWIG_IsOK(res1)) {
16939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
16940 }
16941 arg1 = reinterpret_cast< wxFileType * >(argp1);
16942 {
16943 PyThreadState* __tstate = wxPyBeginAllowThreads();
16944 result = (PyObject *)wxFileType_GetIconInfo(arg1);
16945 wxPyEndAllowThreads(__tstate);
16946 if (PyErr_Occurred()) SWIG_fail;
16947 }
16948 resultobj = result;
16949 return resultobj;
16950 fail:
16951 return NULL;
16952 }
16953
16954
16955 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16956 PyObject *resultobj = 0;
16957 wxFileType *arg1 = (wxFileType *) 0 ;
16958 PyObject *result = 0 ;
16959 void *argp1 = 0 ;
16960 int res1 = 0 ;
16961 PyObject *swig_obj[1] ;
16962
16963 if (!args) SWIG_fail;
16964 swig_obj[0] = args;
16965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16966 if (!SWIG_IsOK(res1)) {
16967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
16968 }
16969 arg1 = reinterpret_cast< wxFileType * >(argp1);
16970 {
16971 PyThreadState* __tstate = wxPyBeginAllowThreads();
16972 result = (PyObject *)wxFileType_GetDescription(arg1);
16973 wxPyEndAllowThreads(__tstate);
16974 if (PyErr_Occurred()) SWIG_fail;
16975 }
16976 resultobj = result;
16977 return resultobj;
16978 fail:
16979 return NULL;
16980 }
16981
16982
16983 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16984 PyObject *resultobj = 0;
16985 wxFileType *arg1 = (wxFileType *) 0 ;
16986 wxString *arg2 = 0 ;
16987 wxString const &arg3_defvalue = wxPyEmptyString ;
16988 wxString *arg3 = (wxString *) &arg3_defvalue ;
16989 PyObject *result = 0 ;
16990 void *argp1 = 0 ;
16991 int res1 = 0 ;
16992 bool temp2 = false ;
16993 bool temp3 = false ;
16994 PyObject * obj0 = 0 ;
16995 PyObject * obj1 = 0 ;
16996 PyObject * obj2 = 0 ;
16997 char * kwnames[] = {
16998 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
16999 };
17000
17001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17003 if (!SWIG_IsOK(res1)) {
17004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17005 }
17006 arg1 = reinterpret_cast< wxFileType * >(argp1);
17007 {
17008 arg2 = wxString_in_helper(obj1);
17009 if (arg2 == NULL) SWIG_fail;
17010 temp2 = true;
17011 }
17012 if (obj2) {
17013 {
17014 arg3 = wxString_in_helper(obj2);
17015 if (arg3 == NULL) SWIG_fail;
17016 temp3 = true;
17017 }
17018 }
17019 {
17020 PyThreadState* __tstate = wxPyBeginAllowThreads();
17021 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17022 wxPyEndAllowThreads(__tstate);
17023 if (PyErr_Occurred()) SWIG_fail;
17024 }
17025 resultobj = result;
17026 {
17027 if (temp2)
17028 delete arg2;
17029 }
17030 {
17031 if (temp3)
17032 delete arg3;
17033 }
17034 return resultobj;
17035 fail:
17036 {
17037 if (temp2)
17038 delete arg2;
17039 }
17040 {
17041 if (temp3)
17042 delete arg3;
17043 }
17044 return NULL;
17045 }
17046
17047
17048 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17049 PyObject *resultobj = 0;
17050 wxFileType *arg1 = (wxFileType *) 0 ;
17051 wxString *arg2 = 0 ;
17052 wxString const &arg3_defvalue = wxPyEmptyString ;
17053 wxString *arg3 = (wxString *) &arg3_defvalue ;
17054 PyObject *result = 0 ;
17055 void *argp1 = 0 ;
17056 int res1 = 0 ;
17057 bool temp2 = false ;
17058 bool temp3 = false ;
17059 PyObject * obj0 = 0 ;
17060 PyObject * obj1 = 0 ;
17061 PyObject * obj2 = 0 ;
17062 char * kwnames[] = {
17063 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17064 };
17065
17066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17068 if (!SWIG_IsOK(res1)) {
17069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17070 }
17071 arg1 = reinterpret_cast< wxFileType * >(argp1);
17072 {
17073 arg2 = wxString_in_helper(obj1);
17074 if (arg2 == NULL) SWIG_fail;
17075 temp2 = true;
17076 }
17077 if (obj2) {
17078 {
17079 arg3 = wxString_in_helper(obj2);
17080 if (arg3 == NULL) SWIG_fail;
17081 temp3 = true;
17082 }
17083 }
17084 {
17085 PyThreadState* __tstate = wxPyBeginAllowThreads();
17086 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17087 wxPyEndAllowThreads(__tstate);
17088 if (PyErr_Occurred()) SWIG_fail;
17089 }
17090 resultobj = result;
17091 {
17092 if (temp2)
17093 delete arg2;
17094 }
17095 {
17096 if (temp3)
17097 delete arg3;
17098 }
17099 return resultobj;
17100 fail:
17101 {
17102 if (temp2)
17103 delete arg2;
17104 }
17105 {
17106 if (temp3)
17107 delete arg3;
17108 }
17109 return NULL;
17110 }
17111
17112
17113 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17114 PyObject *resultobj = 0;
17115 wxFileType *arg1 = (wxFileType *) 0 ;
17116 wxString *arg2 = 0 ;
17117 wxString const &arg3_defvalue = wxPyEmptyString ;
17118 wxString *arg3 = (wxString *) &arg3_defvalue ;
17119 PyObject *result = 0 ;
17120 void *argp1 = 0 ;
17121 int res1 = 0 ;
17122 bool temp2 = false ;
17123 bool temp3 = false ;
17124 PyObject * obj0 = 0 ;
17125 PyObject * obj1 = 0 ;
17126 PyObject * obj2 = 0 ;
17127 char * kwnames[] = {
17128 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17129 };
17130
17131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17133 if (!SWIG_IsOK(res1)) {
17134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
17135 }
17136 arg1 = reinterpret_cast< wxFileType * >(argp1);
17137 {
17138 arg2 = wxString_in_helper(obj1);
17139 if (arg2 == NULL) SWIG_fail;
17140 temp2 = true;
17141 }
17142 if (obj2) {
17143 {
17144 arg3 = wxString_in_helper(obj2);
17145 if (arg3 == NULL) SWIG_fail;
17146 temp3 = true;
17147 }
17148 }
17149 {
17150 PyThreadState* __tstate = wxPyBeginAllowThreads();
17151 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17152 wxPyEndAllowThreads(__tstate);
17153 if (PyErr_Occurred()) SWIG_fail;
17154 }
17155 resultobj = result;
17156 {
17157 if (temp2)
17158 delete arg2;
17159 }
17160 {
17161 if (temp3)
17162 delete arg3;
17163 }
17164 return resultobj;
17165 fail:
17166 {
17167 if (temp2)
17168 delete arg2;
17169 }
17170 {
17171 if (temp3)
17172 delete arg3;
17173 }
17174 return NULL;
17175 }
17176
17177
17178 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17179 PyObject *resultobj = 0;
17180 wxFileType *arg1 = (wxFileType *) 0 ;
17181 wxString *arg2 = 0 ;
17182 wxString *arg3 = 0 ;
17183 bool arg4 = (bool) true ;
17184 bool result;
17185 void *argp1 = 0 ;
17186 int res1 = 0 ;
17187 bool temp2 = false ;
17188 bool temp3 = false ;
17189 bool val4 ;
17190 int ecode4 = 0 ;
17191 PyObject * obj0 = 0 ;
17192 PyObject * obj1 = 0 ;
17193 PyObject * obj2 = 0 ;
17194 PyObject * obj3 = 0 ;
17195 char * kwnames[] = {
17196 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
17197 };
17198
17199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17201 if (!SWIG_IsOK(res1)) {
17202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17203 }
17204 arg1 = reinterpret_cast< wxFileType * >(argp1);
17205 {
17206 arg2 = wxString_in_helper(obj1);
17207 if (arg2 == NULL) SWIG_fail;
17208 temp2 = true;
17209 }
17210 {
17211 arg3 = wxString_in_helper(obj2);
17212 if (arg3 == NULL) SWIG_fail;
17213 temp3 = true;
17214 }
17215 if (obj3) {
17216 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17217 if (!SWIG_IsOK(ecode4)) {
17218 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
17219 }
17220 arg4 = static_cast< bool >(val4);
17221 }
17222 {
17223 PyThreadState* __tstate = wxPyBeginAllowThreads();
17224 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17225 wxPyEndAllowThreads(__tstate);
17226 if (PyErr_Occurred()) SWIG_fail;
17227 }
17228 {
17229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17230 }
17231 {
17232 if (temp2)
17233 delete arg2;
17234 }
17235 {
17236 if (temp3)
17237 delete arg3;
17238 }
17239 return resultobj;
17240 fail:
17241 {
17242 if (temp2)
17243 delete arg2;
17244 }
17245 {
17246 if (temp3)
17247 delete arg3;
17248 }
17249 return NULL;
17250 }
17251
17252
17253 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17254 PyObject *resultobj = 0;
17255 wxFileType *arg1 = (wxFileType *) 0 ;
17256 wxString const &arg2_defvalue = wxPyEmptyString ;
17257 wxString *arg2 = (wxString *) &arg2_defvalue ;
17258 int arg3 = (int) 0 ;
17259 bool result;
17260 void *argp1 = 0 ;
17261 int res1 = 0 ;
17262 bool temp2 = false ;
17263 int val3 ;
17264 int ecode3 = 0 ;
17265 PyObject * obj0 = 0 ;
17266 PyObject * obj1 = 0 ;
17267 PyObject * obj2 = 0 ;
17268 char * kwnames[] = {
17269 (char *) "self",(char *) "cmd",(char *) "index", NULL
17270 };
17271
17272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17274 if (!SWIG_IsOK(res1)) {
17275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17276 }
17277 arg1 = reinterpret_cast< wxFileType * >(argp1);
17278 if (obj1) {
17279 {
17280 arg2 = wxString_in_helper(obj1);
17281 if (arg2 == NULL) SWIG_fail;
17282 temp2 = true;
17283 }
17284 }
17285 if (obj2) {
17286 ecode3 = SWIG_AsVal_int(obj2, &val3);
17287 if (!SWIG_IsOK(ecode3)) {
17288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
17289 }
17290 arg3 = static_cast< int >(val3);
17291 }
17292 {
17293 PyThreadState* __tstate = wxPyBeginAllowThreads();
17294 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
17295 wxPyEndAllowThreads(__tstate);
17296 if (PyErr_Occurred()) SWIG_fail;
17297 }
17298 {
17299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17300 }
17301 {
17302 if (temp2)
17303 delete arg2;
17304 }
17305 return resultobj;
17306 fail:
17307 {
17308 if (temp2)
17309 delete arg2;
17310 }
17311 return NULL;
17312 }
17313
17314
17315 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17316 PyObject *resultobj = 0;
17317 wxFileType *arg1 = (wxFileType *) 0 ;
17318 bool result;
17319 void *argp1 = 0 ;
17320 int res1 = 0 ;
17321 PyObject *swig_obj[1] ;
17322
17323 if (!args) SWIG_fail;
17324 swig_obj[0] = args;
17325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17326 if (!SWIG_IsOK(res1)) {
17327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
17328 }
17329 arg1 = reinterpret_cast< wxFileType * >(argp1);
17330 {
17331 PyThreadState* __tstate = wxPyBeginAllowThreads();
17332 result = (bool)(arg1)->Unassociate();
17333 wxPyEndAllowThreads(__tstate);
17334 if (PyErr_Occurred()) SWIG_fail;
17335 }
17336 {
17337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17338 }
17339 return resultobj;
17340 fail:
17341 return NULL;
17342 }
17343
17344
17345 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17346 PyObject *resultobj = 0;
17347 wxString *arg1 = 0 ;
17348 wxString *arg2 = 0 ;
17349 wxString const &arg3_defvalue = wxPyEmptyString ;
17350 wxString *arg3 = (wxString *) &arg3_defvalue ;
17351 wxString result;
17352 bool temp1 = false ;
17353 bool temp2 = false ;
17354 bool temp3 = false ;
17355 PyObject * obj0 = 0 ;
17356 PyObject * obj1 = 0 ;
17357 PyObject * obj2 = 0 ;
17358 char * kwnames[] = {
17359 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
17360 };
17361
17362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17363 {
17364 arg1 = wxString_in_helper(obj0);
17365 if (arg1 == NULL) SWIG_fail;
17366 temp1 = true;
17367 }
17368 {
17369 arg2 = wxString_in_helper(obj1);
17370 if (arg2 == NULL) SWIG_fail;
17371 temp2 = true;
17372 }
17373 if (obj2) {
17374 {
17375 arg3 = wxString_in_helper(obj2);
17376 if (arg3 == NULL) SWIG_fail;
17377 temp3 = true;
17378 }
17379 }
17380 {
17381 PyThreadState* __tstate = wxPyBeginAllowThreads();
17382 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17383 wxPyEndAllowThreads(__tstate);
17384 if (PyErr_Occurred()) SWIG_fail;
17385 }
17386 {
17387 #if wxUSE_UNICODE
17388 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17389 #else
17390 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17391 #endif
17392 }
17393 {
17394 if (temp1)
17395 delete arg1;
17396 }
17397 {
17398 if (temp2)
17399 delete arg2;
17400 }
17401 {
17402 if (temp3)
17403 delete arg3;
17404 }
17405 return resultobj;
17406 fail:
17407 {
17408 if (temp1)
17409 delete arg1;
17410 }
17411 {
17412 if (temp2)
17413 delete arg2;
17414 }
17415 {
17416 if (temp3)
17417 delete arg3;
17418 }
17419 return NULL;
17420 }
17421
17422
17423 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17424 PyObject *obj;
17425 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17426 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
17427 return SWIG_Py_Void();
17428 }
17429
17430 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17431 return SWIG_Python_InitShadowInstance(args);
17432 }
17433
17434 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
17435 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
17436 return 1;
17437 }
17438
17439
17440 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
17441 PyObject *pyobj = 0;
17442
17443 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
17444 return pyobj;
17445 }
17446
17447
17448 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17449 PyObject *resultobj = 0;
17450 wxString *arg1 = 0 ;
17451 wxString *arg2 = 0 ;
17452 bool result;
17453 bool temp1 = false ;
17454 bool temp2 = false ;
17455 PyObject * obj0 = 0 ;
17456 PyObject * obj1 = 0 ;
17457 char * kwnames[] = {
17458 (char *) "mimeType",(char *) "wildcard", NULL
17459 };
17460
17461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
17462 {
17463 arg1 = wxString_in_helper(obj0);
17464 if (arg1 == NULL) SWIG_fail;
17465 temp1 = true;
17466 }
17467 {
17468 arg2 = wxString_in_helper(obj1);
17469 if (arg2 == NULL) SWIG_fail;
17470 temp2 = true;
17471 }
17472 {
17473 PyThreadState* __tstate = wxPyBeginAllowThreads();
17474 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
17475 wxPyEndAllowThreads(__tstate);
17476 if (PyErr_Occurred()) SWIG_fail;
17477 }
17478 {
17479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17480 }
17481 {
17482 if (temp1)
17483 delete arg1;
17484 }
17485 {
17486 if (temp2)
17487 delete arg2;
17488 }
17489 return resultobj;
17490 fail:
17491 {
17492 if (temp1)
17493 delete arg1;
17494 }
17495 {
17496 if (temp2)
17497 delete arg2;
17498 }
17499 return NULL;
17500 }
17501
17502
17503 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17504 PyObject *resultobj = 0;
17505 wxMimeTypesManager *result = 0 ;
17506
17507 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
17508 {
17509 PyThreadState* __tstate = wxPyBeginAllowThreads();
17510 result = (wxMimeTypesManager *)new wxMimeTypesManager();
17511 wxPyEndAllowThreads(__tstate);
17512 if (PyErr_Occurred()) SWIG_fail;
17513 }
17514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
17515 return resultobj;
17516 fail:
17517 return NULL;
17518 }
17519
17520
17521 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17522 PyObject *resultobj = 0;
17523 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17524 int arg2 = (int) wxMAILCAP_ALL ;
17525 wxString const &arg3_defvalue = wxPyEmptyString ;
17526 wxString *arg3 = (wxString *) &arg3_defvalue ;
17527 void *argp1 = 0 ;
17528 int res1 = 0 ;
17529 int val2 ;
17530 int ecode2 = 0 ;
17531 bool temp3 = false ;
17532 PyObject * obj0 = 0 ;
17533 PyObject * obj1 = 0 ;
17534 PyObject * obj2 = 0 ;
17535 char * kwnames[] = {
17536 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
17537 };
17538
17539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17541 if (!SWIG_IsOK(res1)) {
17542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17543 }
17544 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17545 if (obj1) {
17546 ecode2 = SWIG_AsVal_int(obj1, &val2);
17547 if (!SWIG_IsOK(ecode2)) {
17548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
17549 }
17550 arg2 = static_cast< int >(val2);
17551 }
17552 if (obj2) {
17553 {
17554 arg3 = wxString_in_helper(obj2);
17555 if (arg3 == NULL) SWIG_fail;
17556 temp3 = true;
17557 }
17558 }
17559 {
17560 PyThreadState* __tstate = wxPyBeginAllowThreads();
17561 (arg1)->Initialize(arg2,(wxString const &)*arg3);
17562 wxPyEndAllowThreads(__tstate);
17563 if (PyErr_Occurred()) SWIG_fail;
17564 }
17565 resultobj = SWIG_Py_Void();
17566 {
17567 if (temp3)
17568 delete arg3;
17569 }
17570 return resultobj;
17571 fail:
17572 {
17573 if (temp3)
17574 delete arg3;
17575 }
17576 return NULL;
17577 }
17578
17579
17580 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17581 PyObject *resultobj = 0;
17582 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17583 void *argp1 = 0 ;
17584 int res1 = 0 ;
17585 PyObject *swig_obj[1] ;
17586
17587 if (!args) SWIG_fail;
17588 swig_obj[0] = args;
17589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17590 if (!SWIG_IsOK(res1)) {
17591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17592 }
17593 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17594 {
17595 PyThreadState* __tstate = wxPyBeginAllowThreads();
17596 (arg1)->ClearData();
17597 wxPyEndAllowThreads(__tstate);
17598 if (PyErr_Occurred()) SWIG_fail;
17599 }
17600 resultobj = SWIG_Py_Void();
17601 return resultobj;
17602 fail:
17603 return NULL;
17604 }
17605
17606
17607 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17608 PyObject *resultobj = 0;
17609 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17610 wxString *arg2 = 0 ;
17611 wxFileType *result = 0 ;
17612 void *argp1 = 0 ;
17613 int res1 = 0 ;
17614 bool temp2 = false ;
17615 PyObject * obj0 = 0 ;
17616 PyObject * obj1 = 0 ;
17617 char * kwnames[] = {
17618 (char *) "self",(char *) "ext", NULL
17619 };
17620
17621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
17622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17623 if (!SWIG_IsOK(res1)) {
17624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17625 }
17626 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17627 {
17628 arg2 = wxString_in_helper(obj1);
17629 if (arg2 == NULL) SWIG_fail;
17630 temp2 = true;
17631 }
17632 {
17633 PyThreadState* __tstate = wxPyBeginAllowThreads();
17634 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
17635 wxPyEndAllowThreads(__tstate);
17636 if (PyErr_Occurred()) SWIG_fail;
17637 }
17638 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17639 {
17640 if (temp2)
17641 delete arg2;
17642 }
17643 return resultobj;
17644 fail:
17645 {
17646 if (temp2)
17647 delete arg2;
17648 }
17649 return NULL;
17650 }
17651
17652
17653 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17654 PyObject *resultobj = 0;
17655 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17656 wxString *arg2 = 0 ;
17657 wxFileType *result = 0 ;
17658 void *argp1 = 0 ;
17659 int res1 = 0 ;
17660 bool temp2 = false ;
17661 PyObject * obj0 = 0 ;
17662 PyObject * obj1 = 0 ;
17663 char * kwnames[] = {
17664 (char *) "self",(char *) "mimeType", NULL
17665 };
17666
17667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
17668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17669 if (!SWIG_IsOK(res1)) {
17670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17671 }
17672 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17673 {
17674 arg2 = wxString_in_helper(obj1);
17675 if (arg2 == NULL) SWIG_fail;
17676 temp2 = true;
17677 }
17678 {
17679 PyThreadState* __tstate = wxPyBeginAllowThreads();
17680 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
17681 wxPyEndAllowThreads(__tstate);
17682 if (PyErr_Occurred()) SWIG_fail;
17683 }
17684 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17685 {
17686 if (temp2)
17687 delete arg2;
17688 }
17689 return resultobj;
17690 fail:
17691 {
17692 if (temp2)
17693 delete arg2;
17694 }
17695 return NULL;
17696 }
17697
17698
17699 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17700 PyObject *resultobj = 0;
17701 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17702 wxString *arg2 = 0 ;
17703 bool arg3 = (bool) false ;
17704 bool result;
17705 void *argp1 = 0 ;
17706 int res1 = 0 ;
17707 bool temp2 = false ;
17708 bool val3 ;
17709 int ecode3 = 0 ;
17710 PyObject * obj0 = 0 ;
17711 PyObject * obj1 = 0 ;
17712 PyObject * obj2 = 0 ;
17713 char * kwnames[] = {
17714 (char *) "self",(char *) "filename",(char *) "fallback", NULL
17715 };
17716
17717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17719 if (!SWIG_IsOK(res1)) {
17720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17721 }
17722 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17723 {
17724 arg2 = wxString_in_helper(obj1);
17725 if (arg2 == NULL) SWIG_fail;
17726 temp2 = true;
17727 }
17728 if (obj2) {
17729 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17730 if (!SWIG_IsOK(ecode3)) {
17731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
17732 }
17733 arg3 = static_cast< bool >(val3);
17734 }
17735 {
17736 PyThreadState* __tstate = wxPyBeginAllowThreads();
17737 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
17738 wxPyEndAllowThreads(__tstate);
17739 if (PyErr_Occurred()) SWIG_fail;
17740 }
17741 {
17742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17743 }
17744 {
17745 if (temp2)
17746 delete arg2;
17747 }
17748 return resultobj;
17749 fail:
17750 {
17751 if (temp2)
17752 delete arg2;
17753 }
17754 return NULL;
17755 }
17756
17757
17758 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17759 PyObject *resultobj = 0;
17760 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17761 wxString *arg2 = 0 ;
17762 bool result;
17763 void *argp1 = 0 ;
17764 int res1 = 0 ;
17765 bool temp2 = false ;
17766 PyObject * obj0 = 0 ;
17767 PyObject * obj1 = 0 ;
17768 char * kwnames[] = {
17769 (char *) "self",(char *) "filename", NULL
17770 };
17771
17772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
17773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17774 if (!SWIG_IsOK(res1)) {
17775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17776 }
17777 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17778 {
17779 arg2 = wxString_in_helper(obj1);
17780 if (arg2 == NULL) SWIG_fail;
17781 temp2 = true;
17782 }
17783 {
17784 PyThreadState* __tstate = wxPyBeginAllowThreads();
17785 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
17786 wxPyEndAllowThreads(__tstate);
17787 if (PyErr_Occurred()) SWIG_fail;
17788 }
17789 {
17790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17791 }
17792 {
17793 if (temp2)
17794 delete arg2;
17795 }
17796 return resultobj;
17797 fail:
17798 {
17799 if (temp2)
17800 delete arg2;
17801 }
17802 return NULL;
17803 }
17804
17805
17806 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17807 PyObject *resultobj = 0;
17808 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17809 PyObject *result = 0 ;
17810 void *argp1 = 0 ;
17811 int res1 = 0 ;
17812 PyObject *swig_obj[1] ;
17813
17814 if (!args) SWIG_fail;
17815 swig_obj[0] = args;
17816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17817 if (!SWIG_IsOK(res1)) {
17818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17819 }
17820 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17821 {
17822 PyThreadState* __tstate = wxPyBeginAllowThreads();
17823 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
17824 wxPyEndAllowThreads(__tstate);
17825 if (PyErr_Occurred()) SWIG_fail;
17826 }
17827 resultobj = result;
17828 return resultobj;
17829 fail:
17830 return NULL;
17831 }
17832
17833
17834 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17835 PyObject *resultobj = 0;
17836 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17837 wxFileTypeInfo *arg2 = 0 ;
17838 void *argp1 = 0 ;
17839 int res1 = 0 ;
17840 void *argp2 = 0 ;
17841 int res2 = 0 ;
17842 PyObject * obj0 = 0 ;
17843 PyObject * obj1 = 0 ;
17844 char * kwnames[] = {
17845 (char *) "self",(char *) "ft", NULL
17846 };
17847
17848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
17849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17850 if (!SWIG_IsOK(res1)) {
17851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17852 }
17853 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17854 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17855 if (!SWIG_IsOK(res2)) {
17856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17857 }
17858 if (!argp2) {
17859 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17860 }
17861 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17862 {
17863 PyThreadState* __tstate = wxPyBeginAllowThreads();
17864 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
17865 wxPyEndAllowThreads(__tstate);
17866 if (PyErr_Occurred()) SWIG_fail;
17867 }
17868 resultobj = SWIG_Py_Void();
17869 return resultobj;
17870 fail:
17871 return NULL;
17872 }
17873
17874
17875 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17876 PyObject *resultobj = 0;
17877 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17878 wxFileTypeInfo *arg2 = 0 ;
17879 wxFileType *result = 0 ;
17880 void *argp1 = 0 ;
17881 int res1 = 0 ;
17882 void *argp2 = 0 ;
17883 int res2 = 0 ;
17884 PyObject * obj0 = 0 ;
17885 PyObject * obj1 = 0 ;
17886 char * kwnames[] = {
17887 (char *) "self",(char *) "ftInfo", NULL
17888 };
17889
17890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
17891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17892 if (!SWIG_IsOK(res1)) {
17893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17894 }
17895 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17896 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17897 if (!SWIG_IsOK(res2)) {
17898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17899 }
17900 if (!argp2) {
17901 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17902 }
17903 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17904 {
17905 PyThreadState* __tstate = wxPyBeginAllowThreads();
17906 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
17907 wxPyEndAllowThreads(__tstate);
17908 if (PyErr_Occurred()) SWIG_fail;
17909 }
17910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17911 return resultobj;
17912 fail:
17913 return NULL;
17914 }
17915
17916
17917 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17918 PyObject *resultobj = 0;
17919 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17920 wxFileType *arg2 = (wxFileType *) 0 ;
17921 bool result;
17922 void *argp1 = 0 ;
17923 int res1 = 0 ;
17924 void *argp2 = 0 ;
17925 int res2 = 0 ;
17926 PyObject * obj0 = 0 ;
17927 PyObject * obj1 = 0 ;
17928 char * kwnames[] = {
17929 (char *) "self",(char *) "ft", NULL
17930 };
17931
17932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
17933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17934 if (!SWIG_IsOK(res1)) {
17935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17936 }
17937 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17938 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
17939 if (!SWIG_IsOK(res2)) {
17940 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
17941 }
17942 arg2 = reinterpret_cast< wxFileType * >(argp2);
17943 {
17944 PyThreadState* __tstate = wxPyBeginAllowThreads();
17945 result = (bool)(arg1)->Unassociate(arg2);
17946 wxPyEndAllowThreads(__tstate);
17947 if (PyErr_Occurred()) SWIG_fail;
17948 }
17949 {
17950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17951 }
17952 return resultobj;
17953 fail:
17954 return NULL;
17955 }
17956
17957
17958 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17959 PyObject *resultobj = 0;
17960 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17961 void *argp1 = 0 ;
17962 int res1 = 0 ;
17963 PyObject *swig_obj[1] ;
17964
17965 if (!args) SWIG_fail;
17966 swig_obj[0] = args;
17967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
17968 if (!SWIG_IsOK(res1)) {
17969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17970 }
17971 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17972 {
17973 PyThreadState* __tstate = wxPyBeginAllowThreads();
17974 delete arg1;
17975
17976 wxPyEndAllowThreads(__tstate);
17977 if (PyErr_Occurred()) SWIG_fail;
17978 }
17979 resultobj = SWIG_Py_Void();
17980 return resultobj;
17981 fail:
17982 return NULL;
17983 }
17984
17985
17986 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17987 PyObject *obj;
17988 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17989 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
17990 return SWIG_Py_Void();
17991 }
17992
17993 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17994 return SWIG_Python_InitShadowInstance(args);
17995 }
17996
17997 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
17998 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
17999 return 1;
18000 }
18001
18002
18003 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
18004 PyObject *pyobj = 0;
18005
18006 {
18007 #if wxUSE_UNICODE
18008 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18009 #else
18010 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18011 #endif
18012 }
18013 return pyobj;
18014 }
18015
18016
18017 SWIGINTERN int ART_MENU_set(PyObject *) {
18018 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
18019 return 1;
18020 }
18021
18022
18023 SWIGINTERN PyObject *ART_MENU_get(void) {
18024 PyObject *pyobj = 0;
18025
18026 {
18027 #if wxUSE_UNICODE
18028 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18029 #else
18030 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18031 #endif
18032 }
18033 return pyobj;
18034 }
18035
18036
18037 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
18038 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
18039 return 1;
18040 }
18041
18042
18043 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
18044 PyObject *pyobj = 0;
18045
18046 {
18047 #if wxUSE_UNICODE
18048 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18049 #else
18050 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18051 #endif
18052 }
18053 return pyobj;
18054 }
18055
18056
18057 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
18058 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
18059 return 1;
18060 }
18061
18062
18063 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
18064 PyObject *pyobj = 0;
18065
18066 {
18067 #if wxUSE_UNICODE
18068 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18069 #else
18070 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18071 #endif
18072 }
18073 return pyobj;
18074 }
18075
18076
18077 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
18078 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
18079 return 1;
18080 }
18081
18082
18083 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
18084 PyObject *pyobj = 0;
18085
18086 {
18087 #if wxUSE_UNICODE
18088 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18089 #else
18090 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18091 #endif
18092 }
18093 return pyobj;
18094 }
18095
18096
18097 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
18098 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
18099 return 1;
18100 }
18101
18102
18103 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
18104 PyObject *pyobj = 0;
18105
18106 {
18107 #if wxUSE_UNICODE
18108 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18109 #else
18110 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18111 #endif
18112 }
18113 return pyobj;
18114 }
18115
18116
18117 SWIGINTERN int ART_BUTTON_set(PyObject *) {
18118 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
18119 return 1;
18120 }
18121
18122
18123 SWIGINTERN PyObject *ART_BUTTON_get(void) {
18124 PyObject *pyobj = 0;
18125
18126 {
18127 #if wxUSE_UNICODE
18128 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18129 #else
18130 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18131 #endif
18132 }
18133 return pyobj;
18134 }
18135
18136
18137 SWIGINTERN int ART_OTHER_set(PyObject *) {
18138 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
18139 return 1;
18140 }
18141
18142
18143 SWIGINTERN PyObject *ART_OTHER_get(void) {
18144 PyObject *pyobj = 0;
18145
18146 {
18147 #if wxUSE_UNICODE
18148 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18149 #else
18150 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18151 #endif
18152 }
18153 return pyobj;
18154 }
18155
18156
18157 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
18158 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
18159 return 1;
18160 }
18161
18162
18163 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
18164 PyObject *pyobj = 0;
18165
18166 {
18167 #if wxUSE_UNICODE
18168 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18169 #else
18170 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18171 #endif
18172 }
18173 return pyobj;
18174 }
18175
18176
18177 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
18178 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
18179 return 1;
18180 }
18181
18182
18183 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
18184 PyObject *pyobj = 0;
18185
18186 {
18187 #if wxUSE_UNICODE
18188 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18189 #else
18190 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18191 #endif
18192 }
18193 return pyobj;
18194 }
18195
18196
18197 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
18198 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
18199 return 1;
18200 }
18201
18202
18203 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
18204 PyObject *pyobj = 0;
18205
18206 {
18207 #if wxUSE_UNICODE
18208 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18209 #else
18210 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18211 #endif
18212 }
18213 return pyobj;
18214 }
18215
18216
18217 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
18218 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
18219 return 1;
18220 }
18221
18222
18223 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
18224 PyObject *pyobj = 0;
18225
18226 {
18227 #if wxUSE_UNICODE
18228 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18229 #else
18230 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18231 #endif
18232 }
18233 return pyobj;
18234 }
18235
18236
18237 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
18238 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
18239 return 1;
18240 }
18241
18242
18243 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
18244 PyObject *pyobj = 0;
18245
18246 {
18247 #if wxUSE_UNICODE
18248 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18249 #else
18250 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18251 #endif
18252 }
18253 return pyobj;
18254 }
18255
18256
18257 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
18258 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
18259 return 1;
18260 }
18261
18262
18263 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
18264 PyObject *pyobj = 0;
18265
18266 {
18267 #if wxUSE_UNICODE
18268 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18269 #else
18270 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18271 #endif
18272 }
18273 return pyobj;
18274 }
18275
18276
18277 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
18278 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
18279 return 1;
18280 }
18281
18282
18283 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
18284 PyObject *pyobj = 0;
18285
18286 {
18287 #if wxUSE_UNICODE
18288 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18289 #else
18290 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18291 #endif
18292 }
18293 return pyobj;
18294 }
18295
18296
18297 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
18298 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
18299 return 1;
18300 }
18301
18302
18303 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
18304 PyObject *pyobj = 0;
18305
18306 {
18307 #if wxUSE_UNICODE
18308 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18309 #else
18310 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18311 #endif
18312 }
18313 return pyobj;
18314 }
18315
18316
18317 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
18318 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
18319 return 1;
18320 }
18321
18322
18323 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
18324 PyObject *pyobj = 0;
18325
18326 {
18327 #if wxUSE_UNICODE
18328 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18329 #else
18330 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18331 #endif
18332 }
18333 return pyobj;
18334 }
18335
18336
18337 SWIGINTERN int ART_GO_UP_set(PyObject *) {
18338 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
18339 return 1;
18340 }
18341
18342
18343 SWIGINTERN PyObject *ART_GO_UP_get(void) {
18344 PyObject *pyobj = 0;
18345
18346 {
18347 #if wxUSE_UNICODE
18348 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18349 #else
18350 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18351 #endif
18352 }
18353 return pyobj;
18354 }
18355
18356
18357 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
18358 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
18359 return 1;
18360 }
18361
18362
18363 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
18364 PyObject *pyobj = 0;
18365
18366 {
18367 #if wxUSE_UNICODE
18368 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18369 #else
18370 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18371 #endif
18372 }
18373 return pyobj;
18374 }
18375
18376
18377 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
18378 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
18379 return 1;
18380 }
18381
18382
18383 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
18384 PyObject *pyobj = 0;
18385
18386 {
18387 #if wxUSE_UNICODE
18388 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18389 #else
18390 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18391 #endif
18392 }
18393 return pyobj;
18394 }
18395
18396
18397 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
18398 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
18399 return 1;
18400 }
18401
18402
18403 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
18404 PyObject *pyobj = 0;
18405
18406 {
18407 #if wxUSE_UNICODE
18408 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18409 #else
18410 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18411 #endif
18412 }
18413 return pyobj;
18414 }
18415
18416
18417 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
18418 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
18419 return 1;
18420 }
18421
18422
18423 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
18424 PyObject *pyobj = 0;
18425
18426 {
18427 #if wxUSE_UNICODE
18428 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18429 #else
18430 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18431 #endif
18432 }
18433 return pyobj;
18434 }
18435
18436
18437 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
18438 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
18439 return 1;
18440 }
18441
18442
18443 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
18444 PyObject *pyobj = 0;
18445
18446 {
18447 #if wxUSE_UNICODE
18448 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18449 #else
18450 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18451 #endif
18452 }
18453 return pyobj;
18454 }
18455
18456
18457 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
18458 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
18459 return 1;
18460 }
18461
18462
18463 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
18464 PyObject *pyobj = 0;
18465
18466 {
18467 #if wxUSE_UNICODE
18468 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18469 #else
18470 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18471 #endif
18472 }
18473 return pyobj;
18474 }
18475
18476
18477 SWIGINTERN int ART_PRINT_set(PyObject *) {
18478 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
18479 return 1;
18480 }
18481
18482
18483 SWIGINTERN PyObject *ART_PRINT_get(void) {
18484 PyObject *pyobj = 0;
18485
18486 {
18487 #if wxUSE_UNICODE
18488 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18489 #else
18490 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18491 #endif
18492 }
18493 return pyobj;
18494 }
18495
18496
18497 SWIGINTERN int ART_HELP_set(PyObject *) {
18498 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
18499 return 1;
18500 }
18501
18502
18503 SWIGINTERN PyObject *ART_HELP_get(void) {
18504 PyObject *pyobj = 0;
18505
18506 {
18507 #if wxUSE_UNICODE
18508 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18509 #else
18510 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18511 #endif
18512 }
18513 return pyobj;
18514 }
18515
18516
18517 SWIGINTERN int ART_TIP_set(PyObject *) {
18518 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
18519 return 1;
18520 }
18521
18522
18523 SWIGINTERN PyObject *ART_TIP_get(void) {
18524 PyObject *pyobj = 0;
18525
18526 {
18527 #if wxUSE_UNICODE
18528 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18529 #else
18530 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18531 #endif
18532 }
18533 return pyobj;
18534 }
18535
18536
18537 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
18538 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
18539 return 1;
18540 }
18541
18542
18543 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
18544 PyObject *pyobj = 0;
18545
18546 {
18547 #if wxUSE_UNICODE
18548 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18549 #else
18550 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18551 #endif
18552 }
18553 return pyobj;
18554 }
18555
18556
18557 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
18558 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
18559 return 1;
18560 }
18561
18562
18563 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
18564 PyObject *pyobj = 0;
18565
18566 {
18567 #if wxUSE_UNICODE
18568 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18569 #else
18570 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18571 #endif
18572 }
18573 return pyobj;
18574 }
18575
18576
18577 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
18578 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
18579 return 1;
18580 }
18581
18582
18583 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
18584 PyObject *pyobj = 0;
18585
18586 {
18587 #if wxUSE_UNICODE
18588 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18589 #else
18590 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18591 #endif
18592 }
18593 return pyobj;
18594 }
18595
18596
18597 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
18598 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
18599 return 1;
18600 }
18601
18602
18603 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
18604 PyObject *pyobj = 0;
18605
18606 {
18607 #if wxUSE_UNICODE
18608 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18609 #else
18610 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18611 #endif
18612 }
18613 return pyobj;
18614 }
18615
18616
18617 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
18618 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
18619 return 1;
18620 }
18621
18622
18623 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
18624 PyObject *pyobj = 0;
18625
18626 {
18627 #if wxUSE_UNICODE
18628 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18629 #else
18630 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18631 #endif
18632 }
18633 return pyobj;
18634 }
18635
18636
18637 SWIGINTERN int ART_CDROM_set(PyObject *) {
18638 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
18639 return 1;
18640 }
18641
18642
18643 SWIGINTERN PyObject *ART_CDROM_get(void) {
18644 PyObject *pyobj = 0;
18645
18646 {
18647 #if wxUSE_UNICODE
18648 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18649 #else
18650 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18651 #endif
18652 }
18653 return pyobj;
18654 }
18655
18656
18657 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
18658 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
18659 return 1;
18660 }
18661
18662
18663 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
18664 PyObject *pyobj = 0;
18665
18666 {
18667 #if wxUSE_UNICODE
18668 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18669 #else
18670 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18671 #endif
18672 }
18673 return pyobj;
18674 }
18675
18676
18677 SWIGINTERN int ART_FOLDER_set(PyObject *) {
18678 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
18679 return 1;
18680 }
18681
18682
18683 SWIGINTERN PyObject *ART_FOLDER_get(void) {
18684 PyObject *pyobj = 0;
18685
18686 {
18687 #if wxUSE_UNICODE
18688 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18689 #else
18690 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18691 #endif
18692 }
18693 return pyobj;
18694 }
18695
18696
18697 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
18698 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
18699 return 1;
18700 }
18701
18702
18703 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
18704 PyObject *pyobj = 0;
18705
18706 {
18707 #if wxUSE_UNICODE
18708 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18709 #else
18710 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18711 #endif
18712 }
18713 return pyobj;
18714 }
18715
18716
18717 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
18718 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
18719 return 1;
18720 }
18721
18722
18723 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
18724 PyObject *pyobj = 0;
18725
18726 {
18727 #if wxUSE_UNICODE
18728 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18729 #else
18730 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18731 #endif
18732 }
18733 return pyobj;
18734 }
18735
18736
18737 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
18738 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
18739 return 1;
18740 }
18741
18742
18743 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
18744 PyObject *pyobj = 0;
18745
18746 {
18747 #if wxUSE_UNICODE
18748 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18749 #else
18750 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18751 #endif
18752 }
18753 return pyobj;
18754 }
18755
18756
18757 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
18758 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
18759 return 1;
18760 }
18761
18762
18763 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
18764 PyObject *pyobj = 0;
18765
18766 {
18767 #if wxUSE_UNICODE
18768 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18769 #else
18770 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18771 #endif
18772 }
18773 return pyobj;
18774 }
18775
18776
18777 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
18778 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
18779 return 1;
18780 }
18781
18782
18783 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
18784 PyObject *pyobj = 0;
18785
18786 {
18787 #if wxUSE_UNICODE
18788 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18789 #else
18790 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18791 #endif
18792 }
18793 return pyobj;
18794 }
18795
18796
18797 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
18798 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
18799 return 1;
18800 }
18801
18802
18803 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
18804 PyObject *pyobj = 0;
18805
18806 {
18807 #if wxUSE_UNICODE
18808 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18809 #else
18810 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18811 #endif
18812 }
18813 return pyobj;
18814 }
18815
18816
18817 SWIGINTERN int ART_ERROR_set(PyObject *) {
18818 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
18819 return 1;
18820 }
18821
18822
18823 SWIGINTERN PyObject *ART_ERROR_get(void) {
18824 PyObject *pyobj = 0;
18825
18826 {
18827 #if wxUSE_UNICODE
18828 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18829 #else
18830 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18831 #endif
18832 }
18833 return pyobj;
18834 }
18835
18836
18837 SWIGINTERN int ART_QUESTION_set(PyObject *) {
18838 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
18839 return 1;
18840 }
18841
18842
18843 SWIGINTERN PyObject *ART_QUESTION_get(void) {
18844 PyObject *pyobj = 0;
18845
18846 {
18847 #if wxUSE_UNICODE
18848 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18849 #else
18850 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18851 #endif
18852 }
18853 return pyobj;
18854 }
18855
18856
18857 SWIGINTERN int ART_WARNING_set(PyObject *) {
18858 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
18859 return 1;
18860 }
18861
18862
18863 SWIGINTERN PyObject *ART_WARNING_get(void) {
18864 PyObject *pyobj = 0;
18865
18866 {
18867 #if wxUSE_UNICODE
18868 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18869 #else
18870 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18871 #endif
18872 }
18873 return pyobj;
18874 }
18875
18876
18877 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
18878 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
18879 return 1;
18880 }
18881
18882
18883 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
18884 PyObject *pyobj = 0;
18885
18886 {
18887 #if wxUSE_UNICODE
18888 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18889 #else
18890 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18891 #endif
18892 }
18893 return pyobj;
18894 }
18895
18896
18897 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
18898 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
18899 return 1;
18900 }
18901
18902
18903 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
18904 PyObject *pyobj = 0;
18905
18906 {
18907 #if wxUSE_UNICODE
18908 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18909 #else
18910 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18911 #endif
18912 }
18913 return pyobj;
18914 }
18915
18916
18917 SWIGINTERN int ART_COPY_set(PyObject *) {
18918 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
18919 return 1;
18920 }
18921
18922
18923 SWIGINTERN PyObject *ART_COPY_get(void) {
18924 PyObject *pyobj = 0;
18925
18926 {
18927 #if wxUSE_UNICODE
18928 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18929 #else
18930 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18931 #endif
18932 }
18933 return pyobj;
18934 }
18935
18936
18937 SWIGINTERN int ART_CUT_set(PyObject *) {
18938 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
18939 return 1;
18940 }
18941
18942
18943 SWIGINTERN PyObject *ART_CUT_get(void) {
18944 PyObject *pyobj = 0;
18945
18946 {
18947 #if wxUSE_UNICODE
18948 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18949 #else
18950 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18951 #endif
18952 }
18953 return pyobj;
18954 }
18955
18956
18957 SWIGINTERN int ART_PASTE_set(PyObject *) {
18958 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
18959 return 1;
18960 }
18961
18962
18963 SWIGINTERN PyObject *ART_PASTE_get(void) {
18964 PyObject *pyobj = 0;
18965
18966 {
18967 #if wxUSE_UNICODE
18968 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18969 #else
18970 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18971 #endif
18972 }
18973 return pyobj;
18974 }
18975
18976
18977 SWIGINTERN int ART_DELETE_set(PyObject *) {
18978 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
18979 return 1;
18980 }
18981
18982
18983 SWIGINTERN PyObject *ART_DELETE_get(void) {
18984 PyObject *pyobj = 0;
18985
18986 {
18987 #if wxUSE_UNICODE
18988 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
18989 #else
18990 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
18991 #endif
18992 }
18993 return pyobj;
18994 }
18995
18996
18997 SWIGINTERN int ART_NEW_set(PyObject *) {
18998 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
18999 return 1;
19000 }
19001
19002
19003 SWIGINTERN PyObject *ART_NEW_get(void) {
19004 PyObject *pyobj = 0;
19005
19006 {
19007 #if wxUSE_UNICODE
19008 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19009 #else
19010 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19011 #endif
19012 }
19013 return pyobj;
19014 }
19015
19016
19017 SWIGINTERN int ART_UNDO_set(PyObject *) {
19018 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
19019 return 1;
19020 }
19021
19022
19023 SWIGINTERN PyObject *ART_UNDO_get(void) {
19024 PyObject *pyobj = 0;
19025
19026 {
19027 #if wxUSE_UNICODE
19028 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19029 #else
19030 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19031 #endif
19032 }
19033 return pyobj;
19034 }
19035
19036
19037 SWIGINTERN int ART_REDO_set(PyObject *) {
19038 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
19039 return 1;
19040 }
19041
19042
19043 SWIGINTERN PyObject *ART_REDO_get(void) {
19044 PyObject *pyobj = 0;
19045
19046 {
19047 #if wxUSE_UNICODE
19048 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19049 #else
19050 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19051 #endif
19052 }
19053 return pyobj;
19054 }
19055
19056
19057 SWIGINTERN int ART_QUIT_set(PyObject *) {
19058 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
19059 return 1;
19060 }
19061
19062
19063 SWIGINTERN PyObject *ART_QUIT_get(void) {
19064 PyObject *pyobj = 0;
19065
19066 {
19067 #if wxUSE_UNICODE
19068 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19069 #else
19070 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19071 #endif
19072 }
19073 return pyobj;
19074 }
19075
19076
19077 SWIGINTERN int ART_FIND_set(PyObject *) {
19078 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
19079 return 1;
19080 }
19081
19082
19083 SWIGINTERN PyObject *ART_FIND_get(void) {
19084 PyObject *pyobj = 0;
19085
19086 {
19087 #if wxUSE_UNICODE
19088 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19089 #else
19090 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19091 #endif
19092 }
19093 return pyobj;
19094 }
19095
19096
19097 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
19098 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
19099 return 1;
19100 }
19101
19102
19103 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
19104 PyObject *pyobj = 0;
19105
19106 {
19107 #if wxUSE_UNICODE
19108 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19109 #else
19110 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19111 #endif
19112 }
19113 return pyobj;
19114 }
19115
19116
19117 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19118 PyObject *resultobj = 0;
19119 wxPyArtProvider *result = 0 ;
19120
19121 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
19122 {
19123 if (!wxPyCheckForApp()) SWIG_fail;
19124 PyThreadState* __tstate = wxPyBeginAllowThreads();
19125 result = (wxPyArtProvider *)new wxPyArtProvider();
19126 wxPyEndAllowThreads(__tstate);
19127 if (PyErr_Occurred()) SWIG_fail;
19128 }
19129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
19130 return resultobj;
19131 fail:
19132 return NULL;
19133 }
19134
19135
19136 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19137 PyObject *resultobj = 0;
19138 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19139 void *argp1 = 0 ;
19140 int res1 = 0 ;
19141 PyObject *swig_obj[1] ;
19142
19143 if (!args) SWIG_fail;
19144 swig_obj[0] = args;
19145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19146 if (!SWIG_IsOK(res1)) {
19147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19148 }
19149 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19150 {
19151 PyThreadState* __tstate = wxPyBeginAllowThreads();
19152 delete arg1;
19153
19154 wxPyEndAllowThreads(__tstate);
19155 if (PyErr_Occurred()) SWIG_fail;
19156 }
19157 resultobj = SWIG_Py_Void();
19158 return resultobj;
19159 fail:
19160 return NULL;
19161 }
19162
19163
19164 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19165 PyObject *resultobj = 0;
19166 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19167 PyObject *arg2 = (PyObject *) 0 ;
19168 PyObject *arg3 = (PyObject *) 0 ;
19169 void *argp1 = 0 ;
19170 int res1 = 0 ;
19171 PyObject * obj0 = 0 ;
19172 PyObject * obj1 = 0 ;
19173 PyObject * obj2 = 0 ;
19174 char * kwnames[] = {
19175 (char *) "self",(char *) "self",(char *) "_class", NULL
19176 };
19177
19178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19180 if (!SWIG_IsOK(res1)) {
19181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19182 }
19183 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19184 arg2 = obj1;
19185 arg3 = obj2;
19186 {
19187 PyThreadState* __tstate = wxPyBeginAllowThreads();
19188 (arg1)->_setCallbackInfo(arg2,arg3);
19189 wxPyEndAllowThreads(__tstate);
19190 if (PyErr_Occurred()) SWIG_fail;
19191 }
19192 resultobj = SWIG_Py_Void();
19193 return resultobj;
19194 fail:
19195 return NULL;
19196 }
19197
19198
19199 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19200 PyObject *resultobj = 0;
19201 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19202 int res1 = 0 ;
19203 PyObject * obj0 = 0 ;
19204 char * kwnames[] = {
19205 (char *) "provider", NULL
19206 };
19207
19208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
19209 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19210 if (!SWIG_IsOK(res1)) {
19211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19212 }
19213 {
19214 PyThreadState* __tstate = wxPyBeginAllowThreads();
19215 wxPyArtProvider::PushProvider(arg1);
19216 wxPyEndAllowThreads(__tstate);
19217 if (PyErr_Occurred()) SWIG_fail;
19218 }
19219 resultobj = SWIG_Py_Void();
19220 return resultobj;
19221 fail:
19222 return NULL;
19223 }
19224
19225
19226 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19227 PyObject *resultobj = 0;
19228 bool result;
19229
19230 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
19231 {
19232 PyThreadState* __tstate = wxPyBeginAllowThreads();
19233 result = (bool)wxPyArtProvider::PopProvider();
19234 wxPyEndAllowThreads(__tstate);
19235 if (PyErr_Occurred()) SWIG_fail;
19236 }
19237 {
19238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19239 }
19240 return resultobj;
19241 fail:
19242 return NULL;
19243 }
19244
19245
19246 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19247 PyObject *resultobj = 0;
19248 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19249 bool result;
19250 void *argp1 = 0 ;
19251 int res1 = 0 ;
19252 PyObject * obj0 = 0 ;
19253 char * kwnames[] = {
19254 (char *) "provider", NULL
19255 };
19256
19257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
19258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19259 if (!SWIG_IsOK(res1)) {
19260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19261 }
19262 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19263 {
19264 PyThreadState* __tstate = wxPyBeginAllowThreads();
19265 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
19266 wxPyEndAllowThreads(__tstate);
19267 if (PyErr_Occurred()) SWIG_fail;
19268 }
19269 {
19270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19271 }
19272 return resultobj;
19273 fail:
19274 return NULL;
19275 }
19276
19277
19278 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19279 PyObject *resultobj = 0;
19280 wxString *arg1 = 0 ;
19281 wxString const &arg2_defvalue = wxPyART_OTHER ;
19282 wxString *arg2 = (wxString *) &arg2_defvalue ;
19283 wxSize const &arg3_defvalue = wxDefaultSize ;
19284 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19285 wxBitmap result;
19286 bool temp1 = false ;
19287 bool temp2 = false ;
19288 wxSize temp3 ;
19289 PyObject * obj0 = 0 ;
19290 PyObject * obj1 = 0 ;
19291 PyObject * obj2 = 0 ;
19292 char * kwnames[] = {
19293 (char *) "id",(char *) "client",(char *) "size", NULL
19294 };
19295
19296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19297 {
19298 arg1 = wxString_in_helper(obj0);
19299 if (arg1 == NULL) SWIG_fail;
19300 temp1 = true;
19301 }
19302 if (obj1) {
19303 {
19304 arg2 = wxString_in_helper(obj1);
19305 if (arg2 == NULL) SWIG_fail;
19306 temp2 = true;
19307 }
19308 }
19309 if (obj2) {
19310 {
19311 arg3 = &temp3;
19312 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19313 }
19314 }
19315 {
19316 if (!wxPyCheckForApp()) SWIG_fail;
19317 PyThreadState* __tstate = wxPyBeginAllowThreads();
19318 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19319 wxPyEndAllowThreads(__tstate);
19320 if (PyErr_Occurred()) SWIG_fail;
19321 }
19322 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19323 {
19324 if (temp1)
19325 delete arg1;
19326 }
19327 {
19328 if (temp2)
19329 delete arg2;
19330 }
19331 return resultobj;
19332 fail:
19333 {
19334 if (temp1)
19335 delete arg1;
19336 }
19337 {
19338 if (temp2)
19339 delete arg2;
19340 }
19341 return NULL;
19342 }
19343
19344
19345 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19346 PyObject *resultobj = 0;
19347 wxString *arg1 = 0 ;
19348 wxString const &arg2_defvalue = wxPyART_OTHER ;
19349 wxString *arg2 = (wxString *) &arg2_defvalue ;
19350 wxSize const &arg3_defvalue = wxDefaultSize ;
19351 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19352 wxIcon result;
19353 bool temp1 = false ;
19354 bool temp2 = false ;
19355 wxSize temp3 ;
19356 PyObject * obj0 = 0 ;
19357 PyObject * obj1 = 0 ;
19358 PyObject * obj2 = 0 ;
19359 char * kwnames[] = {
19360 (char *) "id",(char *) "client",(char *) "size", NULL
19361 };
19362
19363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19364 {
19365 arg1 = wxString_in_helper(obj0);
19366 if (arg1 == NULL) SWIG_fail;
19367 temp1 = true;
19368 }
19369 if (obj1) {
19370 {
19371 arg2 = wxString_in_helper(obj1);
19372 if (arg2 == NULL) SWIG_fail;
19373 temp2 = true;
19374 }
19375 }
19376 if (obj2) {
19377 {
19378 arg3 = &temp3;
19379 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19380 }
19381 }
19382 {
19383 if (!wxPyCheckForApp()) SWIG_fail;
19384 PyThreadState* __tstate = wxPyBeginAllowThreads();
19385 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19386 wxPyEndAllowThreads(__tstate);
19387 if (PyErr_Occurred()) SWIG_fail;
19388 }
19389 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
19390 {
19391 if (temp1)
19392 delete arg1;
19393 }
19394 {
19395 if (temp2)
19396 delete arg2;
19397 }
19398 return resultobj;
19399 fail:
19400 {
19401 if (temp1)
19402 delete arg1;
19403 }
19404 {
19405 if (temp2)
19406 delete arg2;
19407 }
19408 return NULL;
19409 }
19410
19411
19412 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19413 PyObject *resultobj = 0;
19414 wxString *arg1 = 0 ;
19415 bool arg2 = (bool) false ;
19416 wxSize result;
19417 bool temp1 = false ;
19418 bool val2 ;
19419 int ecode2 = 0 ;
19420 PyObject * obj0 = 0 ;
19421 PyObject * obj1 = 0 ;
19422 char * kwnames[] = {
19423 (char *) "client",(char *) "platform_dependent", NULL
19424 };
19425
19426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
19427 {
19428 arg1 = wxString_in_helper(obj0);
19429 if (arg1 == NULL) SWIG_fail;
19430 temp1 = true;
19431 }
19432 if (obj1) {
19433 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19434 if (!SWIG_IsOK(ecode2)) {
19435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
19436 }
19437 arg2 = static_cast< bool >(val2);
19438 }
19439 {
19440 PyThreadState* __tstate = wxPyBeginAllowThreads();
19441 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
19442 wxPyEndAllowThreads(__tstate);
19443 if (PyErr_Occurred()) SWIG_fail;
19444 }
19445 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
19446 {
19447 if (temp1)
19448 delete arg1;
19449 }
19450 return resultobj;
19451 fail:
19452 {
19453 if (temp1)
19454 delete arg1;
19455 }
19456 return NULL;
19457 }
19458
19459
19460 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19461 PyObject *resultobj = 0;
19462 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19463 void *argp1 = 0 ;
19464 int res1 = 0 ;
19465 PyObject *swig_obj[1] ;
19466
19467 if (!args) SWIG_fail;
19468 swig_obj[0] = args;
19469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19470 if (!SWIG_IsOK(res1)) {
19471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19472 }
19473 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19474 {
19475 PyThreadState* __tstate = wxPyBeginAllowThreads();
19476 wxPyArtProvider_Destroy(arg1);
19477 wxPyEndAllowThreads(__tstate);
19478 if (PyErr_Occurred()) SWIG_fail;
19479 }
19480 resultobj = SWIG_Py_Void();
19481 return resultobj;
19482 fail:
19483 return NULL;
19484 }
19485
19486
19487 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19488 PyObject *obj;
19489 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19490 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
19491 return SWIG_Py_Void();
19492 }
19493
19494 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19495 return SWIG_Python_InitShadowInstance(args);
19496 }
19497
19498 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19499 PyObject *resultobj = 0;
19500 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19501 void *argp1 = 0 ;
19502 int res1 = 0 ;
19503 PyObject *swig_obj[1] ;
19504
19505 if (!args) SWIG_fail;
19506 swig_obj[0] = args;
19507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19508 if (!SWIG_IsOK(res1)) {
19509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19510 }
19511 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19512 {
19513 PyThreadState* __tstate = wxPyBeginAllowThreads();
19514 delete arg1;
19515
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 *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19527 PyObject *resultobj = 0;
19528 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19529 wxConfigBase *result = 0 ;
19530 int res1 = 0 ;
19531 PyObject * obj0 = 0 ;
19532 char * kwnames[] = {
19533 (char *) "config", NULL
19534 };
19535
19536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
19537 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19538 if (!SWIG_IsOK(res1)) {
19539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19540 }
19541 {
19542 PyThreadState* __tstate = wxPyBeginAllowThreads();
19543 result = (wxConfigBase *)wxConfigBase::Set(arg1);
19544 wxPyEndAllowThreads(__tstate);
19545 if (PyErr_Occurred()) SWIG_fail;
19546 }
19547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19548 return resultobj;
19549 fail:
19550 return NULL;
19551 }
19552
19553
19554 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19555 PyObject *resultobj = 0;
19556 bool arg1 = (bool) true ;
19557 wxConfigBase *result = 0 ;
19558 bool val1 ;
19559 int ecode1 = 0 ;
19560 PyObject * obj0 = 0 ;
19561 char * kwnames[] = {
19562 (char *) "createOnDemand", NULL
19563 };
19564
19565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
19566 if (obj0) {
19567 ecode1 = SWIG_AsVal_bool(obj0, &val1);
19568 if (!SWIG_IsOK(ecode1)) {
19569 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
19570 }
19571 arg1 = static_cast< bool >(val1);
19572 }
19573 {
19574 PyThreadState* __tstate = wxPyBeginAllowThreads();
19575 result = (wxConfigBase *)wxConfigBase::Get(arg1);
19576 wxPyEndAllowThreads(__tstate);
19577 if (PyErr_Occurred()) SWIG_fail;
19578 }
19579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19580 return resultobj;
19581 fail:
19582 return NULL;
19583 }
19584
19585
19586 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19587 PyObject *resultobj = 0;
19588 wxConfigBase *result = 0 ;
19589
19590 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
19591 {
19592 PyThreadState* __tstate = wxPyBeginAllowThreads();
19593 result = (wxConfigBase *)wxConfigBase::Create();
19594 wxPyEndAllowThreads(__tstate);
19595 if (PyErr_Occurred()) SWIG_fail;
19596 }
19597 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19598 return resultobj;
19599 fail:
19600 return NULL;
19601 }
19602
19603
19604 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19605 PyObject *resultobj = 0;
19606
19607 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
19608 {
19609 PyThreadState* __tstate = wxPyBeginAllowThreads();
19610 wxConfigBase::DontCreateOnDemand();
19611 wxPyEndAllowThreads(__tstate);
19612 if (PyErr_Occurred()) SWIG_fail;
19613 }
19614 resultobj = SWIG_Py_Void();
19615 return resultobj;
19616 fail:
19617 return NULL;
19618 }
19619
19620
19621 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19622 PyObject *resultobj = 0;
19623 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19624 wxString *arg2 = 0 ;
19625 void *argp1 = 0 ;
19626 int res1 = 0 ;
19627 bool temp2 = false ;
19628 PyObject * obj0 = 0 ;
19629 PyObject * obj1 = 0 ;
19630 char * kwnames[] = {
19631 (char *) "self",(char *) "path", NULL
19632 };
19633
19634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
19635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19636 if (!SWIG_IsOK(res1)) {
19637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19638 }
19639 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19640 {
19641 arg2 = wxString_in_helper(obj1);
19642 if (arg2 == NULL) SWIG_fail;
19643 temp2 = true;
19644 }
19645 {
19646 PyThreadState* __tstate = wxPyBeginAllowThreads();
19647 (arg1)->SetPath((wxString const &)*arg2);
19648 wxPyEndAllowThreads(__tstate);
19649 if (PyErr_Occurred()) SWIG_fail;
19650 }
19651 resultobj = SWIG_Py_Void();
19652 {
19653 if (temp2)
19654 delete arg2;
19655 }
19656 return resultobj;
19657 fail:
19658 {
19659 if (temp2)
19660 delete arg2;
19661 }
19662 return NULL;
19663 }
19664
19665
19666 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19667 PyObject *resultobj = 0;
19668 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19669 wxString *result = 0 ;
19670 void *argp1 = 0 ;
19671 int res1 = 0 ;
19672 PyObject *swig_obj[1] ;
19673
19674 if (!args) SWIG_fail;
19675 swig_obj[0] = args;
19676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19677 if (!SWIG_IsOK(res1)) {
19678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19679 }
19680 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19681 {
19682 PyThreadState* __tstate = wxPyBeginAllowThreads();
19683 {
19684 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
19685 result = (wxString *) &_result_ref;
19686 }
19687 wxPyEndAllowThreads(__tstate);
19688 if (PyErr_Occurred()) SWIG_fail;
19689 }
19690 {
19691 #if wxUSE_UNICODE
19692 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19693 #else
19694 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19695 #endif
19696 }
19697 return resultobj;
19698 fail:
19699 return NULL;
19700 }
19701
19702
19703 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19704 PyObject *resultobj = 0;
19705 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19706 PyObject *result = 0 ;
19707 void *argp1 = 0 ;
19708 int res1 = 0 ;
19709 PyObject *swig_obj[1] ;
19710
19711 if (!args) SWIG_fail;
19712 swig_obj[0] = args;
19713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19714 if (!SWIG_IsOK(res1)) {
19715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19716 }
19717 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19718 {
19719 PyThreadState* __tstate = wxPyBeginAllowThreads();
19720 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
19721 wxPyEndAllowThreads(__tstate);
19722 if (PyErr_Occurred()) SWIG_fail;
19723 }
19724 resultobj = result;
19725 return resultobj;
19726 fail:
19727 return NULL;
19728 }
19729
19730
19731 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19732 PyObject *resultobj = 0;
19733 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19734 long arg2 ;
19735 PyObject *result = 0 ;
19736 void *argp1 = 0 ;
19737 int res1 = 0 ;
19738 long val2 ;
19739 int ecode2 = 0 ;
19740 PyObject * obj0 = 0 ;
19741 PyObject * obj1 = 0 ;
19742 char * kwnames[] = {
19743 (char *) "self",(char *) "index", NULL
19744 };
19745
19746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19748 if (!SWIG_IsOK(res1)) {
19749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19750 }
19751 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19752 ecode2 = SWIG_AsVal_long(obj1, &val2);
19753 if (!SWIG_IsOK(ecode2)) {
19754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
19755 }
19756 arg2 = static_cast< long >(val2);
19757 {
19758 PyThreadState* __tstate = wxPyBeginAllowThreads();
19759 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
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_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19771 PyObject *resultobj = 0;
19772 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19773 PyObject *result = 0 ;
19774 void *argp1 = 0 ;
19775 int res1 = 0 ;
19776 PyObject *swig_obj[1] ;
19777
19778 if (!args) SWIG_fail;
19779 swig_obj[0] = args;
19780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19781 if (!SWIG_IsOK(res1)) {
19782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19783 }
19784 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19785 {
19786 PyThreadState* __tstate = wxPyBeginAllowThreads();
19787 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
19788 wxPyEndAllowThreads(__tstate);
19789 if (PyErr_Occurred()) SWIG_fail;
19790 }
19791 resultobj = result;
19792 return resultobj;
19793 fail:
19794 return NULL;
19795 }
19796
19797
19798 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19799 PyObject *resultobj = 0;
19800 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19801 long arg2 ;
19802 PyObject *result = 0 ;
19803 void *argp1 = 0 ;
19804 int res1 = 0 ;
19805 long val2 ;
19806 int ecode2 = 0 ;
19807 PyObject * obj0 = 0 ;
19808 PyObject * obj1 = 0 ;
19809 char * kwnames[] = {
19810 (char *) "self",(char *) "index", NULL
19811 };
19812
19813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19815 if (!SWIG_IsOK(res1)) {
19816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19817 }
19818 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19819 ecode2 = SWIG_AsVal_long(obj1, &val2);
19820 if (!SWIG_IsOK(ecode2)) {
19821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
19822 }
19823 arg2 = static_cast< long >(val2);
19824 {
19825 PyThreadState* __tstate = wxPyBeginAllowThreads();
19826 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
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_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19838 PyObject *resultobj = 0;
19839 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19840 bool arg2 = (bool) false ;
19841 size_t result;
19842 void *argp1 = 0 ;
19843 int res1 = 0 ;
19844 bool val2 ;
19845 int ecode2 = 0 ;
19846 PyObject * obj0 = 0 ;
19847 PyObject * obj1 = 0 ;
19848 char * kwnames[] = {
19849 (char *) "self",(char *) "recursive", NULL
19850 };
19851
19852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",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_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19856 }
19857 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19858 if (obj1) {
19859 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19860 if (!SWIG_IsOK(ecode2)) {
19861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
19862 }
19863 arg2 = static_cast< bool >(val2);
19864 }
19865 {
19866 PyThreadState* __tstate = wxPyBeginAllowThreads();
19867 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
19868 wxPyEndAllowThreads(__tstate);
19869 if (PyErr_Occurred()) SWIG_fail;
19870 }
19871 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19872 return resultobj;
19873 fail:
19874 return NULL;
19875 }
19876
19877
19878 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19879 PyObject *resultobj = 0;
19880 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19881 bool arg2 = (bool) false ;
19882 size_t result;
19883 void *argp1 = 0 ;
19884 int res1 = 0 ;
19885 bool val2 ;
19886 int ecode2 = 0 ;
19887 PyObject * obj0 = 0 ;
19888 PyObject * obj1 = 0 ;
19889 char * kwnames[] = {
19890 (char *) "self",(char *) "recursive", NULL
19891 };
19892
19893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
19894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19895 if (!SWIG_IsOK(res1)) {
19896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19897 }
19898 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19899 if (obj1) {
19900 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19901 if (!SWIG_IsOK(ecode2)) {
19902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
19903 }
19904 arg2 = static_cast< bool >(val2);
19905 }
19906 {
19907 PyThreadState* __tstate = wxPyBeginAllowThreads();
19908 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
19909 wxPyEndAllowThreads(__tstate);
19910 if (PyErr_Occurred()) SWIG_fail;
19911 }
19912 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19913 return resultobj;
19914 fail:
19915 return NULL;
19916 }
19917
19918
19919 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19920 PyObject *resultobj = 0;
19921 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19922 wxString *arg2 = 0 ;
19923 bool result;
19924 void *argp1 = 0 ;
19925 int res1 = 0 ;
19926 bool temp2 = false ;
19927 PyObject * obj0 = 0 ;
19928 PyObject * obj1 = 0 ;
19929 char * kwnames[] = {
19930 (char *) "self",(char *) "name", NULL
19931 };
19932
19933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19935 if (!SWIG_IsOK(res1)) {
19936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19937 }
19938 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19939 {
19940 arg2 = wxString_in_helper(obj1);
19941 if (arg2 == NULL) SWIG_fail;
19942 temp2 = true;
19943 }
19944 {
19945 PyThreadState* __tstate = wxPyBeginAllowThreads();
19946 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
19947 wxPyEndAllowThreads(__tstate);
19948 if (PyErr_Occurred()) SWIG_fail;
19949 }
19950 {
19951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19952 }
19953 {
19954 if (temp2)
19955 delete arg2;
19956 }
19957 return resultobj;
19958 fail:
19959 {
19960 if (temp2)
19961 delete arg2;
19962 }
19963 return NULL;
19964 }
19965
19966
19967 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19968 PyObject *resultobj = 0;
19969 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19970 wxString *arg2 = 0 ;
19971 bool result;
19972 void *argp1 = 0 ;
19973 int res1 = 0 ;
19974 bool temp2 = false ;
19975 PyObject * obj0 = 0 ;
19976 PyObject * obj1 = 0 ;
19977 char * kwnames[] = {
19978 (char *) "self",(char *) "name", NULL
19979 };
19980
19981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19983 if (!SWIG_IsOK(res1)) {
19984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19985 }
19986 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19987 {
19988 arg2 = wxString_in_helper(obj1);
19989 if (arg2 == NULL) SWIG_fail;
19990 temp2 = true;
19991 }
19992 {
19993 PyThreadState* __tstate = wxPyBeginAllowThreads();
19994 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
19995 wxPyEndAllowThreads(__tstate);
19996 if (PyErr_Occurred()) SWIG_fail;
19997 }
19998 {
19999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20000 }
20001 {
20002 if (temp2)
20003 delete arg2;
20004 }
20005 return resultobj;
20006 fail:
20007 {
20008 if (temp2)
20009 delete arg2;
20010 }
20011 return NULL;
20012 }
20013
20014
20015 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20016 PyObject *resultobj = 0;
20017 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20018 wxString *arg2 = 0 ;
20019 bool result;
20020 void *argp1 = 0 ;
20021 int res1 = 0 ;
20022 bool temp2 = false ;
20023 PyObject * obj0 = 0 ;
20024 PyObject * obj1 = 0 ;
20025 char * kwnames[] = {
20026 (char *) "self",(char *) "name", NULL
20027 };
20028
20029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
20030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20031 if (!SWIG_IsOK(res1)) {
20032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20033 }
20034 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20035 {
20036 arg2 = wxString_in_helper(obj1);
20037 if (arg2 == NULL) SWIG_fail;
20038 temp2 = true;
20039 }
20040 {
20041 PyThreadState* __tstate = wxPyBeginAllowThreads();
20042 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
20043 wxPyEndAllowThreads(__tstate);
20044 if (PyErr_Occurred()) SWIG_fail;
20045 }
20046 {
20047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20048 }
20049 {
20050 if (temp2)
20051 delete arg2;
20052 }
20053 return resultobj;
20054 fail:
20055 {
20056 if (temp2)
20057 delete arg2;
20058 }
20059 return NULL;
20060 }
20061
20062
20063 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20064 PyObject *resultobj = 0;
20065 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20066 wxString *arg2 = 0 ;
20067 wxConfigBase::EntryType result;
20068 void *argp1 = 0 ;
20069 int res1 = 0 ;
20070 bool temp2 = false ;
20071 PyObject * obj0 = 0 ;
20072 PyObject * obj1 = 0 ;
20073 char * kwnames[] = {
20074 (char *) "self",(char *) "name", NULL
20075 };
20076
20077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
20078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20079 if (!SWIG_IsOK(res1)) {
20080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20081 }
20082 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20083 {
20084 arg2 = wxString_in_helper(obj1);
20085 if (arg2 == NULL) SWIG_fail;
20086 temp2 = true;
20087 }
20088 {
20089 PyThreadState* __tstate = wxPyBeginAllowThreads();
20090 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
20091 wxPyEndAllowThreads(__tstate);
20092 if (PyErr_Occurred()) SWIG_fail;
20093 }
20094 resultobj = SWIG_From_int(static_cast< int >(result));
20095 {
20096 if (temp2)
20097 delete arg2;
20098 }
20099 return resultobj;
20100 fail:
20101 {
20102 if (temp2)
20103 delete arg2;
20104 }
20105 return NULL;
20106 }
20107
20108
20109 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20110 PyObject *resultobj = 0;
20111 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20112 wxString *arg2 = 0 ;
20113 wxString const &arg3_defvalue = wxPyEmptyString ;
20114 wxString *arg3 = (wxString *) &arg3_defvalue ;
20115 wxString result;
20116 void *argp1 = 0 ;
20117 int res1 = 0 ;
20118 bool temp2 = false ;
20119 bool temp3 = false ;
20120 PyObject * obj0 = 0 ;
20121 PyObject * obj1 = 0 ;
20122 PyObject * obj2 = 0 ;
20123 char * kwnames[] = {
20124 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20125 };
20126
20127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20129 if (!SWIG_IsOK(res1)) {
20130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20131 }
20132 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20133 {
20134 arg2 = wxString_in_helper(obj1);
20135 if (arg2 == NULL) SWIG_fail;
20136 temp2 = true;
20137 }
20138 if (obj2) {
20139 {
20140 arg3 = wxString_in_helper(obj2);
20141 if (arg3 == NULL) SWIG_fail;
20142 temp3 = true;
20143 }
20144 }
20145 {
20146 PyThreadState* __tstate = wxPyBeginAllowThreads();
20147 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
20148 wxPyEndAllowThreads(__tstate);
20149 if (PyErr_Occurred()) SWIG_fail;
20150 }
20151 {
20152 #if wxUSE_UNICODE
20153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20154 #else
20155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20156 #endif
20157 }
20158 {
20159 if (temp2)
20160 delete arg2;
20161 }
20162 {
20163 if (temp3)
20164 delete arg3;
20165 }
20166 return resultobj;
20167 fail:
20168 {
20169 if (temp2)
20170 delete arg2;
20171 }
20172 {
20173 if (temp3)
20174 delete arg3;
20175 }
20176 return NULL;
20177 }
20178
20179
20180 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20181 PyObject *resultobj = 0;
20182 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20183 wxString *arg2 = 0 ;
20184 long arg3 = (long) 0 ;
20185 long result;
20186 void *argp1 = 0 ;
20187 int res1 = 0 ;
20188 bool temp2 = false ;
20189 long val3 ;
20190 int ecode3 = 0 ;
20191 PyObject * obj0 = 0 ;
20192 PyObject * obj1 = 0 ;
20193 PyObject * obj2 = 0 ;
20194 char * kwnames[] = {
20195 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20196 };
20197
20198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20200 if (!SWIG_IsOK(res1)) {
20201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20202 }
20203 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20204 {
20205 arg2 = wxString_in_helper(obj1);
20206 if (arg2 == NULL) SWIG_fail;
20207 temp2 = true;
20208 }
20209 if (obj2) {
20210 ecode3 = SWIG_AsVal_long(obj2, &val3);
20211 if (!SWIG_IsOK(ecode3)) {
20212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
20213 }
20214 arg3 = static_cast< long >(val3);
20215 }
20216 {
20217 PyThreadState* __tstate = wxPyBeginAllowThreads();
20218 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
20219 wxPyEndAllowThreads(__tstate);
20220 if (PyErr_Occurred()) SWIG_fail;
20221 }
20222 resultobj = SWIG_From_long(static_cast< long >(result));
20223 {
20224 if (temp2)
20225 delete arg2;
20226 }
20227 return resultobj;
20228 fail:
20229 {
20230 if (temp2)
20231 delete arg2;
20232 }
20233 return NULL;
20234 }
20235
20236
20237 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20238 PyObject *resultobj = 0;
20239 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20240 wxString *arg2 = 0 ;
20241 double arg3 = (double) 0.0 ;
20242 double result;
20243 void *argp1 = 0 ;
20244 int res1 = 0 ;
20245 bool temp2 = false ;
20246 double val3 ;
20247 int ecode3 = 0 ;
20248 PyObject * obj0 = 0 ;
20249 PyObject * obj1 = 0 ;
20250 PyObject * obj2 = 0 ;
20251 char * kwnames[] = {
20252 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20253 };
20254
20255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20257 if (!SWIG_IsOK(res1)) {
20258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20259 }
20260 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20261 {
20262 arg2 = wxString_in_helper(obj1);
20263 if (arg2 == NULL) SWIG_fail;
20264 temp2 = true;
20265 }
20266 if (obj2) {
20267 ecode3 = SWIG_AsVal_double(obj2, &val3);
20268 if (!SWIG_IsOK(ecode3)) {
20269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
20270 }
20271 arg3 = static_cast< double >(val3);
20272 }
20273 {
20274 PyThreadState* __tstate = wxPyBeginAllowThreads();
20275 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
20276 wxPyEndAllowThreads(__tstate);
20277 if (PyErr_Occurred()) SWIG_fail;
20278 }
20279 resultobj = SWIG_From_double(static_cast< double >(result));
20280 {
20281 if (temp2)
20282 delete arg2;
20283 }
20284 return resultobj;
20285 fail:
20286 {
20287 if (temp2)
20288 delete arg2;
20289 }
20290 return NULL;
20291 }
20292
20293
20294 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20295 PyObject *resultobj = 0;
20296 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20297 wxString *arg2 = 0 ;
20298 bool arg3 = (bool) false ;
20299 bool result;
20300 void *argp1 = 0 ;
20301 int res1 = 0 ;
20302 bool temp2 = false ;
20303 bool val3 ;
20304 int ecode3 = 0 ;
20305 PyObject * obj0 = 0 ;
20306 PyObject * obj1 = 0 ;
20307 PyObject * obj2 = 0 ;
20308 char * kwnames[] = {
20309 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20310 };
20311
20312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20314 if (!SWIG_IsOK(res1)) {
20315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20316 }
20317 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20318 {
20319 arg2 = wxString_in_helper(obj1);
20320 if (arg2 == NULL) SWIG_fail;
20321 temp2 = true;
20322 }
20323 if (obj2) {
20324 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20325 if (!SWIG_IsOK(ecode3)) {
20326 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
20327 }
20328 arg3 = static_cast< bool >(val3);
20329 }
20330 {
20331 PyThreadState* __tstate = wxPyBeginAllowThreads();
20332 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
20333 wxPyEndAllowThreads(__tstate);
20334 if (PyErr_Occurred()) SWIG_fail;
20335 }
20336 {
20337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20338 }
20339 {
20340 if (temp2)
20341 delete arg2;
20342 }
20343 return resultobj;
20344 fail:
20345 {
20346 if (temp2)
20347 delete arg2;
20348 }
20349 return NULL;
20350 }
20351
20352
20353 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20354 PyObject *resultobj = 0;
20355 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20356 wxString *arg2 = 0 ;
20357 wxString *arg3 = 0 ;
20358 bool result;
20359 void *argp1 = 0 ;
20360 int res1 = 0 ;
20361 bool temp2 = false ;
20362 bool temp3 = false ;
20363 PyObject * obj0 = 0 ;
20364 PyObject * obj1 = 0 ;
20365 PyObject * obj2 = 0 ;
20366 char * kwnames[] = {
20367 (char *) "self",(char *) "key",(char *) "value", NULL
20368 };
20369
20370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20372 if (!SWIG_IsOK(res1)) {
20373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20374 }
20375 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20376 {
20377 arg2 = wxString_in_helper(obj1);
20378 if (arg2 == NULL) SWIG_fail;
20379 temp2 = true;
20380 }
20381 {
20382 arg3 = wxString_in_helper(obj2);
20383 if (arg3 == NULL) SWIG_fail;
20384 temp3 = true;
20385 }
20386 {
20387 PyThreadState* __tstate = wxPyBeginAllowThreads();
20388 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
20389 wxPyEndAllowThreads(__tstate);
20390 if (PyErr_Occurred()) SWIG_fail;
20391 }
20392 {
20393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20394 }
20395 {
20396 if (temp2)
20397 delete arg2;
20398 }
20399 {
20400 if (temp3)
20401 delete arg3;
20402 }
20403 return resultobj;
20404 fail:
20405 {
20406 if (temp2)
20407 delete arg2;
20408 }
20409 {
20410 if (temp3)
20411 delete arg3;
20412 }
20413 return NULL;
20414 }
20415
20416
20417 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20418 PyObject *resultobj = 0;
20419 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20420 wxString *arg2 = 0 ;
20421 long arg3 ;
20422 bool result;
20423 void *argp1 = 0 ;
20424 int res1 = 0 ;
20425 bool temp2 = false ;
20426 long val3 ;
20427 int ecode3 = 0 ;
20428 PyObject * obj0 = 0 ;
20429 PyObject * obj1 = 0 ;
20430 PyObject * obj2 = 0 ;
20431 char * kwnames[] = {
20432 (char *) "self",(char *) "key",(char *) "value", NULL
20433 };
20434
20435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20437 if (!SWIG_IsOK(res1)) {
20438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20439 }
20440 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20441 {
20442 arg2 = wxString_in_helper(obj1);
20443 if (arg2 == NULL) SWIG_fail;
20444 temp2 = true;
20445 }
20446 ecode3 = SWIG_AsVal_long(obj2, &val3);
20447 if (!SWIG_IsOK(ecode3)) {
20448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
20449 }
20450 arg3 = static_cast< long >(val3);
20451 {
20452 PyThreadState* __tstate = wxPyBeginAllowThreads();
20453 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20454 wxPyEndAllowThreads(__tstate);
20455 if (PyErr_Occurred()) SWIG_fail;
20456 }
20457 {
20458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20459 }
20460 {
20461 if (temp2)
20462 delete arg2;
20463 }
20464 return resultobj;
20465 fail:
20466 {
20467 if (temp2)
20468 delete arg2;
20469 }
20470 return NULL;
20471 }
20472
20473
20474 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20475 PyObject *resultobj = 0;
20476 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20477 wxString *arg2 = 0 ;
20478 double arg3 ;
20479 bool result;
20480 void *argp1 = 0 ;
20481 int res1 = 0 ;
20482 bool temp2 = false ;
20483 double val3 ;
20484 int ecode3 = 0 ;
20485 PyObject * obj0 = 0 ;
20486 PyObject * obj1 = 0 ;
20487 PyObject * obj2 = 0 ;
20488 char * kwnames[] = {
20489 (char *) "self",(char *) "key",(char *) "value", NULL
20490 };
20491
20492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20494 if (!SWIG_IsOK(res1)) {
20495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20496 }
20497 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20498 {
20499 arg2 = wxString_in_helper(obj1);
20500 if (arg2 == NULL) SWIG_fail;
20501 temp2 = true;
20502 }
20503 ecode3 = SWIG_AsVal_double(obj2, &val3);
20504 if (!SWIG_IsOK(ecode3)) {
20505 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
20506 }
20507 arg3 = static_cast< double >(val3);
20508 {
20509 PyThreadState* __tstate = wxPyBeginAllowThreads();
20510 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20511 wxPyEndAllowThreads(__tstate);
20512 if (PyErr_Occurred()) SWIG_fail;
20513 }
20514 {
20515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20516 }
20517 {
20518 if (temp2)
20519 delete arg2;
20520 }
20521 return resultobj;
20522 fail:
20523 {
20524 if (temp2)
20525 delete arg2;
20526 }
20527 return NULL;
20528 }
20529
20530
20531 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20532 PyObject *resultobj = 0;
20533 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20534 wxString *arg2 = 0 ;
20535 bool arg3 ;
20536 bool result;
20537 void *argp1 = 0 ;
20538 int res1 = 0 ;
20539 bool temp2 = false ;
20540 bool val3 ;
20541 int ecode3 = 0 ;
20542 PyObject * obj0 = 0 ;
20543 PyObject * obj1 = 0 ;
20544 PyObject * obj2 = 0 ;
20545 char * kwnames[] = {
20546 (char *) "self",(char *) "key",(char *) "value", NULL
20547 };
20548
20549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20551 if (!SWIG_IsOK(res1)) {
20552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20553 }
20554 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20555 {
20556 arg2 = wxString_in_helper(obj1);
20557 if (arg2 == NULL) SWIG_fail;
20558 temp2 = true;
20559 }
20560 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20561 if (!SWIG_IsOK(ecode3)) {
20562 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
20563 }
20564 arg3 = static_cast< bool >(val3);
20565 {
20566 PyThreadState* __tstate = wxPyBeginAllowThreads();
20567 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20568 wxPyEndAllowThreads(__tstate);
20569 if (PyErr_Occurred()) SWIG_fail;
20570 }
20571 {
20572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20573 }
20574 {
20575 if (temp2)
20576 delete arg2;
20577 }
20578 return resultobj;
20579 fail:
20580 {
20581 if (temp2)
20582 delete arg2;
20583 }
20584 return NULL;
20585 }
20586
20587
20588 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20589 PyObject *resultobj = 0;
20590 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20591 bool arg2 = (bool) false ;
20592 bool result;
20593 void *argp1 = 0 ;
20594 int res1 = 0 ;
20595 bool val2 ;
20596 int ecode2 = 0 ;
20597 PyObject * obj0 = 0 ;
20598 PyObject * obj1 = 0 ;
20599 char * kwnames[] = {
20600 (char *) "self",(char *) "currentOnly", NULL
20601 };
20602
20603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
20604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20605 if (!SWIG_IsOK(res1)) {
20606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20607 }
20608 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20609 if (obj1) {
20610 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20611 if (!SWIG_IsOK(ecode2)) {
20612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
20613 }
20614 arg2 = static_cast< bool >(val2);
20615 }
20616 {
20617 PyThreadState* __tstate = wxPyBeginAllowThreads();
20618 result = (bool)(arg1)->Flush(arg2);
20619 wxPyEndAllowThreads(__tstate);
20620 if (PyErr_Occurred()) SWIG_fail;
20621 }
20622 {
20623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20624 }
20625 return resultobj;
20626 fail:
20627 return NULL;
20628 }
20629
20630
20631 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20632 PyObject *resultobj = 0;
20633 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20634 wxString *arg2 = 0 ;
20635 wxString *arg3 = 0 ;
20636 bool result;
20637 void *argp1 = 0 ;
20638 int res1 = 0 ;
20639 bool temp2 = false ;
20640 bool temp3 = false ;
20641 PyObject * obj0 = 0 ;
20642 PyObject * obj1 = 0 ;
20643 PyObject * obj2 = 0 ;
20644 char * kwnames[] = {
20645 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20646 };
20647
20648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20650 if (!SWIG_IsOK(res1)) {
20651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20652 }
20653 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20654 {
20655 arg2 = wxString_in_helper(obj1);
20656 if (arg2 == NULL) SWIG_fail;
20657 temp2 = true;
20658 }
20659 {
20660 arg3 = wxString_in_helper(obj2);
20661 if (arg3 == NULL) SWIG_fail;
20662 temp3 = true;
20663 }
20664 {
20665 PyThreadState* __tstate = wxPyBeginAllowThreads();
20666 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
20667 wxPyEndAllowThreads(__tstate);
20668 if (PyErr_Occurred()) SWIG_fail;
20669 }
20670 {
20671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20672 }
20673 {
20674 if (temp2)
20675 delete arg2;
20676 }
20677 {
20678 if (temp3)
20679 delete arg3;
20680 }
20681 return resultobj;
20682 fail:
20683 {
20684 if (temp2)
20685 delete arg2;
20686 }
20687 {
20688 if (temp3)
20689 delete arg3;
20690 }
20691 return NULL;
20692 }
20693
20694
20695 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20696 PyObject *resultobj = 0;
20697 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20698 wxString *arg2 = 0 ;
20699 wxString *arg3 = 0 ;
20700 bool result;
20701 void *argp1 = 0 ;
20702 int res1 = 0 ;
20703 bool temp2 = false ;
20704 bool temp3 = false ;
20705 PyObject * obj0 = 0 ;
20706 PyObject * obj1 = 0 ;
20707 PyObject * obj2 = 0 ;
20708 char * kwnames[] = {
20709 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20710 };
20711
20712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20714 if (!SWIG_IsOK(res1)) {
20715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20716 }
20717 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20718 {
20719 arg2 = wxString_in_helper(obj1);
20720 if (arg2 == NULL) SWIG_fail;
20721 temp2 = true;
20722 }
20723 {
20724 arg3 = wxString_in_helper(obj2);
20725 if (arg3 == NULL) SWIG_fail;
20726 temp3 = true;
20727 }
20728 {
20729 PyThreadState* __tstate = wxPyBeginAllowThreads();
20730 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
20731 wxPyEndAllowThreads(__tstate);
20732 if (PyErr_Occurred()) SWIG_fail;
20733 }
20734 {
20735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20736 }
20737 {
20738 if (temp2)
20739 delete arg2;
20740 }
20741 {
20742 if (temp3)
20743 delete arg3;
20744 }
20745 return resultobj;
20746 fail:
20747 {
20748 if (temp2)
20749 delete arg2;
20750 }
20751 {
20752 if (temp3)
20753 delete arg3;
20754 }
20755 return NULL;
20756 }
20757
20758
20759 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20760 PyObject *resultobj = 0;
20761 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20762 wxString *arg2 = 0 ;
20763 bool arg3 = (bool) true ;
20764 bool result;
20765 void *argp1 = 0 ;
20766 int res1 = 0 ;
20767 bool temp2 = false ;
20768 bool val3 ;
20769 int ecode3 = 0 ;
20770 PyObject * obj0 = 0 ;
20771 PyObject * obj1 = 0 ;
20772 PyObject * obj2 = 0 ;
20773 char * kwnames[] = {
20774 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
20775 };
20776
20777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20779 if (!SWIG_IsOK(res1)) {
20780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20781 }
20782 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20783 {
20784 arg2 = wxString_in_helper(obj1);
20785 if (arg2 == NULL) SWIG_fail;
20786 temp2 = true;
20787 }
20788 if (obj2) {
20789 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20790 if (!SWIG_IsOK(ecode3)) {
20791 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
20792 }
20793 arg3 = static_cast< bool >(val3);
20794 }
20795 {
20796 PyThreadState* __tstate = wxPyBeginAllowThreads();
20797 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
20798 wxPyEndAllowThreads(__tstate);
20799 if (PyErr_Occurred()) SWIG_fail;
20800 }
20801 {
20802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20803 }
20804 {
20805 if (temp2)
20806 delete arg2;
20807 }
20808 return resultobj;
20809 fail:
20810 {
20811 if (temp2)
20812 delete arg2;
20813 }
20814 return NULL;
20815 }
20816
20817
20818 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20819 PyObject *resultobj = 0;
20820 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20821 wxString *arg2 = 0 ;
20822 bool result;
20823 void *argp1 = 0 ;
20824 int res1 = 0 ;
20825 bool temp2 = false ;
20826 PyObject * obj0 = 0 ;
20827 PyObject * obj1 = 0 ;
20828 char * kwnames[] = {
20829 (char *) "self",(char *) "key", NULL
20830 };
20831
20832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20834 if (!SWIG_IsOK(res1)) {
20835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20836 }
20837 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20838 {
20839 arg2 = wxString_in_helper(obj1);
20840 if (arg2 == NULL) SWIG_fail;
20841 temp2 = true;
20842 }
20843 {
20844 PyThreadState* __tstate = wxPyBeginAllowThreads();
20845 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
20846 wxPyEndAllowThreads(__tstate);
20847 if (PyErr_Occurred()) SWIG_fail;
20848 }
20849 {
20850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20851 }
20852 {
20853 if (temp2)
20854 delete arg2;
20855 }
20856 return resultobj;
20857 fail:
20858 {
20859 if (temp2)
20860 delete arg2;
20861 }
20862 return NULL;
20863 }
20864
20865
20866 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20867 PyObject *resultobj = 0;
20868 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20869 bool result;
20870 void *argp1 = 0 ;
20871 int res1 = 0 ;
20872 PyObject *swig_obj[1] ;
20873
20874 if (!args) SWIG_fail;
20875 swig_obj[0] = args;
20876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20877 if (!SWIG_IsOK(res1)) {
20878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20879 }
20880 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20881 {
20882 PyThreadState* __tstate = wxPyBeginAllowThreads();
20883 result = (bool)(arg1)->DeleteAll();
20884 wxPyEndAllowThreads(__tstate);
20885 if (PyErr_Occurred()) SWIG_fail;
20886 }
20887 {
20888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20889 }
20890 return resultobj;
20891 fail:
20892 return NULL;
20893 }
20894
20895
20896 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20897 PyObject *resultobj = 0;
20898 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20899 bool arg2 = (bool) true ;
20900 void *argp1 = 0 ;
20901 int res1 = 0 ;
20902 bool val2 ;
20903 int ecode2 = 0 ;
20904 PyObject * obj0 = 0 ;
20905 PyObject * obj1 = 0 ;
20906 char * kwnames[] = {
20907 (char *) "self",(char *) "doIt", NULL
20908 };
20909
20910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
20911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20912 if (!SWIG_IsOK(res1)) {
20913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20914 }
20915 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20916 if (obj1) {
20917 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20918 if (!SWIG_IsOK(ecode2)) {
20919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
20920 }
20921 arg2 = static_cast< bool >(val2);
20922 }
20923 {
20924 PyThreadState* __tstate = wxPyBeginAllowThreads();
20925 (arg1)->SetExpandEnvVars(arg2);
20926 wxPyEndAllowThreads(__tstate);
20927 if (PyErr_Occurred()) SWIG_fail;
20928 }
20929 resultobj = SWIG_Py_Void();
20930 return resultobj;
20931 fail:
20932 return NULL;
20933 }
20934
20935
20936 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20937 PyObject *resultobj = 0;
20938 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20939 bool result;
20940 void *argp1 = 0 ;
20941 int res1 = 0 ;
20942 PyObject *swig_obj[1] ;
20943
20944 if (!args) SWIG_fail;
20945 swig_obj[0] = args;
20946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20947 if (!SWIG_IsOK(res1)) {
20948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20949 }
20950 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20951 {
20952 PyThreadState* __tstate = wxPyBeginAllowThreads();
20953 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
20954 wxPyEndAllowThreads(__tstate);
20955 if (PyErr_Occurred()) SWIG_fail;
20956 }
20957 {
20958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20959 }
20960 return resultobj;
20961 fail:
20962 return NULL;
20963 }
20964
20965
20966 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20967 PyObject *resultobj = 0;
20968 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20969 bool arg2 = (bool) true ;
20970 void *argp1 = 0 ;
20971 int res1 = 0 ;
20972 bool val2 ;
20973 int ecode2 = 0 ;
20974 PyObject * obj0 = 0 ;
20975 PyObject * obj1 = 0 ;
20976 char * kwnames[] = {
20977 (char *) "self",(char *) "doIt", NULL
20978 };
20979
20980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
20981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20982 if (!SWIG_IsOK(res1)) {
20983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20984 }
20985 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20986 if (obj1) {
20987 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20988 if (!SWIG_IsOK(ecode2)) {
20989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
20990 }
20991 arg2 = static_cast< bool >(val2);
20992 }
20993 {
20994 PyThreadState* __tstate = wxPyBeginAllowThreads();
20995 (arg1)->SetRecordDefaults(arg2);
20996 wxPyEndAllowThreads(__tstate);
20997 if (PyErr_Occurred()) SWIG_fail;
20998 }
20999 resultobj = SWIG_Py_Void();
21000 return resultobj;
21001 fail:
21002 return NULL;
21003 }
21004
21005
21006 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21007 PyObject *resultobj = 0;
21008 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21009 bool result;
21010 void *argp1 = 0 ;
21011 int res1 = 0 ;
21012 PyObject *swig_obj[1] ;
21013
21014 if (!args) SWIG_fail;
21015 swig_obj[0] = args;
21016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21017 if (!SWIG_IsOK(res1)) {
21018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21019 }
21020 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21021 {
21022 PyThreadState* __tstate = wxPyBeginAllowThreads();
21023 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
21024 wxPyEndAllowThreads(__tstate);
21025 if (PyErr_Occurred()) SWIG_fail;
21026 }
21027 {
21028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21029 }
21030 return resultobj;
21031 fail:
21032 return NULL;
21033 }
21034
21035
21036 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21037 PyObject *resultobj = 0;
21038 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21039 wxString *arg2 = 0 ;
21040 wxString result;
21041 void *argp1 = 0 ;
21042 int res1 = 0 ;
21043 bool temp2 = false ;
21044 PyObject * obj0 = 0 ;
21045 PyObject * obj1 = 0 ;
21046 char * kwnames[] = {
21047 (char *) "self",(char *) "str", NULL
21048 };
21049
21050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21052 if (!SWIG_IsOK(res1)) {
21053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21054 }
21055 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21056 {
21057 arg2 = wxString_in_helper(obj1);
21058 if (arg2 == NULL) SWIG_fail;
21059 temp2 = true;
21060 }
21061 {
21062 PyThreadState* __tstate = wxPyBeginAllowThreads();
21063 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
21064 wxPyEndAllowThreads(__tstate);
21065 if (PyErr_Occurred()) SWIG_fail;
21066 }
21067 {
21068 #if wxUSE_UNICODE
21069 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21070 #else
21071 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21072 #endif
21073 }
21074 {
21075 if (temp2)
21076 delete arg2;
21077 }
21078 return resultobj;
21079 fail:
21080 {
21081 if (temp2)
21082 delete arg2;
21083 }
21084 return NULL;
21085 }
21086
21087
21088 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21089 PyObject *resultobj = 0;
21090 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21091 wxString result;
21092 void *argp1 = 0 ;
21093 int res1 = 0 ;
21094 PyObject *swig_obj[1] ;
21095
21096 if (!args) SWIG_fail;
21097 swig_obj[0] = args;
21098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21099 if (!SWIG_IsOK(res1)) {
21100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21101 }
21102 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21103 {
21104 PyThreadState* __tstate = wxPyBeginAllowThreads();
21105 result = ((wxConfigBase const *)arg1)->GetAppName();
21106 wxPyEndAllowThreads(__tstate);
21107 if (PyErr_Occurred()) SWIG_fail;
21108 }
21109 {
21110 #if wxUSE_UNICODE
21111 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21112 #else
21113 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21114 #endif
21115 }
21116 return resultobj;
21117 fail:
21118 return NULL;
21119 }
21120
21121
21122 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21123 PyObject *resultobj = 0;
21124 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21125 wxString result;
21126 void *argp1 = 0 ;
21127 int res1 = 0 ;
21128 PyObject *swig_obj[1] ;
21129
21130 if (!args) SWIG_fail;
21131 swig_obj[0] = args;
21132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21133 if (!SWIG_IsOK(res1)) {
21134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21135 }
21136 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21137 {
21138 PyThreadState* __tstate = wxPyBeginAllowThreads();
21139 result = ((wxConfigBase const *)arg1)->GetVendorName();
21140 wxPyEndAllowThreads(__tstate);
21141 if (PyErr_Occurred()) SWIG_fail;
21142 }
21143 {
21144 #if wxUSE_UNICODE
21145 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21146 #else
21147 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21148 #endif
21149 }
21150 return resultobj;
21151 fail:
21152 return NULL;
21153 }
21154
21155
21156 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21157 PyObject *resultobj = 0;
21158 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21159 wxString *arg2 = 0 ;
21160 void *argp1 = 0 ;
21161 int res1 = 0 ;
21162 bool temp2 = false ;
21163 PyObject * obj0 = 0 ;
21164 PyObject * obj1 = 0 ;
21165 char * kwnames[] = {
21166 (char *) "self",(char *) "appName", NULL
21167 };
21168
21169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
21170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21171 if (!SWIG_IsOK(res1)) {
21172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21173 }
21174 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21175 {
21176 arg2 = wxString_in_helper(obj1);
21177 if (arg2 == NULL) SWIG_fail;
21178 temp2 = true;
21179 }
21180 {
21181 PyThreadState* __tstate = wxPyBeginAllowThreads();
21182 (arg1)->SetAppName((wxString const &)*arg2);
21183 wxPyEndAllowThreads(__tstate);
21184 if (PyErr_Occurred()) SWIG_fail;
21185 }
21186 resultobj = SWIG_Py_Void();
21187 {
21188 if (temp2)
21189 delete arg2;
21190 }
21191 return resultobj;
21192 fail:
21193 {
21194 if (temp2)
21195 delete arg2;
21196 }
21197 return NULL;
21198 }
21199
21200
21201 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21202 PyObject *resultobj = 0;
21203 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21204 wxString *arg2 = 0 ;
21205 void *argp1 = 0 ;
21206 int res1 = 0 ;
21207 bool temp2 = false ;
21208 PyObject * obj0 = 0 ;
21209 PyObject * obj1 = 0 ;
21210 char * kwnames[] = {
21211 (char *) "self",(char *) "vendorName", NULL
21212 };
21213
21214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
21215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21216 if (!SWIG_IsOK(res1)) {
21217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21218 }
21219 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21220 {
21221 arg2 = wxString_in_helper(obj1);
21222 if (arg2 == NULL) SWIG_fail;
21223 temp2 = true;
21224 }
21225 {
21226 PyThreadState* __tstate = wxPyBeginAllowThreads();
21227 (arg1)->SetVendorName((wxString const &)*arg2);
21228 wxPyEndAllowThreads(__tstate);
21229 if (PyErr_Occurred()) SWIG_fail;
21230 }
21231 resultobj = SWIG_Py_Void();
21232 {
21233 if (temp2)
21234 delete arg2;
21235 }
21236 return resultobj;
21237 fail:
21238 {
21239 if (temp2)
21240 delete arg2;
21241 }
21242 return NULL;
21243 }
21244
21245
21246 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21247 PyObject *resultobj = 0;
21248 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21249 long arg2 ;
21250 void *argp1 = 0 ;
21251 int res1 = 0 ;
21252 long val2 ;
21253 int ecode2 = 0 ;
21254 PyObject * obj0 = 0 ;
21255 PyObject * obj1 = 0 ;
21256 char * kwnames[] = {
21257 (char *) "self",(char *) "style", NULL
21258 };
21259
21260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
21261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21262 if (!SWIG_IsOK(res1)) {
21263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21264 }
21265 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21266 ecode2 = SWIG_AsVal_long(obj1, &val2);
21267 if (!SWIG_IsOK(ecode2)) {
21268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
21269 }
21270 arg2 = static_cast< long >(val2);
21271 {
21272 PyThreadState* __tstate = wxPyBeginAllowThreads();
21273 (arg1)->SetStyle(arg2);
21274 wxPyEndAllowThreads(__tstate);
21275 if (PyErr_Occurred()) SWIG_fail;
21276 }
21277 resultobj = SWIG_Py_Void();
21278 return resultobj;
21279 fail:
21280 return NULL;
21281 }
21282
21283
21284 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21285 PyObject *resultobj = 0;
21286 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21287 long result;
21288 void *argp1 = 0 ;
21289 int res1 = 0 ;
21290 PyObject *swig_obj[1] ;
21291
21292 if (!args) SWIG_fail;
21293 swig_obj[0] = args;
21294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21295 if (!SWIG_IsOK(res1)) {
21296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21297 }
21298 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21299 {
21300 PyThreadState* __tstate = wxPyBeginAllowThreads();
21301 result = (long)((wxConfigBase const *)arg1)->GetStyle();
21302 wxPyEndAllowThreads(__tstate);
21303 if (PyErr_Occurred()) SWIG_fail;
21304 }
21305 resultobj = SWIG_From_long(static_cast< long >(result));
21306 return resultobj;
21307 fail:
21308 return NULL;
21309 }
21310
21311
21312 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21313 PyObject *obj;
21314 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21315 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
21316 return SWIG_Py_Void();
21317 }
21318
21319 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21320 PyObject *resultobj = 0;
21321 wxString const &arg1_defvalue = wxPyEmptyString ;
21322 wxString *arg1 = (wxString *) &arg1_defvalue ;
21323 wxString const &arg2_defvalue = wxPyEmptyString ;
21324 wxString *arg2 = (wxString *) &arg2_defvalue ;
21325 wxString const &arg3_defvalue = wxPyEmptyString ;
21326 wxString *arg3 = (wxString *) &arg3_defvalue ;
21327 wxString const &arg4_defvalue = wxPyEmptyString ;
21328 wxString *arg4 = (wxString *) &arg4_defvalue ;
21329 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21330 wxConfig *result = 0 ;
21331 bool temp1 = false ;
21332 bool temp2 = false ;
21333 bool temp3 = false ;
21334 bool temp4 = false ;
21335 long val5 ;
21336 int ecode5 = 0 ;
21337 PyObject * obj0 = 0 ;
21338 PyObject * obj1 = 0 ;
21339 PyObject * obj2 = 0 ;
21340 PyObject * obj3 = 0 ;
21341 PyObject * obj4 = 0 ;
21342 char * kwnames[] = {
21343 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21344 };
21345
21346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21347 if (obj0) {
21348 {
21349 arg1 = wxString_in_helper(obj0);
21350 if (arg1 == NULL) SWIG_fail;
21351 temp1 = true;
21352 }
21353 }
21354 if (obj1) {
21355 {
21356 arg2 = wxString_in_helper(obj1);
21357 if (arg2 == NULL) SWIG_fail;
21358 temp2 = true;
21359 }
21360 }
21361 if (obj2) {
21362 {
21363 arg3 = wxString_in_helper(obj2);
21364 if (arg3 == NULL) SWIG_fail;
21365 temp3 = true;
21366 }
21367 }
21368 if (obj3) {
21369 {
21370 arg4 = wxString_in_helper(obj3);
21371 if (arg4 == NULL) SWIG_fail;
21372 temp4 = true;
21373 }
21374 }
21375 if (obj4) {
21376 ecode5 = SWIG_AsVal_long(obj4, &val5);
21377 if (!SWIG_IsOK(ecode5)) {
21378 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
21379 }
21380 arg5 = static_cast< long >(val5);
21381 }
21382 {
21383 PyThreadState* __tstate = wxPyBeginAllowThreads();
21384 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21385 wxPyEndAllowThreads(__tstate);
21386 if (PyErr_Occurred()) SWIG_fail;
21387 }
21388 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
21389 {
21390 if (temp1)
21391 delete arg1;
21392 }
21393 {
21394 if (temp2)
21395 delete arg2;
21396 }
21397 {
21398 if (temp3)
21399 delete arg3;
21400 }
21401 {
21402 if (temp4)
21403 delete arg4;
21404 }
21405 return resultobj;
21406 fail:
21407 {
21408 if (temp1)
21409 delete arg1;
21410 }
21411 {
21412 if (temp2)
21413 delete arg2;
21414 }
21415 {
21416 if (temp3)
21417 delete arg3;
21418 }
21419 {
21420 if (temp4)
21421 delete arg4;
21422 }
21423 return NULL;
21424 }
21425
21426
21427 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21428 PyObject *resultobj = 0;
21429 wxConfig *arg1 = (wxConfig *) 0 ;
21430 void *argp1 = 0 ;
21431 int res1 = 0 ;
21432 PyObject *swig_obj[1] ;
21433
21434 if (!args) SWIG_fail;
21435 swig_obj[0] = args;
21436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
21437 if (!SWIG_IsOK(res1)) {
21438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
21439 }
21440 arg1 = reinterpret_cast< wxConfig * >(argp1);
21441 {
21442 PyThreadState* __tstate = wxPyBeginAllowThreads();
21443 delete arg1;
21444
21445 wxPyEndAllowThreads(__tstate);
21446 if (PyErr_Occurred()) SWIG_fail;
21447 }
21448 resultobj = SWIG_Py_Void();
21449 return resultobj;
21450 fail:
21451 return NULL;
21452 }
21453
21454
21455 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21456 PyObject *obj;
21457 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21458 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
21459 return SWIG_Py_Void();
21460 }
21461
21462 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21463 return SWIG_Python_InitShadowInstance(args);
21464 }
21465
21466 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21467 PyObject *resultobj = 0;
21468 wxString const &arg1_defvalue = wxPyEmptyString ;
21469 wxString *arg1 = (wxString *) &arg1_defvalue ;
21470 wxString const &arg2_defvalue = wxPyEmptyString ;
21471 wxString *arg2 = (wxString *) &arg2_defvalue ;
21472 wxString const &arg3_defvalue = wxPyEmptyString ;
21473 wxString *arg3 = (wxString *) &arg3_defvalue ;
21474 wxString const &arg4_defvalue = wxPyEmptyString ;
21475 wxString *arg4 = (wxString *) &arg4_defvalue ;
21476 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21477 wxFileConfig *result = 0 ;
21478 bool temp1 = false ;
21479 bool temp2 = false ;
21480 bool temp3 = false ;
21481 bool temp4 = false ;
21482 long val5 ;
21483 int ecode5 = 0 ;
21484 PyObject * obj0 = 0 ;
21485 PyObject * obj1 = 0 ;
21486 PyObject * obj2 = 0 ;
21487 PyObject * obj3 = 0 ;
21488 PyObject * obj4 = 0 ;
21489 char * kwnames[] = {
21490 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21491 };
21492
21493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21494 if (obj0) {
21495 {
21496 arg1 = wxString_in_helper(obj0);
21497 if (arg1 == NULL) SWIG_fail;
21498 temp1 = true;
21499 }
21500 }
21501 if (obj1) {
21502 {
21503 arg2 = wxString_in_helper(obj1);
21504 if (arg2 == NULL) SWIG_fail;
21505 temp2 = true;
21506 }
21507 }
21508 if (obj2) {
21509 {
21510 arg3 = wxString_in_helper(obj2);
21511 if (arg3 == NULL) SWIG_fail;
21512 temp3 = true;
21513 }
21514 }
21515 if (obj3) {
21516 {
21517 arg4 = wxString_in_helper(obj3);
21518 if (arg4 == NULL) SWIG_fail;
21519 temp4 = true;
21520 }
21521 }
21522 if (obj4) {
21523 ecode5 = SWIG_AsVal_long(obj4, &val5);
21524 if (!SWIG_IsOK(ecode5)) {
21525 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
21526 }
21527 arg5 = static_cast< long >(val5);
21528 }
21529 {
21530 PyThreadState* __tstate = wxPyBeginAllowThreads();
21531 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21532 wxPyEndAllowThreads(__tstate);
21533 if (PyErr_Occurred()) SWIG_fail;
21534 }
21535 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
21536 {
21537 if (temp1)
21538 delete arg1;
21539 }
21540 {
21541 if (temp2)
21542 delete arg2;
21543 }
21544 {
21545 if (temp3)
21546 delete arg3;
21547 }
21548 {
21549 if (temp4)
21550 delete arg4;
21551 }
21552 return resultobj;
21553 fail:
21554 {
21555 if (temp1)
21556 delete arg1;
21557 }
21558 {
21559 if (temp2)
21560 delete arg2;
21561 }
21562 {
21563 if (temp3)
21564 delete arg3;
21565 }
21566 {
21567 if (temp4)
21568 delete arg4;
21569 }
21570 return NULL;
21571 }
21572
21573
21574 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21575 PyObject *resultobj = 0;
21576 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
21577 void *argp1 = 0 ;
21578 int res1 = 0 ;
21579 PyObject *swig_obj[1] ;
21580
21581 if (!args) SWIG_fail;
21582 swig_obj[0] = args;
21583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
21584 if (!SWIG_IsOK(res1)) {
21585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
21586 }
21587 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
21588 {
21589 PyThreadState* __tstate = wxPyBeginAllowThreads();
21590 delete arg1;
21591
21592 wxPyEndAllowThreads(__tstate);
21593 if (PyErr_Occurred()) SWIG_fail;
21594 }
21595 resultobj = SWIG_Py_Void();
21596 return resultobj;
21597 fail:
21598 return NULL;
21599 }
21600
21601
21602 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21603 PyObject *obj;
21604 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21605 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
21606 return SWIG_Py_Void();
21607 }
21608
21609 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21610 return SWIG_Python_InitShadowInstance(args);
21611 }
21612
21613 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21614 PyObject *resultobj = 0;
21615 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21616 wxString *arg2 = 0 ;
21617 wxConfigPathChanger *result = 0 ;
21618 void *argp1 = 0 ;
21619 int res1 = 0 ;
21620 bool temp2 = false ;
21621 PyObject * obj0 = 0 ;
21622 PyObject * obj1 = 0 ;
21623 char * kwnames[] = {
21624 (char *) "config",(char *) "entry", NULL
21625 };
21626
21627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
21628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21629 if (!SWIG_IsOK(res1)) {
21630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21631 }
21632 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21633 {
21634 arg2 = wxString_in_helper(obj1);
21635 if (arg2 == NULL) SWIG_fail;
21636 temp2 = true;
21637 }
21638 {
21639 PyThreadState* __tstate = wxPyBeginAllowThreads();
21640 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
21641 wxPyEndAllowThreads(__tstate);
21642 if (PyErr_Occurred()) SWIG_fail;
21643 }
21644 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
21645 {
21646 if (temp2)
21647 delete arg2;
21648 }
21649 return resultobj;
21650 fail:
21651 {
21652 if (temp2)
21653 delete arg2;
21654 }
21655 return NULL;
21656 }
21657
21658
21659 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21660 PyObject *resultobj = 0;
21661 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21662 void *argp1 = 0 ;
21663 int res1 = 0 ;
21664 PyObject *swig_obj[1] ;
21665
21666 if (!args) SWIG_fail;
21667 swig_obj[0] = args;
21668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
21669 if (!SWIG_IsOK(res1)) {
21670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
21671 }
21672 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21673 {
21674 PyThreadState* __tstate = wxPyBeginAllowThreads();
21675 delete arg1;
21676
21677 wxPyEndAllowThreads(__tstate);
21678 if (PyErr_Occurred()) SWIG_fail;
21679 }
21680 resultobj = SWIG_Py_Void();
21681 return resultobj;
21682 fail:
21683 return NULL;
21684 }
21685
21686
21687 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21688 PyObject *resultobj = 0;
21689 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21690 wxString *result = 0 ;
21691 void *argp1 = 0 ;
21692 int res1 = 0 ;
21693 PyObject *swig_obj[1] ;
21694
21695 if (!args) SWIG_fail;
21696 swig_obj[0] = args;
21697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
21698 if (!SWIG_IsOK(res1)) {
21699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
21700 }
21701 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21702 {
21703 PyThreadState* __tstate = wxPyBeginAllowThreads();
21704 {
21705 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
21706 result = (wxString *) &_result_ref;
21707 }
21708 wxPyEndAllowThreads(__tstate);
21709 if (PyErr_Occurred()) SWIG_fail;
21710 }
21711 {
21712 #if wxUSE_UNICODE
21713 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21714 #else
21715 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21716 #endif
21717 }
21718 return resultobj;
21719 fail:
21720 return NULL;
21721 }
21722
21723
21724 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21725 PyObject *obj;
21726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21727 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
21728 return SWIG_Py_Void();
21729 }
21730
21731 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21732 return SWIG_Python_InitShadowInstance(args);
21733 }
21734
21735 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21736 PyObject *resultobj = 0;
21737 wxString *arg1 = 0 ;
21738 wxString result;
21739 bool temp1 = false ;
21740 PyObject * obj0 = 0 ;
21741 char * kwnames[] = {
21742 (char *) "sz", NULL
21743 };
21744
21745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
21746 {
21747 arg1 = wxString_in_helper(obj0);
21748 if (arg1 == NULL) SWIG_fail;
21749 temp1 = true;
21750 }
21751 {
21752 PyThreadState* __tstate = wxPyBeginAllowThreads();
21753 result = wxExpandEnvVars((wxString const &)*arg1);
21754 wxPyEndAllowThreads(__tstate);
21755 if (PyErr_Occurred()) SWIG_fail;
21756 }
21757 {
21758 #if wxUSE_UNICODE
21759 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21760 #else
21761 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21762 #endif
21763 }
21764 {
21765 if (temp1)
21766 delete arg1;
21767 }
21768 return resultobj;
21769 fail:
21770 {
21771 if (temp1)
21772 delete arg1;
21773 }
21774 return NULL;
21775 }
21776
21777
21778 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
21779 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
21780 return 1;
21781 }
21782
21783
21784 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
21785 PyObject *pyobj = 0;
21786
21787 {
21788 #if wxUSE_UNICODE
21789 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21790 #else
21791 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21792 #endif
21793 }
21794 return pyobj;
21795 }
21796
21797
21798 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
21799 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
21800 return 1;
21801 }
21802
21803
21804 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
21805 PyObject *pyobj = 0;
21806
21807 {
21808 #if wxUSE_UNICODE
21809 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21810 #else
21811 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21812 #endif
21813 }
21814 return pyobj;
21815 }
21816
21817
21818 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21819 PyObject *resultobj = 0;
21820 wxDateTime::Country arg1 ;
21821 int val1 ;
21822 int ecode1 = 0 ;
21823 PyObject * obj0 = 0 ;
21824 char * kwnames[] = {
21825 (char *) "country", NULL
21826 };
21827
21828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
21829 ecode1 = SWIG_AsVal_int(obj0, &val1);
21830 if (!SWIG_IsOK(ecode1)) {
21831 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21832 }
21833 arg1 = static_cast< wxDateTime::Country >(val1);
21834 {
21835 PyThreadState* __tstate = wxPyBeginAllowThreads();
21836 wxDateTime::SetCountry(arg1);
21837 wxPyEndAllowThreads(__tstate);
21838 if (PyErr_Occurred()) SWIG_fail;
21839 }
21840 resultobj = SWIG_Py_Void();
21841 return resultobj;
21842 fail:
21843 return NULL;
21844 }
21845
21846
21847 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21848 PyObject *resultobj = 0;
21849 wxDateTime::Country result;
21850
21851 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
21852 {
21853 PyThreadState* __tstate = wxPyBeginAllowThreads();
21854 result = (wxDateTime::Country)wxDateTime::GetCountry();
21855 wxPyEndAllowThreads(__tstate);
21856 if (PyErr_Occurred()) SWIG_fail;
21857 }
21858 resultobj = SWIG_From_int(static_cast< int >(result));
21859 return resultobj;
21860 fail:
21861 return NULL;
21862 }
21863
21864
21865 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21866 PyObject *resultobj = 0;
21867 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
21868 bool result;
21869 int val1 ;
21870 int ecode1 = 0 ;
21871 PyObject * obj0 = 0 ;
21872 char * kwnames[] = {
21873 (char *) "country", NULL
21874 };
21875
21876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
21877 if (obj0) {
21878 ecode1 = SWIG_AsVal_int(obj0, &val1);
21879 if (!SWIG_IsOK(ecode1)) {
21880 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21881 }
21882 arg1 = static_cast< wxDateTime::Country >(val1);
21883 }
21884 {
21885 PyThreadState* __tstate = wxPyBeginAllowThreads();
21886 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
21887 wxPyEndAllowThreads(__tstate);
21888 if (PyErr_Occurred()) SWIG_fail;
21889 }
21890 {
21891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21892 }
21893 return resultobj;
21894 fail:
21895 return NULL;
21896 }
21897
21898
21899 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21900 PyObject *resultobj = 0;
21901 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21902 int result;
21903 int val1 ;
21904 int ecode1 = 0 ;
21905 PyObject * obj0 = 0 ;
21906 char * kwnames[] = {
21907 (char *) "cal", NULL
21908 };
21909
21910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
21911 if (obj0) {
21912 ecode1 = SWIG_AsVal_int(obj0, &val1);
21913 if (!SWIG_IsOK(ecode1)) {
21914 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21915 }
21916 arg1 = static_cast< wxDateTime::Calendar >(val1);
21917 }
21918 {
21919 PyThreadState* __tstate = wxPyBeginAllowThreads();
21920 result = (int)wxDateTime::GetCurrentYear(arg1);
21921 wxPyEndAllowThreads(__tstate);
21922 if (PyErr_Occurred()) SWIG_fail;
21923 }
21924 resultobj = SWIG_From_int(static_cast< int >(result));
21925 return resultobj;
21926 fail:
21927 return NULL;
21928 }
21929
21930
21931 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21932 PyObject *resultobj = 0;
21933 int arg1 ;
21934 int result;
21935 int val1 ;
21936 int ecode1 = 0 ;
21937 PyObject * obj0 = 0 ;
21938 char * kwnames[] = {
21939 (char *) "year", NULL
21940 };
21941
21942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
21943 ecode1 = SWIG_AsVal_int(obj0, &val1);
21944 if (!SWIG_IsOK(ecode1)) {
21945 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
21946 }
21947 arg1 = static_cast< int >(val1);
21948 {
21949 PyThreadState* __tstate = wxPyBeginAllowThreads();
21950 result = (int)wxDateTime::ConvertYearToBC(arg1);
21951 wxPyEndAllowThreads(__tstate);
21952 if (PyErr_Occurred()) SWIG_fail;
21953 }
21954 resultobj = SWIG_From_int(static_cast< int >(result));
21955 return resultobj;
21956 fail:
21957 return NULL;
21958 }
21959
21960
21961 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21962 PyObject *resultobj = 0;
21963 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21964 wxDateTime::Month result;
21965 int val1 ;
21966 int ecode1 = 0 ;
21967 PyObject * obj0 = 0 ;
21968 char * kwnames[] = {
21969 (char *) "cal", NULL
21970 };
21971
21972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
21973 if (obj0) {
21974 ecode1 = SWIG_AsVal_int(obj0, &val1);
21975 if (!SWIG_IsOK(ecode1)) {
21976 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21977 }
21978 arg1 = static_cast< wxDateTime::Calendar >(val1);
21979 }
21980 {
21981 PyThreadState* __tstate = wxPyBeginAllowThreads();
21982 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
21983 wxPyEndAllowThreads(__tstate);
21984 if (PyErr_Occurred()) SWIG_fail;
21985 }
21986 resultobj = SWIG_From_int(static_cast< int >(result));
21987 return resultobj;
21988 fail:
21989 return NULL;
21990 }
21991
21992
21993 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21994 PyObject *resultobj = 0;
21995 int arg1 = (int) wxDateTime::Inv_Year ;
21996 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21997 bool result;
21998 int val1 ;
21999 int ecode1 = 0 ;
22000 int val2 ;
22001 int ecode2 = 0 ;
22002 PyObject * obj0 = 0 ;
22003 PyObject * obj1 = 0 ;
22004 char * kwnames[] = {
22005 (char *) "year",(char *) "cal", NULL
22006 };
22007
22008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
22009 if (obj0) {
22010 ecode1 = SWIG_AsVal_int(obj0, &val1);
22011 if (!SWIG_IsOK(ecode1)) {
22012 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
22013 }
22014 arg1 = static_cast< int >(val1);
22015 }
22016 if (obj1) {
22017 ecode2 = SWIG_AsVal_int(obj1, &val2);
22018 if (!SWIG_IsOK(ecode2)) {
22019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22020 }
22021 arg2 = static_cast< wxDateTime::Calendar >(val2);
22022 }
22023 {
22024 PyThreadState* __tstate = wxPyBeginAllowThreads();
22025 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
22026 wxPyEndAllowThreads(__tstate);
22027 if (PyErr_Occurred()) SWIG_fail;
22028 }
22029 {
22030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22031 }
22032 return resultobj;
22033 fail:
22034 return NULL;
22035 }
22036
22037
22038 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22039 PyObject *resultobj = 0;
22040 int arg1 = (int) wxDateTime::Inv_Year ;
22041 int result;
22042 int val1 ;
22043 int ecode1 = 0 ;
22044 PyObject * obj0 = 0 ;
22045 char * kwnames[] = {
22046 (char *) "year", NULL
22047 };
22048
22049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
22050 if (obj0) {
22051 ecode1 = SWIG_AsVal_int(obj0, &val1);
22052 if (!SWIG_IsOK(ecode1)) {
22053 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
22054 }
22055 arg1 = static_cast< int >(val1);
22056 }
22057 {
22058 PyThreadState* __tstate = wxPyBeginAllowThreads();
22059 result = (int)wxDateTime::GetCentury(arg1);
22060 wxPyEndAllowThreads(__tstate);
22061 if (PyErr_Occurred()) SWIG_fail;
22062 }
22063 resultobj = SWIG_From_int(static_cast< int >(result));
22064 return resultobj;
22065 fail:
22066 return NULL;
22067 }
22068
22069
22070 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22071 PyObject *resultobj = 0;
22072 int arg1 ;
22073 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22074 int result;
22075 int val1 ;
22076 int ecode1 = 0 ;
22077 int val2 ;
22078 int ecode2 = 0 ;
22079 PyObject * obj0 = 0 ;
22080 PyObject * obj1 = 0 ;
22081 char * kwnames[] = {
22082 (char *) "year",(char *) "cal", NULL
22083 };
22084
22085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
22086 ecode1 = SWIG_AsVal_int(obj0, &val1);
22087 if (!SWIG_IsOK(ecode1)) {
22088 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
22089 }
22090 arg1 = static_cast< int >(val1);
22091 if (obj1) {
22092 ecode2 = SWIG_AsVal_int(obj1, &val2);
22093 if (!SWIG_IsOK(ecode2)) {
22094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22095 }
22096 arg2 = static_cast< wxDateTime::Calendar >(val2);
22097 }
22098 {
22099 PyThreadState* __tstate = wxPyBeginAllowThreads();
22100 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
22101 wxPyEndAllowThreads(__tstate);
22102 if (PyErr_Occurred()) SWIG_fail;
22103 }
22104 resultobj = SWIG_From_int(static_cast< int >(result));
22105 return resultobj;
22106 fail:
22107 return NULL;
22108 }
22109
22110
22111 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22112 PyObject *resultobj = 0;
22113 wxDateTime::Month arg1 ;
22114 int arg2 = (int) wxDateTime::Inv_Year ;
22115 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22116 int result;
22117 int val1 ;
22118 int ecode1 = 0 ;
22119 int val2 ;
22120 int ecode2 = 0 ;
22121 int val3 ;
22122 int ecode3 = 0 ;
22123 PyObject * obj0 = 0 ;
22124 PyObject * obj1 = 0 ;
22125 PyObject * obj2 = 0 ;
22126 char * kwnames[] = {
22127 (char *) "month",(char *) "year",(char *) "cal", NULL
22128 };
22129
22130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22131 ecode1 = SWIG_AsVal_int(obj0, &val1);
22132 if (!SWIG_IsOK(ecode1)) {
22133 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22134 }
22135 arg1 = static_cast< wxDateTime::Month >(val1);
22136 if (obj1) {
22137 ecode2 = SWIG_AsVal_int(obj1, &val2);
22138 if (!SWIG_IsOK(ecode2)) {
22139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
22140 }
22141 arg2 = static_cast< int >(val2);
22142 }
22143 if (obj2) {
22144 ecode3 = SWIG_AsVal_int(obj2, &val3);
22145 if (!SWIG_IsOK(ecode3)) {
22146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
22147 }
22148 arg3 = static_cast< wxDateTime::Calendar >(val3);
22149 }
22150 {
22151 PyThreadState* __tstate = wxPyBeginAllowThreads();
22152 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
22153 wxPyEndAllowThreads(__tstate);
22154 if (PyErr_Occurred()) SWIG_fail;
22155 }
22156 resultobj = SWIG_From_int(static_cast< int >(result));
22157 return resultobj;
22158 fail:
22159 return NULL;
22160 }
22161
22162
22163 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22164 PyObject *resultobj = 0;
22165 wxDateTime::Month arg1 ;
22166 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22167 wxString result;
22168 int val1 ;
22169 int ecode1 = 0 ;
22170 int val2 ;
22171 int ecode2 = 0 ;
22172 PyObject * obj0 = 0 ;
22173 PyObject * obj1 = 0 ;
22174 char * kwnames[] = {
22175 (char *) "month",(char *) "flags", NULL
22176 };
22177
22178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
22179 ecode1 = SWIG_AsVal_int(obj0, &val1);
22180 if (!SWIG_IsOK(ecode1)) {
22181 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22182 }
22183 arg1 = static_cast< wxDateTime::Month >(val1);
22184 if (obj1) {
22185 ecode2 = SWIG_AsVal_int(obj1, &val2);
22186 if (!SWIG_IsOK(ecode2)) {
22187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22188 }
22189 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22190 }
22191 {
22192 PyThreadState* __tstate = wxPyBeginAllowThreads();
22193 result = wxDateTime::GetMonthName(arg1,arg2);
22194 wxPyEndAllowThreads(__tstate);
22195 if (PyErr_Occurred()) SWIG_fail;
22196 }
22197 {
22198 #if wxUSE_UNICODE
22199 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22200 #else
22201 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22202 #endif
22203 }
22204 return resultobj;
22205 fail:
22206 return NULL;
22207 }
22208
22209
22210 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22211 PyObject *resultobj = 0;
22212 wxDateTime::WeekDay arg1 ;
22213 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22214 wxString result;
22215 int val1 ;
22216 int ecode1 = 0 ;
22217 int val2 ;
22218 int ecode2 = 0 ;
22219 PyObject * obj0 = 0 ;
22220 PyObject * obj1 = 0 ;
22221 char * kwnames[] = {
22222 (char *) "weekday",(char *) "flags", NULL
22223 };
22224
22225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
22226 ecode1 = SWIG_AsVal_int(obj0, &val1);
22227 if (!SWIG_IsOK(ecode1)) {
22228 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
22229 }
22230 arg1 = static_cast< wxDateTime::WeekDay >(val1);
22231 if (obj1) {
22232 ecode2 = SWIG_AsVal_int(obj1, &val2);
22233 if (!SWIG_IsOK(ecode2)) {
22234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22235 }
22236 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22237 }
22238 {
22239 PyThreadState* __tstate = wxPyBeginAllowThreads();
22240 result = wxDateTime::GetWeekDayName(arg1,arg2);
22241 wxPyEndAllowThreads(__tstate);
22242 if (PyErr_Occurred()) SWIG_fail;
22243 }
22244 {
22245 #if wxUSE_UNICODE
22246 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22247 #else
22248 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22249 #endif
22250 }
22251 return resultobj;
22252 fail:
22253 return NULL;
22254 }
22255
22256
22257 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22258 PyObject *resultobj = 0;
22259 PyObject *result = 0 ;
22260
22261 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
22262 {
22263 PyThreadState* __tstate = wxPyBeginAllowThreads();
22264 result = (PyObject *)wxDateTime_GetAmPmStrings();
22265 wxPyEndAllowThreads(__tstate);
22266 if (PyErr_Occurred()) SWIG_fail;
22267 }
22268 resultobj = result;
22269 return resultobj;
22270 fail:
22271 return NULL;
22272 }
22273
22274
22275 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22276 PyObject *resultobj = 0;
22277 int arg1 = (int) wxDateTime::Inv_Year ;
22278 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22279 bool result;
22280 int val1 ;
22281 int ecode1 = 0 ;
22282 int val2 ;
22283 int ecode2 = 0 ;
22284 PyObject * obj0 = 0 ;
22285 PyObject * obj1 = 0 ;
22286 char * kwnames[] = {
22287 (char *) "year",(char *) "country", NULL
22288 };
22289
22290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
22291 if (obj0) {
22292 ecode1 = SWIG_AsVal_int(obj0, &val1);
22293 if (!SWIG_IsOK(ecode1)) {
22294 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
22295 }
22296 arg1 = static_cast< int >(val1);
22297 }
22298 if (obj1) {
22299 ecode2 = SWIG_AsVal_int(obj1, &val2);
22300 if (!SWIG_IsOK(ecode2)) {
22301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22302 }
22303 arg2 = static_cast< wxDateTime::Country >(val2);
22304 }
22305 {
22306 PyThreadState* __tstate = wxPyBeginAllowThreads();
22307 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
22308 wxPyEndAllowThreads(__tstate);
22309 if (PyErr_Occurred()) SWIG_fail;
22310 }
22311 {
22312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22313 }
22314 return resultobj;
22315 fail:
22316 return NULL;
22317 }
22318
22319
22320 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22321 PyObject *resultobj = 0;
22322 int arg1 = (int) wxDateTime::Inv_Year ;
22323 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22324 wxDateTime result;
22325 int val1 ;
22326 int ecode1 = 0 ;
22327 int val2 ;
22328 int ecode2 = 0 ;
22329 PyObject * obj0 = 0 ;
22330 PyObject * obj1 = 0 ;
22331 char * kwnames[] = {
22332 (char *) "year",(char *) "country", NULL
22333 };
22334
22335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
22336 if (obj0) {
22337 ecode1 = SWIG_AsVal_int(obj0, &val1);
22338 if (!SWIG_IsOK(ecode1)) {
22339 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
22340 }
22341 arg1 = static_cast< int >(val1);
22342 }
22343 if (obj1) {
22344 ecode2 = SWIG_AsVal_int(obj1, &val2);
22345 if (!SWIG_IsOK(ecode2)) {
22346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22347 }
22348 arg2 = static_cast< wxDateTime::Country >(val2);
22349 }
22350 {
22351 PyThreadState* __tstate = wxPyBeginAllowThreads();
22352 result = wxDateTime::GetBeginDST(arg1,arg2);
22353 wxPyEndAllowThreads(__tstate);
22354 if (PyErr_Occurred()) SWIG_fail;
22355 }
22356 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22357 return resultobj;
22358 fail:
22359 return NULL;
22360 }
22361
22362
22363 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22364 PyObject *resultobj = 0;
22365 int arg1 = (int) wxDateTime::Inv_Year ;
22366 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22367 wxDateTime result;
22368 int val1 ;
22369 int ecode1 = 0 ;
22370 int val2 ;
22371 int ecode2 = 0 ;
22372 PyObject * obj0 = 0 ;
22373 PyObject * obj1 = 0 ;
22374 char * kwnames[] = {
22375 (char *) "year",(char *) "country", NULL
22376 };
22377
22378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
22379 if (obj0) {
22380 ecode1 = SWIG_AsVal_int(obj0, &val1);
22381 if (!SWIG_IsOK(ecode1)) {
22382 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
22383 }
22384 arg1 = static_cast< int >(val1);
22385 }
22386 if (obj1) {
22387 ecode2 = SWIG_AsVal_int(obj1, &val2);
22388 if (!SWIG_IsOK(ecode2)) {
22389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22390 }
22391 arg2 = static_cast< wxDateTime::Country >(val2);
22392 }
22393 {
22394 PyThreadState* __tstate = wxPyBeginAllowThreads();
22395 result = wxDateTime::GetEndDST(arg1,arg2);
22396 wxPyEndAllowThreads(__tstate);
22397 if (PyErr_Occurred()) SWIG_fail;
22398 }
22399 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22400 return resultobj;
22401 fail:
22402 return NULL;
22403 }
22404
22405
22406 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22407 PyObject *resultobj = 0;
22408 wxDateTime result;
22409
22410 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
22411 {
22412 PyThreadState* __tstate = wxPyBeginAllowThreads();
22413 result = wxDateTime::Now();
22414 wxPyEndAllowThreads(__tstate);
22415 if (PyErr_Occurred()) SWIG_fail;
22416 }
22417 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22418 return resultobj;
22419 fail:
22420 return NULL;
22421 }
22422
22423
22424 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22425 PyObject *resultobj = 0;
22426 wxDateTime result;
22427
22428 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
22429 {
22430 PyThreadState* __tstate = wxPyBeginAllowThreads();
22431 result = wxDateTime::UNow();
22432 wxPyEndAllowThreads(__tstate);
22433 if (PyErr_Occurred()) SWIG_fail;
22434 }
22435 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22436 return resultobj;
22437 fail:
22438 return NULL;
22439 }
22440
22441
22442 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22443 PyObject *resultobj = 0;
22444 wxDateTime result;
22445
22446 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
22447 {
22448 PyThreadState* __tstate = wxPyBeginAllowThreads();
22449 result = wxDateTime::Today();
22450 wxPyEndAllowThreads(__tstate);
22451 if (PyErr_Occurred()) SWIG_fail;
22452 }
22453 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22454 return resultobj;
22455 fail:
22456 return NULL;
22457 }
22458
22459
22460 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22461 PyObject *resultobj = 0;
22462 wxDateTime *result = 0 ;
22463
22464 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
22465 {
22466 PyThreadState* __tstate = wxPyBeginAllowThreads();
22467 result = (wxDateTime *)new wxDateTime();
22468 wxPyEndAllowThreads(__tstate);
22469 if (PyErr_Occurred()) SWIG_fail;
22470 }
22471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
22472 return resultobj;
22473 fail:
22474 return NULL;
22475 }
22476
22477
22478 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22479 PyObject *resultobj = 0;
22480 time_t arg1 ;
22481 wxDateTime *result = 0 ;
22482 unsigned int val1 ;
22483 int ecode1 = 0 ;
22484 PyObject * obj0 = 0 ;
22485 char * kwnames[] = {
22486 (char *) "timet", NULL
22487 };
22488
22489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
22490 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
22491 if (!SWIG_IsOK(ecode1)) {
22492 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
22493 }
22494 arg1 = static_cast< time_t >(val1);
22495 {
22496 PyThreadState* __tstate = wxPyBeginAllowThreads();
22497 result = (wxDateTime *)new wxDateTime(arg1);
22498 wxPyEndAllowThreads(__tstate);
22499 if (PyErr_Occurred()) SWIG_fail;
22500 }
22501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22502 return resultobj;
22503 fail:
22504 return NULL;
22505 }
22506
22507
22508 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22509 PyObject *resultobj = 0;
22510 double arg1 ;
22511 wxDateTime *result = 0 ;
22512 double val1 ;
22513 int ecode1 = 0 ;
22514 PyObject * obj0 = 0 ;
22515 char * kwnames[] = {
22516 (char *) "jdn", NULL
22517 };
22518
22519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
22520 ecode1 = SWIG_AsVal_double(obj0, &val1);
22521 if (!SWIG_IsOK(ecode1)) {
22522 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
22523 }
22524 arg1 = static_cast< double >(val1);
22525 {
22526 PyThreadState* __tstate = wxPyBeginAllowThreads();
22527 result = (wxDateTime *)new wxDateTime(arg1);
22528 wxPyEndAllowThreads(__tstate);
22529 if (PyErr_Occurred()) SWIG_fail;
22530 }
22531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22532 return resultobj;
22533 fail:
22534 return NULL;
22535 }
22536
22537
22538 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22539 PyObject *resultobj = 0;
22540 int arg1 ;
22541 int arg2 = (int) 0 ;
22542 int arg3 = (int) 0 ;
22543 int arg4 = (int) 0 ;
22544 wxDateTime *result = 0 ;
22545 int val1 ;
22546 int ecode1 = 0 ;
22547 int val2 ;
22548 int ecode2 = 0 ;
22549 int val3 ;
22550 int ecode3 = 0 ;
22551 int val4 ;
22552 int ecode4 = 0 ;
22553 PyObject * obj0 = 0 ;
22554 PyObject * obj1 = 0 ;
22555 PyObject * obj2 = 0 ;
22556 PyObject * obj3 = 0 ;
22557 char * kwnames[] = {
22558 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22559 };
22560
22561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22562 ecode1 = SWIG_AsVal_int(obj0, &val1);
22563 if (!SWIG_IsOK(ecode1)) {
22564 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
22565 }
22566 arg1 = static_cast< int >(val1);
22567 if (obj1) {
22568 ecode2 = SWIG_AsVal_int(obj1, &val2);
22569 if (!SWIG_IsOK(ecode2)) {
22570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
22571 }
22572 arg2 = static_cast< int >(val2);
22573 }
22574 if (obj2) {
22575 ecode3 = SWIG_AsVal_int(obj2, &val3);
22576 if (!SWIG_IsOK(ecode3)) {
22577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
22578 }
22579 arg3 = static_cast< int >(val3);
22580 }
22581 if (obj3) {
22582 ecode4 = SWIG_AsVal_int(obj3, &val4);
22583 if (!SWIG_IsOK(ecode4)) {
22584 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
22585 }
22586 arg4 = static_cast< int >(val4);
22587 }
22588 {
22589 PyThreadState* __tstate = wxPyBeginAllowThreads();
22590 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
22591 wxPyEndAllowThreads(__tstate);
22592 if (PyErr_Occurred()) SWIG_fail;
22593 }
22594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22595 return resultobj;
22596 fail:
22597 return NULL;
22598 }
22599
22600
22601 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22602 PyObject *resultobj = 0;
22603 int arg1 ;
22604 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22605 int arg3 = (int) wxDateTime::Inv_Year ;
22606 int arg4 = (int) 0 ;
22607 int arg5 = (int) 0 ;
22608 int arg6 = (int) 0 ;
22609 int arg7 = (int) 0 ;
22610 wxDateTime *result = 0 ;
22611 int val1 ;
22612 int ecode1 = 0 ;
22613 int val2 ;
22614 int ecode2 = 0 ;
22615 int val3 ;
22616 int ecode3 = 0 ;
22617 int val4 ;
22618 int ecode4 = 0 ;
22619 int val5 ;
22620 int ecode5 = 0 ;
22621 int val6 ;
22622 int ecode6 = 0 ;
22623 int val7 ;
22624 int ecode7 = 0 ;
22625 PyObject * obj0 = 0 ;
22626 PyObject * obj1 = 0 ;
22627 PyObject * obj2 = 0 ;
22628 PyObject * obj3 = 0 ;
22629 PyObject * obj4 = 0 ;
22630 PyObject * obj5 = 0 ;
22631 PyObject * obj6 = 0 ;
22632 char * kwnames[] = {
22633 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22634 };
22635
22636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22637 ecode1 = SWIG_AsVal_int(obj0, &val1);
22638 if (!SWIG_IsOK(ecode1)) {
22639 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
22640 }
22641 arg1 = static_cast< int >(val1);
22642 if (obj1) {
22643 ecode2 = SWIG_AsVal_int(obj1, &val2);
22644 if (!SWIG_IsOK(ecode2)) {
22645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
22646 }
22647 arg2 = static_cast< wxDateTime::Month >(val2);
22648 }
22649 if (obj2) {
22650 ecode3 = SWIG_AsVal_int(obj2, &val3);
22651 if (!SWIG_IsOK(ecode3)) {
22652 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
22653 }
22654 arg3 = static_cast< int >(val3);
22655 }
22656 if (obj3) {
22657 ecode4 = SWIG_AsVal_int(obj3, &val4);
22658 if (!SWIG_IsOK(ecode4)) {
22659 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
22660 }
22661 arg4 = static_cast< int >(val4);
22662 }
22663 if (obj4) {
22664 ecode5 = SWIG_AsVal_int(obj4, &val5);
22665 if (!SWIG_IsOK(ecode5)) {
22666 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
22667 }
22668 arg5 = static_cast< int >(val5);
22669 }
22670 if (obj5) {
22671 ecode6 = SWIG_AsVal_int(obj5, &val6);
22672 if (!SWIG_IsOK(ecode6)) {
22673 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
22674 }
22675 arg6 = static_cast< int >(val6);
22676 }
22677 if (obj6) {
22678 ecode7 = SWIG_AsVal_int(obj6, &val7);
22679 if (!SWIG_IsOK(ecode7)) {
22680 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
22681 }
22682 arg7 = static_cast< int >(val7);
22683 }
22684 {
22685 PyThreadState* __tstate = wxPyBeginAllowThreads();
22686 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
22687 wxPyEndAllowThreads(__tstate);
22688 if (PyErr_Occurred()) SWIG_fail;
22689 }
22690 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22691 return resultobj;
22692 fail:
22693 return NULL;
22694 }
22695
22696
22697 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22698 PyObject *resultobj = 0;
22699 wxDateTime *arg1 = 0 ;
22700 wxDateTime *result = 0 ;
22701 void *argp1 = 0 ;
22702 int res1 = 0 ;
22703 PyObject * obj0 = 0 ;
22704 char * kwnames[] = {
22705 (char *) "date", NULL
22706 };
22707
22708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
22709 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
22710 if (!SWIG_IsOK(res1)) {
22711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22712 }
22713 if (!argp1) {
22714 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22715 }
22716 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22717 {
22718 PyThreadState* __tstate = wxPyBeginAllowThreads();
22719 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
22720 wxPyEndAllowThreads(__tstate);
22721 if (PyErr_Occurred()) SWIG_fail;
22722 }
22723 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22724 return resultobj;
22725 fail:
22726 return NULL;
22727 }
22728
22729
22730 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22731 PyObject *resultobj = 0;
22732 wxDateTime *arg1 = (wxDateTime *) 0 ;
22733 void *argp1 = 0 ;
22734 int res1 = 0 ;
22735 PyObject *swig_obj[1] ;
22736
22737 if (!args) SWIG_fail;
22738 swig_obj[0] = args;
22739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
22740 if (!SWIG_IsOK(res1)) {
22741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
22742 }
22743 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22744 {
22745 PyThreadState* __tstate = wxPyBeginAllowThreads();
22746 delete arg1;
22747
22748 wxPyEndAllowThreads(__tstate);
22749 if (PyErr_Occurred()) SWIG_fail;
22750 }
22751 resultobj = SWIG_Py_Void();
22752 return resultobj;
22753 fail:
22754 return NULL;
22755 }
22756
22757
22758 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22759 PyObject *resultobj = 0;
22760 wxDateTime *arg1 = (wxDateTime *) 0 ;
22761 wxDateTime *result = 0 ;
22762 void *argp1 = 0 ;
22763 int res1 = 0 ;
22764 PyObject *swig_obj[1] ;
22765
22766 if (!args) SWIG_fail;
22767 swig_obj[0] = args;
22768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22769 if (!SWIG_IsOK(res1)) {
22770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
22771 }
22772 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22773 {
22774 PyThreadState* __tstate = wxPyBeginAllowThreads();
22775 {
22776 wxDateTime &_result_ref = (arg1)->SetToCurrent();
22777 result = (wxDateTime *) &_result_ref;
22778 }
22779 wxPyEndAllowThreads(__tstate);
22780 if (PyErr_Occurred()) SWIG_fail;
22781 }
22782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22783 return resultobj;
22784 fail:
22785 return NULL;
22786 }
22787
22788
22789 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22790 PyObject *resultobj = 0;
22791 wxDateTime *arg1 = (wxDateTime *) 0 ;
22792 time_t arg2 ;
22793 wxDateTime *result = 0 ;
22794 void *argp1 = 0 ;
22795 int res1 = 0 ;
22796 unsigned int val2 ;
22797 int ecode2 = 0 ;
22798 PyObject * obj0 = 0 ;
22799 PyObject * obj1 = 0 ;
22800 char * kwnames[] = {
22801 (char *) "self",(char *) "timet", NULL
22802 };
22803
22804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
22805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22806 if (!SWIG_IsOK(res1)) {
22807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
22808 }
22809 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22810 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22811 if (!SWIG_IsOK(ecode2)) {
22812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
22813 }
22814 arg2 = static_cast< time_t >(val2);
22815 {
22816 PyThreadState* __tstate = wxPyBeginAllowThreads();
22817 {
22818 wxDateTime &_result_ref = (arg1)->Set(arg2);
22819 result = (wxDateTime *) &_result_ref;
22820 }
22821 wxPyEndAllowThreads(__tstate);
22822 if (PyErr_Occurred()) SWIG_fail;
22823 }
22824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22825 return resultobj;
22826 fail:
22827 return NULL;
22828 }
22829
22830
22831 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22832 PyObject *resultobj = 0;
22833 wxDateTime *arg1 = (wxDateTime *) 0 ;
22834 double arg2 ;
22835 wxDateTime *result = 0 ;
22836 void *argp1 = 0 ;
22837 int res1 = 0 ;
22838 double val2 ;
22839 int ecode2 = 0 ;
22840 PyObject * obj0 = 0 ;
22841 PyObject * obj1 = 0 ;
22842 char * kwnames[] = {
22843 (char *) "self",(char *) "jdn", NULL
22844 };
22845
22846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
22847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22848 if (!SWIG_IsOK(res1)) {
22849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
22850 }
22851 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22852 ecode2 = SWIG_AsVal_double(obj1, &val2);
22853 if (!SWIG_IsOK(ecode2)) {
22854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
22855 }
22856 arg2 = static_cast< double >(val2);
22857 {
22858 PyThreadState* __tstate = wxPyBeginAllowThreads();
22859 {
22860 wxDateTime &_result_ref = (arg1)->Set(arg2);
22861 result = (wxDateTime *) &_result_ref;
22862 }
22863 wxPyEndAllowThreads(__tstate);
22864 if (PyErr_Occurred()) SWIG_fail;
22865 }
22866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22867 return resultobj;
22868 fail:
22869 return NULL;
22870 }
22871
22872
22873 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22874 PyObject *resultobj = 0;
22875 wxDateTime *arg1 = (wxDateTime *) 0 ;
22876 int arg2 ;
22877 int arg3 = (int) 0 ;
22878 int arg4 = (int) 0 ;
22879 int arg5 = (int) 0 ;
22880 wxDateTime *result = 0 ;
22881 void *argp1 = 0 ;
22882 int res1 = 0 ;
22883 int val2 ;
22884 int ecode2 = 0 ;
22885 int val3 ;
22886 int ecode3 = 0 ;
22887 int val4 ;
22888 int ecode4 = 0 ;
22889 int val5 ;
22890 int ecode5 = 0 ;
22891 PyObject * obj0 = 0 ;
22892 PyObject * obj1 = 0 ;
22893 PyObject * obj2 = 0 ;
22894 PyObject * obj3 = 0 ;
22895 PyObject * obj4 = 0 ;
22896 char * kwnames[] = {
22897 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22898 };
22899
22900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22902 if (!SWIG_IsOK(res1)) {
22903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
22904 }
22905 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22906 ecode2 = SWIG_AsVal_int(obj1, &val2);
22907 if (!SWIG_IsOK(ecode2)) {
22908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
22909 }
22910 arg2 = static_cast< int >(val2);
22911 if (obj2) {
22912 ecode3 = SWIG_AsVal_int(obj2, &val3);
22913 if (!SWIG_IsOK(ecode3)) {
22914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
22915 }
22916 arg3 = static_cast< int >(val3);
22917 }
22918 if (obj3) {
22919 ecode4 = SWIG_AsVal_int(obj3, &val4);
22920 if (!SWIG_IsOK(ecode4)) {
22921 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
22922 }
22923 arg4 = static_cast< int >(val4);
22924 }
22925 if (obj4) {
22926 ecode5 = SWIG_AsVal_int(obj4, &val5);
22927 if (!SWIG_IsOK(ecode5)) {
22928 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
22929 }
22930 arg5 = static_cast< int >(val5);
22931 }
22932 {
22933 PyThreadState* __tstate = wxPyBeginAllowThreads();
22934 {
22935 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
22936 result = (wxDateTime *) &_result_ref;
22937 }
22938 wxPyEndAllowThreads(__tstate);
22939 if (PyErr_Occurred()) SWIG_fail;
22940 }
22941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22942 return resultobj;
22943 fail:
22944 return NULL;
22945 }
22946
22947
22948 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22949 PyObject *resultobj = 0;
22950 wxDateTime *arg1 = (wxDateTime *) 0 ;
22951 int arg2 ;
22952 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22953 int arg4 = (int) wxDateTime::Inv_Year ;
22954 int arg5 = (int) 0 ;
22955 int arg6 = (int) 0 ;
22956 int arg7 = (int) 0 ;
22957 int arg8 = (int) 0 ;
22958 wxDateTime *result = 0 ;
22959 void *argp1 = 0 ;
22960 int res1 = 0 ;
22961 int val2 ;
22962 int ecode2 = 0 ;
22963 int val3 ;
22964 int ecode3 = 0 ;
22965 int val4 ;
22966 int ecode4 = 0 ;
22967 int val5 ;
22968 int ecode5 = 0 ;
22969 int val6 ;
22970 int ecode6 = 0 ;
22971 int val7 ;
22972 int ecode7 = 0 ;
22973 int val8 ;
22974 int ecode8 = 0 ;
22975 PyObject * obj0 = 0 ;
22976 PyObject * obj1 = 0 ;
22977 PyObject * obj2 = 0 ;
22978 PyObject * obj3 = 0 ;
22979 PyObject * obj4 = 0 ;
22980 PyObject * obj5 = 0 ;
22981 PyObject * obj6 = 0 ;
22982 PyObject * obj7 = 0 ;
22983 char * kwnames[] = {
22984 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22985 };
22986
22987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
22988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22989 if (!SWIG_IsOK(res1)) {
22990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
22991 }
22992 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22993 ecode2 = SWIG_AsVal_int(obj1, &val2);
22994 if (!SWIG_IsOK(ecode2)) {
22995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
22996 }
22997 arg2 = static_cast< int >(val2);
22998 if (obj2) {
22999 ecode3 = SWIG_AsVal_int(obj2, &val3);
23000 if (!SWIG_IsOK(ecode3)) {
23001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23002 }
23003 arg3 = static_cast< wxDateTime::Month >(val3);
23004 }
23005 if (obj3) {
23006 ecode4 = SWIG_AsVal_int(obj3, &val4);
23007 if (!SWIG_IsOK(ecode4)) {
23008 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
23009 }
23010 arg4 = static_cast< int >(val4);
23011 }
23012 if (obj4) {
23013 ecode5 = SWIG_AsVal_int(obj4, &val5);
23014 if (!SWIG_IsOK(ecode5)) {
23015 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
23016 }
23017 arg5 = static_cast< int >(val5);
23018 }
23019 if (obj5) {
23020 ecode6 = SWIG_AsVal_int(obj5, &val6);
23021 if (!SWIG_IsOK(ecode6)) {
23022 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
23023 }
23024 arg6 = static_cast< int >(val6);
23025 }
23026 if (obj6) {
23027 ecode7 = SWIG_AsVal_int(obj6, &val7);
23028 if (!SWIG_IsOK(ecode7)) {
23029 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
23030 }
23031 arg7 = static_cast< int >(val7);
23032 }
23033 if (obj7) {
23034 ecode8 = SWIG_AsVal_int(obj7, &val8);
23035 if (!SWIG_IsOK(ecode8)) {
23036 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
23037 }
23038 arg8 = static_cast< int >(val8);
23039 }
23040 {
23041 PyThreadState* __tstate = wxPyBeginAllowThreads();
23042 {
23043 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
23044 result = (wxDateTime *) &_result_ref;
23045 }
23046 wxPyEndAllowThreads(__tstate);
23047 if (PyErr_Occurred()) SWIG_fail;
23048 }
23049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23050 return resultobj;
23051 fail:
23052 return NULL;
23053 }
23054
23055
23056 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23057 PyObject *resultobj = 0;
23058 wxDateTime *arg1 = (wxDateTime *) 0 ;
23059 wxDateTime *result = 0 ;
23060 void *argp1 = 0 ;
23061 int res1 = 0 ;
23062 PyObject *swig_obj[1] ;
23063
23064 if (!args) SWIG_fail;
23065 swig_obj[0] = args;
23066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23067 if (!SWIG_IsOK(res1)) {
23068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23069 }
23070 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23071 {
23072 PyThreadState* __tstate = wxPyBeginAllowThreads();
23073 {
23074 wxDateTime &_result_ref = (arg1)->ResetTime();
23075 result = (wxDateTime *) &_result_ref;
23076 }
23077 wxPyEndAllowThreads(__tstate);
23078 if (PyErr_Occurred()) SWIG_fail;
23079 }
23080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23081 return resultobj;
23082 fail:
23083 return NULL;
23084 }
23085
23086
23087 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23088 PyObject *resultobj = 0;
23089 wxDateTime *arg1 = (wxDateTime *) 0 ;
23090 int arg2 ;
23091 wxDateTime *result = 0 ;
23092 void *argp1 = 0 ;
23093 int res1 = 0 ;
23094 int val2 ;
23095 int ecode2 = 0 ;
23096 PyObject * obj0 = 0 ;
23097 PyObject * obj1 = 0 ;
23098 char * kwnames[] = {
23099 (char *) "self",(char *) "year", NULL
23100 };
23101
23102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
23103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23104 if (!SWIG_IsOK(res1)) {
23105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
23106 }
23107 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23108 ecode2 = SWIG_AsVal_int(obj1, &val2);
23109 if (!SWIG_IsOK(ecode2)) {
23110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
23111 }
23112 arg2 = static_cast< int >(val2);
23113 {
23114 PyThreadState* __tstate = wxPyBeginAllowThreads();
23115 {
23116 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
23117 result = (wxDateTime *) &_result_ref;
23118 }
23119 wxPyEndAllowThreads(__tstate);
23120 if (PyErr_Occurred()) SWIG_fail;
23121 }
23122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23123 return resultobj;
23124 fail:
23125 return NULL;
23126 }
23127
23128
23129 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23130 PyObject *resultobj = 0;
23131 wxDateTime *arg1 = (wxDateTime *) 0 ;
23132 wxDateTime::Month arg2 ;
23133 wxDateTime *result = 0 ;
23134 void *argp1 = 0 ;
23135 int res1 = 0 ;
23136 int val2 ;
23137 int ecode2 = 0 ;
23138 PyObject * obj0 = 0 ;
23139 PyObject * obj1 = 0 ;
23140 char * kwnames[] = {
23141 (char *) "self",(char *) "month", NULL
23142 };
23143
23144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
23145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23146 if (!SWIG_IsOK(res1)) {
23147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
23148 }
23149 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23150 ecode2 = SWIG_AsVal_int(obj1, &val2);
23151 if (!SWIG_IsOK(ecode2)) {
23152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23153 }
23154 arg2 = static_cast< wxDateTime::Month >(val2);
23155 {
23156 PyThreadState* __tstate = wxPyBeginAllowThreads();
23157 {
23158 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
23159 result = (wxDateTime *) &_result_ref;
23160 }
23161 wxPyEndAllowThreads(__tstate);
23162 if (PyErr_Occurred()) SWIG_fail;
23163 }
23164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23165 return resultobj;
23166 fail:
23167 return NULL;
23168 }
23169
23170
23171 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23172 PyObject *resultobj = 0;
23173 wxDateTime *arg1 = (wxDateTime *) 0 ;
23174 int arg2 ;
23175 wxDateTime *result = 0 ;
23176 void *argp1 = 0 ;
23177 int res1 = 0 ;
23178 int val2 ;
23179 int ecode2 = 0 ;
23180 PyObject * obj0 = 0 ;
23181 PyObject * obj1 = 0 ;
23182 char * kwnames[] = {
23183 (char *) "self",(char *) "day", NULL
23184 };
23185
23186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
23187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23188 if (!SWIG_IsOK(res1)) {
23189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23190 }
23191 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23192 ecode2 = SWIG_AsVal_int(obj1, &val2);
23193 if (!SWIG_IsOK(ecode2)) {
23194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
23195 }
23196 arg2 = static_cast< int >(val2);
23197 {
23198 PyThreadState* __tstate = wxPyBeginAllowThreads();
23199 {
23200 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
23201 result = (wxDateTime *) &_result_ref;
23202 }
23203 wxPyEndAllowThreads(__tstate);
23204 if (PyErr_Occurred()) SWIG_fail;
23205 }
23206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23207 return resultobj;
23208 fail:
23209 return NULL;
23210 }
23211
23212
23213 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23214 PyObject *resultobj = 0;
23215 wxDateTime *arg1 = (wxDateTime *) 0 ;
23216 int arg2 ;
23217 wxDateTime *result = 0 ;
23218 void *argp1 = 0 ;
23219 int res1 = 0 ;
23220 int val2 ;
23221 int ecode2 = 0 ;
23222 PyObject * obj0 = 0 ;
23223 PyObject * obj1 = 0 ;
23224 char * kwnames[] = {
23225 (char *) "self",(char *) "hour", NULL
23226 };
23227
23228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
23229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23230 if (!SWIG_IsOK(res1)) {
23231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
23232 }
23233 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23234 ecode2 = SWIG_AsVal_int(obj1, &val2);
23235 if (!SWIG_IsOK(ecode2)) {
23236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
23237 }
23238 arg2 = static_cast< int >(val2);
23239 {
23240 PyThreadState* __tstate = wxPyBeginAllowThreads();
23241 {
23242 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
23243 result = (wxDateTime *) &_result_ref;
23244 }
23245 wxPyEndAllowThreads(__tstate);
23246 if (PyErr_Occurred()) SWIG_fail;
23247 }
23248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23249 return resultobj;
23250 fail:
23251 return NULL;
23252 }
23253
23254
23255 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23256 PyObject *resultobj = 0;
23257 wxDateTime *arg1 = (wxDateTime *) 0 ;
23258 int arg2 ;
23259 wxDateTime *result = 0 ;
23260 void *argp1 = 0 ;
23261 int res1 = 0 ;
23262 int val2 ;
23263 int ecode2 = 0 ;
23264 PyObject * obj0 = 0 ;
23265 PyObject * obj1 = 0 ;
23266 char * kwnames[] = {
23267 (char *) "self",(char *) "minute", NULL
23268 };
23269
23270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
23271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23272 if (!SWIG_IsOK(res1)) {
23273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
23274 }
23275 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23276 ecode2 = SWIG_AsVal_int(obj1, &val2);
23277 if (!SWIG_IsOK(ecode2)) {
23278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
23279 }
23280 arg2 = static_cast< int >(val2);
23281 {
23282 PyThreadState* __tstate = wxPyBeginAllowThreads();
23283 {
23284 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
23285 result = (wxDateTime *) &_result_ref;
23286 }
23287 wxPyEndAllowThreads(__tstate);
23288 if (PyErr_Occurred()) SWIG_fail;
23289 }
23290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23291 return resultobj;
23292 fail:
23293 return NULL;
23294 }
23295
23296
23297 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23298 PyObject *resultobj = 0;
23299 wxDateTime *arg1 = (wxDateTime *) 0 ;
23300 int arg2 ;
23301 wxDateTime *result = 0 ;
23302 void *argp1 = 0 ;
23303 int res1 = 0 ;
23304 int val2 ;
23305 int ecode2 = 0 ;
23306 PyObject * obj0 = 0 ;
23307 PyObject * obj1 = 0 ;
23308 char * kwnames[] = {
23309 (char *) "self",(char *) "second", NULL
23310 };
23311
23312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
23313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23314 if (!SWIG_IsOK(res1)) {
23315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23316 }
23317 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23318 ecode2 = SWIG_AsVal_int(obj1, &val2);
23319 if (!SWIG_IsOK(ecode2)) {
23320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
23321 }
23322 arg2 = static_cast< int >(val2);
23323 {
23324 PyThreadState* __tstate = wxPyBeginAllowThreads();
23325 {
23326 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
23327 result = (wxDateTime *) &_result_ref;
23328 }
23329 wxPyEndAllowThreads(__tstate);
23330 if (PyErr_Occurred()) SWIG_fail;
23331 }
23332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23333 return resultobj;
23334 fail:
23335 return NULL;
23336 }
23337
23338
23339 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23340 PyObject *resultobj = 0;
23341 wxDateTime *arg1 = (wxDateTime *) 0 ;
23342 int arg2 ;
23343 wxDateTime *result = 0 ;
23344 void *argp1 = 0 ;
23345 int res1 = 0 ;
23346 int val2 ;
23347 int ecode2 = 0 ;
23348 PyObject * obj0 = 0 ;
23349 PyObject * obj1 = 0 ;
23350 char * kwnames[] = {
23351 (char *) "self",(char *) "millisecond", NULL
23352 };
23353
23354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
23355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23356 if (!SWIG_IsOK(res1)) {
23357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23358 }
23359 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23360 ecode2 = SWIG_AsVal_int(obj1, &val2);
23361 if (!SWIG_IsOK(ecode2)) {
23362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
23363 }
23364 arg2 = static_cast< int >(val2);
23365 {
23366 PyThreadState* __tstate = wxPyBeginAllowThreads();
23367 {
23368 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
23369 result = (wxDateTime *) &_result_ref;
23370 }
23371 wxPyEndAllowThreads(__tstate);
23372 if (PyErr_Occurred()) SWIG_fail;
23373 }
23374 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23375 return resultobj;
23376 fail:
23377 return NULL;
23378 }
23379
23380
23381 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23382 PyObject *resultobj = 0;
23383 wxDateTime *arg1 = (wxDateTime *) 0 ;
23384 wxDateTime::WeekDay arg2 ;
23385 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23386 wxDateTime *result = 0 ;
23387 void *argp1 = 0 ;
23388 int res1 = 0 ;
23389 int val2 ;
23390 int ecode2 = 0 ;
23391 int val3 ;
23392 int ecode3 = 0 ;
23393 PyObject * obj0 = 0 ;
23394 PyObject * obj1 = 0 ;
23395 PyObject * obj2 = 0 ;
23396 char * kwnames[] = {
23397 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23398 };
23399
23400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23402 if (!SWIG_IsOK(res1)) {
23403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23404 }
23405 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23406 ecode2 = SWIG_AsVal_int(obj1, &val2);
23407 if (!SWIG_IsOK(ecode2)) {
23408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23409 }
23410 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23411 if (obj2) {
23412 ecode3 = SWIG_AsVal_int(obj2, &val3);
23413 if (!SWIG_IsOK(ecode3)) {
23414 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23415 }
23416 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23417 }
23418 {
23419 PyThreadState* __tstate = wxPyBeginAllowThreads();
23420 {
23421 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
23422 result = (wxDateTime *) &_result_ref;
23423 }
23424 wxPyEndAllowThreads(__tstate);
23425 if (PyErr_Occurred()) SWIG_fail;
23426 }
23427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23428 return resultobj;
23429 fail:
23430 return NULL;
23431 }
23432
23433
23434 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23435 PyObject *resultobj = 0;
23436 wxDateTime *arg1 = (wxDateTime *) 0 ;
23437 wxDateTime::WeekDay arg2 ;
23438 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23439 wxDateTime result;
23440 void *argp1 = 0 ;
23441 int res1 = 0 ;
23442 int val2 ;
23443 int ecode2 = 0 ;
23444 int val3 ;
23445 int ecode3 = 0 ;
23446 PyObject * obj0 = 0 ;
23447 PyObject * obj1 = 0 ;
23448 PyObject * obj2 = 0 ;
23449 char * kwnames[] = {
23450 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23451 };
23452
23453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23455 if (!SWIG_IsOK(res1)) {
23456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23457 }
23458 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23459 ecode2 = SWIG_AsVal_int(obj1, &val2);
23460 if (!SWIG_IsOK(ecode2)) {
23461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23462 }
23463 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23464 if (obj2) {
23465 ecode3 = SWIG_AsVal_int(obj2, &val3);
23466 if (!SWIG_IsOK(ecode3)) {
23467 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23468 }
23469 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23470 }
23471 {
23472 PyThreadState* __tstate = wxPyBeginAllowThreads();
23473 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
23474 wxPyEndAllowThreads(__tstate);
23475 if (PyErr_Occurred()) SWIG_fail;
23476 }
23477 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23478 return resultobj;
23479 fail:
23480 return NULL;
23481 }
23482
23483
23484 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23485 PyObject *resultobj = 0;
23486 wxDateTime *arg1 = (wxDateTime *) 0 ;
23487 wxDateTime::WeekDay arg2 ;
23488 wxDateTime *result = 0 ;
23489 void *argp1 = 0 ;
23490 int res1 = 0 ;
23491 int val2 ;
23492 int ecode2 = 0 ;
23493 PyObject * obj0 = 0 ;
23494 PyObject * obj1 = 0 ;
23495 char * kwnames[] = {
23496 (char *) "self",(char *) "weekday", NULL
23497 };
23498
23499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23501 if (!SWIG_IsOK(res1)) {
23502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23503 }
23504 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23505 ecode2 = SWIG_AsVal_int(obj1, &val2);
23506 if (!SWIG_IsOK(ecode2)) {
23507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23508 }
23509 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23510 {
23511 PyThreadState* __tstate = wxPyBeginAllowThreads();
23512 {
23513 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
23514 result = (wxDateTime *) &_result_ref;
23515 }
23516 wxPyEndAllowThreads(__tstate);
23517 if (PyErr_Occurred()) SWIG_fail;
23518 }
23519 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23520 return resultobj;
23521 fail:
23522 return NULL;
23523 }
23524
23525
23526 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23527 PyObject *resultobj = 0;
23528 wxDateTime *arg1 = (wxDateTime *) 0 ;
23529 wxDateTime::WeekDay arg2 ;
23530 wxDateTime result;
23531 void *argp1 = 0 ;
23532 int res1 = 0 ;
23533 int val2 ;
23534 int ecode2 = 0 ;
23535 PyObject * obj0 = 0 ;
23536 PyObject * obj1 = 0 ;
23537 char * kwnames[] = {
23538 (char *) "self",(char *) "weekday", NULL
23539 };
23540
23541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23543 if (!SWIG_IsOK(res1)) {
23544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23545 }
23546 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23547 ecode2 = SWIG_AsVal_int(obj1, &val2);
23548 if (!SWIG_IsOK(ecode2)) {
23549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23550 }
23551 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23552 {
23553 PyThreadState* __tstate = wxPyBeginAllowThreads();
23554 result = (arg1)->GetNextWeekDay(arg2);
23555 wxPyEndAllowThreads(__tstate);
23556 if (PyErr_Occurred()) SWIG_fail;
23557 }
23558 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23559 return resultobj;
23560 fail:
23561 return NULL;
23562 }
23563
23564
23565 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23566 PyObject *resultobj = 0;
23567 wxDateTime *arg1 = (wxDateTime *) 0 ;
23568 wxDateTime::WeekDay arg2 ;
23569 wxDateTime *result = 0 ;
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_SetToPrevWeekDay",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_SetToPrevWeekDay" "', 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_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23589 }
23590 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23591 {
23592 PyThreadState* __tstate = wxPyBeginAllowThreads();
23593 {
23594 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
23595 result = (wxDateTime *) &_result_ref;
23596 }
23597 wxPyEndAllowThreads(__tstate);
23598 if (PyErr_Occurred()) SWIG_fail;
23599 }
23600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23601 return resultobj;
23602 fail:
23603 return NULL;
23604 }
23605
23606
23607 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23608 PyObject *resultobj = 0;
23609 wxDateTime *arg1 = (wxDateTime *) 0 ;
23610 wxDateTime::WeekDay arg2 ;
23611 wxDateTime result;
23612 void *argp1 = 0 ;
23613 int res1 = 0 ;
23614 int val2 ;
23615 int ecode2 = 0 ;
23616 PyObject * obj0 = 0 ;
23617 PyObject * obj1 = 0 ;
23618 char * kwnames[] = {
23619 (char *) "self",(char *) "weekday", NULL
23620 };
23621
23622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23624 if (!SWIG_IsOK(res1)) {
23625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23626 }
23627 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23628 ecode2 = SWIG_AsVal_int(obj1, &val2);
23629 if (!SWIG_IsOK(ecode2)) {
23630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23631 }
23632 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23633 {
23634 PyThreadState* __tstate = wxPyBeginAllowThreads();
23635 result = (arg1)->GetPrevWeekDay(arg2);
23636 wxPyEndAllowThreads(__tstate);
23637 if (PyErr_Occurred()) SWIG_fail;
23638 }
23639 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23640 return resultobj;
23641 fail:
23642 return NULL;
23643 }
23644
23645
23646 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23647 PyObject *resultobj = 0;
23648 wxDateTime *arg1 = (wxDateTime *) 0 ;
23649 wxDateTime::WeekDay arg2 ;
23650 int arg3 = (int) 1 ;
23651 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23652 int arg5 = (int) wxDateTime::Inv_Year ;
23653 bool result;
23654 void *argp1 = 0 ;
23655 int res1 = 0 ;
23656 int val2 ;
23657 int ecode2 = 0 ;
23658 int val3 ;
23659 int ecode3 = 0 ;
23660 int val4 ;
23661 int ecode4 = 0 ;
23662 int val5 ;
23663 int ecode5 = 0 ;
23664 PyObject * obj0 = 0 ;
23665 PyObject * obj1 = 0 ;
23666 PyObject * obj2 = 0 ;
23667 PyObject * obj3 = 0 ;
23668 PyObject * obj4 = 0 ;
23669 char * kwnames[] = {
23670 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
23671 };
23672
23673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23675 if (!SWIG_IsOK(res1)) {
23676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23677 }
23678 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23679 ecode2 = SWIG_AsVal_int(obj1, &val2);
23680 if (!SWIG_IsOK(ecode2)) {
23681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23682 }
23683 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23684 if (obj2) {
23685 ecode3 = SWIG_AsVal_int(obj2, &val3);
23686 if (!SWIG_IsOK(ecode3)) {
23687 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
23688 }
23689 arg3 = static_cast< int >(val3);
23690 }
23691 if (obj3) {
23692 ecode4 = SWIG_AsVal_int(obj3, &val4);
23693 if (!SWIG_IsOK(ecode4)) {
23694 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
23695 }
23696 arg4 = static_cast< wxDateTime::Month >(val4);
23697 }
23698 if (obj4) {
23699 ecode5 = SWIG_AsVal_int(obj4, &val5);
23700 if (!SWIG_IsOK(ecode5)) {
23701 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
23702 }
23703 arg5 = static_cast< int >(val5);
23704 }
23705 {
23706 PyThreadState* __tstate = wxPyBeginAllowThreads();
23707 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
23708 wxPyEndAllowThreads(__tstate);
23709 if (PyErr_Occurred()) SWIG_fail;
23710 }
23711 {
23712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23713 }
23714 return resultobj;
23715 fail:
23716 return NULL;
23717 }
23718
23719
23720 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23721 PyObject *resultobj = 0;
23722 wxDateTime *arg1 = (wxDateTime *) 0 ;
23723 wxDateTime::WeekDay arg2 ;
23724 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23725 int arg4 = (int) wxDateTime::Inv_Year ;
23726 bool result;
23727 void *argp1 = 0 ;
23728 int res1 = 0 ;
23729 int val2 ;
23730 int ecode2 = 0 ;
23731 int val3 ;
23732 int ecode3 = 0 ;
23733 int val4 ;
23734 int ecode4 = 0 ;
23735 PyObject * obj0 = 0 ;
23736 PyObject * obj1 = 0 ;
23737 PyObject * obj2 = 0 ;
23738 PyObject * obj3 = 0 ;
23739 char * kwnames[] = {
23740 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23741 };
23742
23743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23745 if (!SWIG_IsOK(res1)) {
23746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23747 }
23748 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23749 ecode2 = SWIG_AsVal_int(obj1, &val2);
23750 if (!SWIG_IsOK(ecode2)) {
23751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23752 }
23753 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23754 if (obj2) {
23755 ecode3 = SWIG_AsVal_int(obj2, &val3);
23756 if (!SWIG_IsOK(ecode3)) {
23757 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23758 }
23759 arg3 = static_cast< wxDateTime::Month >(val3);
23760 }
23761 if (obj3) {
23762 ecode4 = SWIG_AsVal_int(obj3, &val4);
23763 if (!SWIG_IsOK(ecode4)) {
23764 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23765 }
23766 arg4 = static_cast< int >(val4);
23767 }
23768 {
23769 PyThreadState* __tstate = wxPyBeginAllowThreads();
23770 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
23771 wxPyEndAllowThreads(__tstate);
23772 if (PyErr_Occurred()) SWIG_fail;
23773 }
23774 {
23775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23776 }
23777 return resultobj;
23778 fail:
23779 return NULL;
23780 }
23781
23782
23783 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23784 PyObject *resultobj = 0;
23785 wxDateTime *arg1 = (wxDateTime *) 0 ;
23786 wxDateTime::WeekDay arg2 ;
23787 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23788 int arg4 = (int) wxDateTime::Inv_Year ;
23789 wxDateTime result;
23790 void *argp1 = 0 ;
23791 int res1 = 0 ;
23792 int val2 ;
23793 int ecode2 = 0 ;
23794 int val3 ;
23795 int ecode3 = 0 ;
23796 int val4 ;
23797 int ecode4 = 0 ;
23798 PyObject * obj0 = 0 ;
23799 PyObject * obj1 = 0 ;
23800 PyObject * obj2 = 0 ;
23801 PyObject * obj3 = 0 ;
23802 char * kwnames[] = {
23803 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23804 };
23805
23806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23808 if (!SWIG_IsOK(res1)) {
23809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23810 }
23811 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23812 ecode2 = SWIG_AsVal_int(obj1, &val2);
23813 if (!SWIG_IsOK(ecode2)) {
23814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23815 }
23816 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23817 if (obj2) {
23818 ecode3 = SWIG_AsVal_int(obj2, &val3);
23819 if (!SWIG_IsOK(ecode3)) {
23820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23821 }
23822 arg3 = static_cast< wxDateTime::Month >(val3);
23823 }
23824 if (obj3) {
23825 ecode4 = SWIG_AsVal_int(obj3, &val4);
23826 if (!SWIG_IsOK(ecode4)) {
23827 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23828 }
23829 arg4 = static_cast< int >(val4);
23830 }
23831 {
23832 PyThreadState* __tstate = wxPyBeginAllowThreads();
23833 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
23834 wxPyEndAllowThreads(__tstate);
23835 if (PyErr_Occurred()) SWIG_fail;
23836 }
23837 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23838 return resultobj;
23839 fail:
23840 return NULL;
23841 }
23842
23843
23844 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23845 PyObject *resultobj = 0;
23846 wxDateTime *arg1 = (wxDateTime *) 0 ;
23847 int arg2 ;
23848 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23849 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23850 bool result;
23851 void *argp1 = 0 ;
23852 int res1 = 0 ;
23853 int val2 ;
23854 int ecode2 = 0 ;
23855 int val3 ;
23856 int ecode3 = 0 ;
23857 int val4 ;
23858 int ecode4 = 0 ;
23859 PyObject * obj0 = 0 ;
23860 PyObject * obj1 = 0 ;
23861 PyObject * obj2 = 0 ;
23862 PyObject * obj3 = 0 ;
23863 char * kwnames[] = {
23864 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23865 };
23866
23867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23869 if (!SWIG_IsOK(res1)) {
23870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23871 }
23872 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23873 ecode2 = SWIG_AsVal_int(obj1, &val2);
23874 if (!SWIG_IsOK(ecode2)) {
23875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
23876 }
23877 arg2 = static_cast< int >(val2);
23878 if (obj2) {
23879 ecode3 = SWIG_AsVal_int(obj2, &val3);
23880 if (!SWIG_IsOK(ecode3)) {
23881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23882 }
23883 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23884 }
23885 if (obj3) {
23886 ecode4 = SWIG_AsVal_int(obj3, &val4);
23887 if (!SWIG_IsOK(ecode4)) {
23888 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23889 }
23890 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23891 }
23892 {
23893 PyThreadState* __tstate = wxPyBeginAllowThreads();
23894 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
23895 wxPyEndAllowThreads(__tstate);
23896 if (PyErr_Occurred()) SWIG_fail;
23897 }
23898 {
23899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23900 }
23901 return resultobj;
23902 fail:
23903 return NULL;
23904 }
23905
23906
23907 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23908 PyObject *resultobj = 0;
23909 wxDateTime *arg1 = (wxDateTime *) 0 ;
23910 int arg2 ;
23911 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23912 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23913 wxDateTime result;
23914 void *argp1 = 0 ;
23915 int res1 = 0 ;
23916 int val2 ;
23917 int ecode2 = 0 ;
23918 int val3 ;
23919 int ecode3 = 0 ;
23920 int val4 ;
23921 int ecode4 = 0 ;
23922 PyObject * obj0 = 0 ;
23923 PyObject * obj1 = 0 ;
23924 PyObject * obj2 = 0 ;
23925 PyObject * obj3 = 0 ;
23926 char * kwnames[] = {
23927 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23928 };
23929
23930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23932 if (!SWIG_IsOK(res1)) {
23933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23934 }
23935 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23936 ecode2 = SWIG_AsVal_int(obj1, &val2);
23937 if (!SWIG_IsOK(ecode2)) {
23938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
23939 }
23940 arg2 = static_cast< int >(val2);
23941 if (obj2) {
23942 ecode3 = SWIG_AsVal_int(obj2, &val3);
23943 if (!SWIG_IsOK(ecode3)) {
23944 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23945 }
23946 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23947 }
23948 if (obj3) {
23949 ecode4 = SWIG_AsVal_int(obj3, &val4);
23950 if (!SWIG_IsOK(ecode4)) {
23951 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23952 }
23953 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23954 }
23955 {
23956 PyThreadState* __tstate = wxPyBeginAllowThreads();
23957 result = (arg1)->GetWeek(arg2,arg3,arg4);
23958 wxPyEndAllowThreads(__tstate);
23959 if (PyErr_Occurred()) SWIG_fail;
23960 }
23961 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23962 return resultobj;
23963 fail:
23964 return NULL;
23965 }
23966
23967
23968 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23969 PyObject *resultobj = 0;
23970 int arg1 ;
23971 int arg2 ;
23972 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23973 wxDateTime result;
23974 int val1 ;
23975 int ecode1 = 0 ;
23976 int val2 ;
23977 int ecode2 = 0 ;
23978 int val3 ;
23979 int ecode3 = 0 ;
23980 PyObject * obj0 = 0 ;
23981 PyObject * obj1 = 0 ;
23982 PyObject * obj2 = 0 ;
23983 char * kwnames[] = {
23984 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
23985 };
23986
23987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23988 ecode1 = SWIG_AsVal_int(obj0, &val1);
23989 if (!SWIG_IsOK(ecode1)) {
23990 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
23991 }
23992 arg1 = static_cast< int >(val1);
23993 ecode2 = SWIG_AsVal_int(obj1, &val2);
23994 if (!SWIG_IsOK(ecode2)) {
23995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
23996 }
23997 arg2 = static_cast< int >(val2);
23998 if (obj2) {
23999 ecode3 = SWIG_AsVal_int(obj2, &val3);
24000 if (!SWIG_IsOK(ecode3)) {
24001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24002 }
24003 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24004 }
24005 {
24006 PyThreadState* __tstate = wxPyBeginAllowThreads();
24007 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
24008 wxPyEndAllowThreads(__tstate);
24009 if (PyErr_Occurred()) SWIG_fail;
24010 }
24011 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24012 return resultobj;
24013 fail:
24014 return NULL;
24015 }
24016
24017
24018 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24019 PyObject *resultobj = 0;
24020 wxDateTime *arg1 = (wxDateTime *) 0 ;
24021 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24022 int arg3 = (int) wxDateTime::Inv_Year ;
24023 wxDateTime *result = 0 ;
24024 void *argp1 = 0 ;
24025 int res1 = 0 ;
24026 int val2 ;
24027 int ecode2 = 0 ;
24028 int val3 ;
24029 int ecode3 = 0 ;
24030 PyObject * obj0 = 0 ;
24031 PyObject * obj1 = 0 ;
24032 PyObject * obj2 = 0 ;
24033 char * kwnames[] = {
24034 (char *) "self",(char *) "month",(char *) "year", NULL
24035 };
24036
24037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24039 if (!SWIG_IsOK(res1)) {
24040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24041 }
24042 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24043 if (obj1) {
24044 ecode2 = SWIG_AsVal_int(obj1, &val2);
24045 if (!SWIG_IsOK(ecode2)) {
24046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24047 }
24048 arg2 = static_cast< wxDateTime::Month >(val2);
24049 }
24050 if (obj2) {
24051 ecode3 = SWIG_AsVal_int(obj2, &val3);
24052 if (!SWIG_IsOK(ecode3)) {
24053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24054 }
24055 arg3 = static_cast< int >(val3);
24056 }
24057 {
24058 PyThreadState* __tstate = wxPyBeginAllowThreads();
24059 {
24060 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
24061 result = (wxDateTime *) &_result_ref;
24062 }
24063 wxPyEndAllowThreads(__tstate);
24064 if (PyErr_Occurred()) SWIG_fail;
24065 }
24066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24067 return resultobj;
24068 fail:
24069 return NULL;
24070 }
24071
24072
24073 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24074 PyObject *resultobj = 0;
24075 wxDateTime *arg1 = (wxDateTime *) 0 ;
24076 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24077 int arg3 = (int) wxDateTime::Inv_Year ;
24078 wxDateTime result;
24079 void *argp1 = 0 ;
24080 int res1 = 0 ;
24081 int val2 ;
24082 int ecode2 = 0 ;
24083 int val3 ;
24084 int ecode3 = 0 ;
24085 PyObject * obj0 = 0 ;
24086 PyObject * obj1 = 0 ;
24087 PyObject * obj2 = 0 ;
24088 char * kwnames[] = {
24089 (char *) "self",(char *) "month",(char *) "year", NULL
24090 };
24091
24092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24094 if (!SWIG_IsOK(res1)) {
24095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24096 }
24097 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24098 if (obj1) {
24099 ecode2 = SWIG_AsVal_int(obj1, &val2);
24100 if (!SWIG_IsOK(ecode2)) {
24101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24102 }
24103 arg2 = static_cast< wxDateTime::Month >(val2);
24104 }
24105 if (obj2) {
24106 ecode3 = SWIG_AsVal_int(obj2, &val3);
24107 if (!SWIG_IsOK(ecode3)) {
24108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24109 }
24110 arg3 = static_cast< int >(val3);
24111 }
24112 {
24113 PyThreadState* __tstate = wxPyBeginAllowThreads();
24114 result = (arg1)->GetLastMonthDay(arg2,arg3);
24115 wxPyEndAllowThreads(__tstate);
24116 if (PyErr_Occurred()) SWIG_fail;
24117 }
24118 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24119 return resultobj;
24120 fail:
24121 return NULL;
24122 }
24123
24124
24125 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24126 PyObject *resultobj = 0;
24127 wxDateTime *arg1 = (wxDateTime *) 0 ;
24128 int arg2 ;
24129 wxDateTime *result = 0 ;
24130 void *argp1 = 0 ;
24131 int res1 = 0 ;
24132 int val2 ;
24133 int ecode2 = 0 ;
24134 PyObject * obj0 = 0 ;
24135 PyObject * obj1 = 0 ;
24136 char * kwnames[] = {
24137 (char *) "self",(char *) "yday", NULL
24138 };
24139
24140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24142 if (!SWIG_IsOK(res1)) {
24143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24144 }
24145 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24146 ecode2 = SWIG_AsVal_int(obj1, &val2);
24147 if (!SWIG_IsOK(ecode2)) {
24148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
24149 }
24150 arg2 = static_cast< int >(val2);
24151 {
24152 PyThreadState* __tstate = wxPyBeginAllowThreads();
24153 {
24154 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
24155 result = (wxDateTime *) &_result_ref;
24156 }
24157 wxPyEndAllowThreads(__tstate);
24158 if (PyErr_Occurred()) SWIG_fail;
24159 }
24160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24161 return resultobj;
24162 fail:
24163 return NULL;
24164 }
24165
24166
24167 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24168 PyObject *resultobj = 0;
24169 wxDateTime *arg1 = (wxDateTime *) 0 ;
24170 int arg2 ;
24171 wxDateTime result;
24172 void *argp1 = 0 ;
24173 int res1 = 0 ;
24174 int val2 ;
24175 int ecode2 = 0 ;
24176 PyObject * obj0 = 0 ;
24177 PyObject * obj1 = 0 ;
24178 char * kwnames[] = {
24179 (char *) "self",(char *) "yday", NULL
24180 };
24181
24182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24184 if (!SWIG_IsOK(res1)) {
24185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24186 }
24187 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24188 ecode2 = SWIG_AsVal_int(obj1, &val2);
24189 if (!SWIG_IsOK(ecode2)) {
24190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
24191 }
24192 arg2 = static_cast< int >(val2);
24193 {
24194 PyThreadState* __tstate = wxPyBeginAllowThreads();
24195 result = (arg1)->GetYearDay(arg2);
24196 wxPyEndAllowThreads(__tstate);
24197 if (PyErr_Occurred()) SWIG_fail;
24198 }
24199 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24200 return resultobj;
24201 fail:
24202 return NULL;
24203 }
24204
24205
24206 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24207 PyObject *resultobj = 0;
24208 wxDateTime *arg1 = (wxDateTime *) 0 ;
24209 double result;
24210 void *argp1 = 0 ;
24211 int res1 = 0 ;
24212 PyObject *swig_obj[1] ;
24213
24214 if (!args) SWIG_fail;
24215 swig_obj[0] = args;
24216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24217 if (!SWIG_IsOK(res1)) {
24218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
24219 }
24220 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24221 {
24222 PyThreadState* __tstate = wxPyBeginAllowThreads();
24223 result = (double)(arg1)->GetJulianDayNumber();
24224 wxPyEndAllowThreads(__tstate);
24225 if (PyErr_Occurred()) SWIG_fail;
24226 }
24227 resultobj = SWIG_From_double(static_cast< double >(result));
24228 return resultobj;
24229 fail:
24230 return NULL;
24231 }
24232
24233
24234 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24235 PyObject *resultobj = 0;
24236 wxDateTime *arg1 = (wxDateTime *) 0 ;
24237 double result;
24238 void *argp1 = 0 ;
24239 int res1 = 0 ;
24240 PyObject *swig_obj[1] ;
24241
24242 if (!args) SWIG_fail;
24243 swig_obj[0] = args;
24244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24245 if (!SWIG_IsOK(res1)) {
24246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24247 }
24248 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24249 {
24250 PyThreadState* __tstate = wxPyBeginAllowThreads();
24251 result = (double)(arg1)->GetJDN();
24252 wxPyEndAllowThreads(__tstate);
24253 if (PyErr_Occurred()) SWIG_fail;
24254 }
24255 resultobj = SWIG_From_double(static_cast< double >(result));
24256 return resultobj;
24257 fail:
24258 return NULL;
24259 }
24260
24261
24262 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24263 PyObject *resultobj = 0;
24264 wxDateTime *arg1 = (wxDateTime *) 0 ;
24265 double result;
24266 void *argp1 = 0 ;
24267 int res1 = 0 ;
24268 PyObject *swig_obj[1] ;
24269
24270 if (!args) SWIG_fail;
24271 swig_obj[0] = args;
24272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24273 if (!SWIG_IsOK(res1)) {
24274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24275 }
24276 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24277 {
24278 PyThreadState* __tstate = wxPyBeginAllowThreads();
24279 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
24280 wxPyEndAllowThreads(__tstate);
24281 if (PyErr_Occurred()) SWIG_fail;
24282 }
24283 resultobj = SWIG_From_double(static_cast< double >(result));
24284 return resultobj;
24285 fail:
24286 return NULL;
24287 }
24288
24289
24290 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24291 PyObject *resultobj = 0;
24292 wxDateTime *arg1 = (wxDateTime *) 0 ;
24293 double result;
24294 void *argp1 = 0 ;
24295 int res1 = 0 ;
24296 PyObject *swig_obj[1] ;
24297
24298 if (!args) SWIG_fail;
24299 swig_obj[0] = args;
24300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24301 if (!SWIG_IsOK(res1)) {
24302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
24303 }
24304 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24305 {
24306 PyThreadState* __tstate = wxPyBeginAllowThreads();
24307 result = (double)(arg1)->GetMJD();
24308 wxPyEndAllowThreads(__tstate);
24309 if (PyErr_Occurred()) SWIG_fail;
24310 }
24311 resultobj = SWIG_From_double(static_cast< double >(result));
24312 return resultobj;
24313 fail:
24314 return NULL;
24315 }
24316
24317
24318 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24319 PyObject *resultobj = 0;
24320 wxDateTime *arg1 = (wxDateTime *) 0 ;
24321 double result;
24322 void *argp1 = 0 ;
24323 int res1 = 0 ;
24324 PyObject *swig_obj[1] ;
24325
24326 if (!args) SWIG_fail;
24327 swig_obj[0] = args;
24328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24329 if (!SWIG_IsOK(res1)) {
24330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
24331 }
24332 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24333 {
24334 PyThreadState* __tstate = wxPyBeginAllowThreads();
24335 result = (double)(arg1)->GetRataDie();
24336 wxPyEndAllowThreads(__tstate);
24337 if (PyErr_Occurred()) SWIG_fail;
24338 }
24339 resultobj = SWIG_From_double(static_cast< double >(result));
24340 return resultobj;
24341 fail:
24342 return NULL;
24343 }
24344
24345
24346 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24347 PyObject *resultobj = 0;
24348 wxDateTime *arg1 = (wxDateTime *) 0 ;
24349 wxDateTime::TimeZone *arg2 = 0 ;
24350 bool arg3 = (bool) false ;
24351 wxDateTime result;
24352 void *argp1 = 0 ;
24353 int res1 = 0 ;
24354 bool temp2 = false ;
24355 bool val3 ;
24356 int ecode3 = 0 ;
24357 PyObject * obj0 = 0 ;
24358 PyObject * obj1 = 0 ;
24359 PyObject * obj2 = 0 ;
24360 char * kwnames[] = {
24361 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24362 };
24363
24364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24366 if (!SWIG_IsOK(res1)) {
24367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24368 }
24369 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24370 {
24371 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24372 temp2 = true;
24373 }
24374 if (obj2) {
24375 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24376 if (!SWIG_IsOK(ecode3)) {
24377 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
24378 }
24379 arg3 = static_cast< bool >(val3);
24380 }
24381 {
24382 PyThreadState* __tstate = wxPyBeginAllowThreads();
24383 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24384 wxPyEndAllowThreads(__tstate);
24385 if (PyErr_Occurred()) SWIG_fail;
24386 }
24387 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24388 {
24389 if (temp2) delete arg2;
24390 }
24391 return resultobj;
24392 fail:
24393 {
24394 if (temp2) delete arg2;
24395 }
24396 return NULL;
24397 }
24398
24399
24400 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24401 PyObject *resultobj = 0;
24402 wxDateTime *arg1 = (wxDateTime *) 0 ;
24403 wxDateTime::TimeZone *arg2 = 0 ;
24404 bool arg3 = (bool) false ;
24405 wxDateTime *result = 0 ;
24406 void *argp1 = 0 ;
24407 int res1 = 0 ;
24408 bool temp2 = false ;
24409 bool val3 ;
24410 int ecode3 = 0 ;
24411 PyObject * obj0 = 0 ;
24412 PyObject * obj1 = 0 ;
24413 PyObject * obj2 = 0 ;
24414 char * kwnames[] = {
24415 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24416 };
24417
24418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24420 if (!SWIG_IsOK(res1)) {
24421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24422 }
24423 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24424 {
24425 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24426 temp2 = true;
24427 }
24428 if (obj2) {
24429 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24430 if (!SWIG_IsOK(ecode3)) {
24431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
24432 }
24433 arg3 = static_cast< bool >(val3);
24434 }
24435 {
24436 PyThreadState* __tstate = wxPyBeginAllowThreads();
24437 {
24438 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24439 result = (wxDateTime *) &_result_ref;
24440 }
24441 wxPyEndAllowThreads(__tstate);
24442 if (PyErr_Occurred()) SWIG_fail;
24443 }
24444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24445 {
24446 if (temp2) delete arg2;
24447 }
24448 return resultobj;
24449 fail:
24450 {
24451 if (temp2) delete arg2;
24452 }
24453 return NULL;
24454 }
24455
24456
24457 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24458 PyObject *resultobj = 0;
24459 wxDateTime *arg1 = (wxDateTime *) 0 ;
24460 wxDateTime::TimeZone *arg2 = 0 ;
24461 bool arg3 = (bool) false ;
24462 wxDateTime result;
24463 void *argp1 = 0 ;
24464 int res1 = 0 ;
24465 bool temp2 = false ;
24466 bool val3 ;
24467 int ecode3 = 0 ;
24468 PyObject * obj0 = 0 ;
24469 PyObject * obj1 = 0 ;
24470 PyObject * obj2 = 0 ;
24471 char * kwnames[] = {
24472 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24473 };
24474
24475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24477 if (!SWIG_IsOK(res1)) {
24478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24479 }
24480 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24481 {
24482 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24483 temp2 = true;
24484 }
24485 if (obj2) {
24486 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24487 if (!SWIG_IsOK(ecode3)) {
24488 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
24489 }
24490 arg3 = static_cast< bool >(val3);
24491 }
24492 {
24493 PyThreadState* __tstate = wxPyBeginAllowThreads();
24494 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24495 wxPyEndAllowThreads(__tstate);
24496 if (PyErr_Occurred()) SWIG_fail;
24497 }
24498 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24499 {
24500 if (temp2) delete arg2;
24501 }
24502 return resultobj;
24503 fail:
24504 {
24505 if (temp2) delete arg2;
24506 }
24507 return NULL;
24508 }
24509
24510
24511 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24512 PyObject *resultobj = 0;
24513 wxDateTime *arg1 = (wxDateTime *) 0 ;
24514 wxDateTime::TimeZone *arg2 = 0 ;
24515 bool arg3 = (bool) false ;
24516 wxDateTime *result = 0 ;
24517 void *argp1 = 0 ;
24518 int res1 = 0 ;
24519 bool temp2 = false ;
24520 bool val3 ;
24521 int ecode3 = 0 ;
24522 PyObject * obj0 = 0 ;
24523 PyObject * obj1 = 0 ;
24524 PyObject * obj2 = 0 ;
24525 char * kwnames[] = {
24526 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24527 };
24528
24529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24531 if (!SWIG_IsOK(res1)) {
24532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24533 }
24534 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24535 {
24536 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24537 temp2 = true;
24538 }
24539 if (obj2) {
24540 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24541 if (!SWIG_IsOK(ecode3)) {
24542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
24543 }
24544 arg3 = static_cast< bool >(val3);
24545 }
24546 {
24547 PyThreadState* __tstate = wxPyBeginAllowThreads();
24548 {
24549 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24550 result = (wxDateTime *) &_result_ref;
24551 }
24552 wxPyEndAllowThreads(__tstate);
24553 if (PyErr_Occurred()) SWIG_fail;
24554 }
24555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24556 {
24557 if (temp2) delete arg2;
24558 }
24559 return resultobj;
24560 fail:
24561 {
24562 if (temp2) delete arg2;
24563 }
24564 return NULL;
24565 }
24566
24567
24568 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24569 PyObject *resultobj = 0;
24570 wxDateTime *arg1 = (wxDateTime *) 0 ;
24571 bool arg2 = (bool) false ;
24572 wxDateTime result;
24573 void *argp1 = 0 ;
24574 int res1 = 0 ;
24575 bool val2 ;
24576 int ecode2 = 0 ;
24577 PyObject * obj0 = 0 ;
24578 PyObject * obj1 = 0 ;
24579 char * kwnames[] = {
24580 (char *) "self",(char *) "noDST", NULL
24581 };
24582
24583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24585 if (!SWIG_IsOK(res1)) {
24586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24587 }
24588 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24589 if (obj1) {
24590 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24591 if (!SWIG_IsOK(ecode2)) {
24592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
24593 }
24594 arg2 = static_cast< bool >(val2);
24595 }
24596 {
24597 PyThreadState* __tstate = wxPyBeginAllowThreads();
24598 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
24599 wxPyEndAllowThreads(__tstate);
24600 if (PyErr_Occurred()) SWIG_fail;
24601 }
24602 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24603 return resultobj;
24604 fail:
24605 return NULL;
24606 }
24607
24608
24609 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24610 PyObject *resultobj = 0;
24611 wxDateTime *arg1 = (wxDateTime *) 0 ;
24612 bool arg2 = (bool) false ;
24613 wxDateTime *result = 0 ;
24614 void *argp1 = 0 ;
24615 int res1 = 0 ;
24616 bool val2 ;
24617 int ecode2 = 0 ;
24618 PyObject * obj0 = 0 ;
24619 PyObject * obj1 = 0 ;
24620 char * kwnames[] = {
24621 (char *) "self",(char *) "noDST", NULL
24622 };
24623
24624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24626 if (!SWIG_IsOK(res1)) {
24627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24628 }
24629 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24630 if (obj1) {
24631 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24632 if (!SWIG_IsOK(ecode2)) {
24633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
24634 }
24635 arg2 = static_cast< bool >(val2);
24636 }
24637 {
24638 PyThreadState* __tstate = wxPyBeginAllowThreads();
24639 {
24640 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
24641 result = (wxDateTime *) &_result_ref;
24642 }
24643 wxPyEndAllowThreads(__tstate);
24644 if (PyErr_Occurred()) SWIG_fail;
24645 }
24646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24647 return resultobj;
24648 fail:
24649 return NULL;
24650 }
24651
24652
24653 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24654 PyObject *resultobj = 0;
24655 wxDateTime *arg1 = (wxDateTime *) 0 ;
24656 bool arg2 = (bool) false ;
24657 wxDateTime result;
24658 void *argp1 = 0 ;
24659 int res1 = 0 ;
24660 bool val2 ;
24661 int ecode2 = 0 ;
24662 PyObject * obj0 = 0 ;
24663 PyObject * obj1 = 0 ;
24664 char * kwnames[] = {
24665 (char *) "self",(char *) "noDST", NULL
24666 };
24667
24668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24670 if (!SWIG_IsOK(res1)) {
24671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24672 }
24673 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24674 if (obj1) {
24675 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24676 if (!SWIG_IsOK(ecode2)) {
24677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
24678 }
24679 arg2 = static_cast< bool >(val2);
24680 }
24681 {
24682 PyThreadState* __tstate = wxPyBeginAllowThreads();
24683 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
24684 wxPyEndAllowThreads(__tstate);
24685 if (PyErr_Occurred()) SWIG_fail;
24686 }
24687 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24688 return resultobj;
24689 fail:
24690 return NULL;
24691 }
24692
24693
24694 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24695 PyObject *resultobj = 0;
24696 wxDateTime *arg1 = (wxDateTime *) 0 ;
24697 bool arg2 = (bool) false ;
24698 wxDateTime *result = 0 ;
24699 void *argp1 = 0 ;
24700 int res1 = 0 ;
24701 bool val2 ;
24702 int ecode2 = 0 ;
24703 PyObject * obj0 = 0 ;
24704 PyObject * obj1 = 0 ;
24705 char * kwnames[] = {
24706 (char *) "self",(char *) "noDST", NULL
24707 };
24708
24709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24711 if (!SWIG_IsOK(res1)) {
24712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24713 }
24714 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24715 if (obj1) {
24716 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24717 if (!SWIG_IsOK(ecode2)) {
24718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
24719 }
24720 arg2 = static_cast< bool >(val2);
24721 }
24722 {
24723 PyThreadState* __tstate = wxPyBeginAllowThreads();
24724 {
24725 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
24726 result = (wxDateTime *) &_result_ref;
24727 }
24728 wxPyEndAllowThreads(__tstate);
24729 if (PyErr_Occurred()) SWIG_fail;
24730 }
24731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24732 return resultobj;
24733 fail:
24734 return NULL;
24735 }
24736
24737
24738 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24739 PyObject *resultobj = 0;
24740 wxDateTime *arg1 = (wxDateTime *) 0 ;
24741 bool arg2 = (bool) false ;
24742 wxDateTime result;
24743 void *argp1 = 0 ;
24744 int res1 = 0 ;
24745 bool val2 ;
24746 int ecode2 = 0 ;
24747 PyObject * obj0 = 0 ;
24748 PyObject * obj1 = 0 ;
24749 char * kwnames[] = {
24750 (char *) "self",(char *) "noDST", NULL
24751 };
24752
24753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24755 if (!SWIG_IsOK(res1)) {
24756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24757 }
24758 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24759 if (obj1) {
24760 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24761 if (!SWIG_IsOK(ecode2)) {
24762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
24763 }
24764 arg2 = static_cast< bool >(val2);
24765 }
24766 {
24767 PyThreadState* __tstate = wxPyBeginAllowThreads();
24768 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
24769 wxPyEndAllowThreads(__tstate);
24770 if (PyErr_Occurred()) SWIG_fail;
24771 }
24772 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24773 return resultobj;
24774 fail:
24775 return NULL;
24776 }
24777
24778
24779 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24780 PyObject *resultobj = 0;
24781 wxDateTime *arg1 = (wxDateTime *) 0 ;
24782 bool arg2 = (bool) false ;
24783 wxDateTime *result = 0 ;
24784 void *argp1 = 0 ;
24785 int res1 = 0 ;
24786 bool val2 ;
24787 int ecode2 = 0 ;
24788 PyObject * obj0 = 0 ;
24789 PyObject * obj1 = 0 ;
24790 char * kwnames[] = {
24791 (char *) "self",(char *) "noDST", NULL
24792 };
24793
24794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24796 if (!SWIG_IsOK(res1)) {
24797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24798 }
24799 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24800 if (obj1) {
24801 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24802 if (!SWIG_IsOK(ecode2)) {
24803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
24804 }
24805 arg2 = static_cast< bool >(val2);
24806 }
24807 {
24808 PyThreadState* __tstate = wxPyBeginAllowThreads();
24809 {
24810 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
24811 result = (wxDateTime *) &_result_ref;
24812 }
24813 wxPyEndAllowThreads(__tstate);
24814 if (PyErr_Occurred()) SWIG_fail;
24815 }
24816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24817 return resultobj;
24818 fail:
24819 return NULL;
24820 }
24821
24822
24823 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24824 PyObject *resultobj = 0;
24825 wxDateTime *arg1 = (wxDateTime *) 0 ;
24826 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
24827 int result;
24828 void *argp1 = 0 ;
24829 int res1 = 0 ;
24830 int val2 ;
24831 int ecode2 = 0 ;
24832 PyObject * obj0 = 0 ;
24833 PyObject * obj1 = 0 ;
24834 char * kwnames[] = {
24835 (char *) "self",(char *) "country", NULL
24836 };
24837
24838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
24839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24840 if (!SWIG_IsOK(res1)) {
24841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
24842 }
24843 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24844 if (obj1) {
24845 ecode2 = SWIG_AsVal_int(obj1, &val2);
24846 if (!SWIG_IsOK(ecode2)) {
24847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
24848 }
24849 arg2 = static_cast< wxDateTime::Country >(val2);
24850 }
24851 {
24852 PyThreadState* __tstate = wxPyBeginAllowThreads();
24853 result = (int)(arg1)->IsDST(arg2);
24854 wxPyEndAllowThreads(__tstate);
24855 if (PyErr_Occurred()) SWIG_fail;
24856 }
24857 resultobj = SWIG_From_int(static_cast< int >(result));
24858 return resultobj;
24859 fail:
24860 return NULL;
24861 }
24862
24863
24864 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24865 PyObject *resultobj = 0;
24866 wxDateTime *arg1 = (wxDateTime *) 0 ;
24867 bool result;
24868 void *argp1 = 0 ;
24869 int res1 = 0 ;
24870 PyObject *swig_obj[1] ;
24871
24872 if (!args) SWIG_fail;
24873 swig_obj[0] = args;
24874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24875 if (!SWIG_IsOK(res1)) {
24876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24877 }
24878 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24879 {
24880 PyThreadState* __tstate = wxPyBeginAllowThreads();
24881 result = (bool)((wxDateTime const *)arg1)->IsValid();
24882 wxPyEndAllowThreads(__tstate);
24883 if (PyErr_Occurred()) SWIG_fail;
24884 }
24885 {
24886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24887 }
24888 return resultobj;
24889 fail:
24890 return NULL;
24891 }
24892
24893
24894 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24895 PyObject *resultobj = 0;
24896 wxDateTime *arg1 = (wxDateTime *) 0 ;
24897 time_t result;
24898 void *argp1 = 0 ;
24899 int res1 = 0 ;
24900 PyObject *swig_obj[1] ;
24901
24902 if (!args) SWIG_fail;
24903 swig_obj[0] = args;
24904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24905 if (!SWIG_IsOK(res1)) {
24906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24907 }
24908 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24909 {
24910 PyThreadState* __tstate = wxPyBeginAllowThreads();
24911 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
24912 wxPyEndAllowThreads(__tstate);
24913 if (PyErr_Occurred()) SWIG_fail;
24914 }
24915 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
24916 return resultobj;
24917 fail:
24918 return NULL;
24919 }
24920
24921
24922 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24923 PyObject *resultobj = 0;
24924 wxDateTime *arg1 = (wxDateTime *) 0 ;
24925 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24926 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24927 int result;
24928 void *argp1 = 0 ;
24929 int res1 = 0 ;
24930 bool temp2 = false ;
24931 PyObject * obj0 = 0 ;
24932 PyObject * obj1 = 0 ;
24933 char * kwnames[] = {
24934 (char *) "self",(char *) "tz", NULL
24935 };
24936
24937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24939 if (!SWIG_IsOK(res1)) {
24940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24941 }
24942 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24943 if (obj1) {
24944 {
24945 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24946 temp2 = true;
24947 }
24948 }
24949 {
24950 PyThreadState* __tstate = wxPyBeginAllowThreads();
24951 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
24952 wxPyEndAllowThreads(__tstate);
24953 if (PyErr_Occurred()) SWIG_fail;
24954 }
24955 resultobj = SWIG_From_int(static_cast< int >(result));
24956 {
24957 if (temp2) delete arg2;
24958 }
24959 return resultobj;
24960 fail:
24961 {
24962 if (temp2) delete arg2;
24963 }
24964 return NULL;
24965 }
24966
24967
24968 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24969 PyObject *resultobj = 0;
24970 wxDateTime *arg1 = (wxDateTime *) 0 ;
24971 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24972 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24973 wxDateTime::Month result;
24974 void *argp1 = 0 ;
24975 int res1 = 0 ;
24976 bool temp2 = false ;
24977 PyObject * obj0 = 0 ;
24978 PyObject * obj1 = 0 ;
24979 char * kwnames[] = {
24980 (char *) "self",(char *) "tz", NULL
24981 };
24982
24983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24985 if (!SWIG_IsOK(res1)) {
24986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24987 }
24988 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24989 if (obj1) {
24990 {
24991 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24992 temp2 = true;
24993 }
24994 }
24995 {
24996 PyThreadState* __tstate = wxPyBeginAllowThreads();
24997 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
24998 wxPyEndAllowThreads(__tstate);
24999 if (PyErr_Occurred()) SWIG_fail;
25000 }
25001 resultobj = SWIG_From_int(static_cast< int >(result));
25002 {
25003 if (temp2) delete arg2;
25004 }
25005 return resultobj;
25006 fail:
25007 {
25008 if (temp2) delete arg2;
25009 }
25010 return NULL;
25011 }
25012
25013
25014 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25015 PyObject *resultobj = 0;
25016 wxDateTime *arg1 = (wxDateTime *) 0 ;
25017 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25018 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25019 int result;
25020 void *argp1 = 0 ;
25021 int res1 = 0 ;
25022 bool temp2 = false ;
25023 PyObject * obj0 = 0 ;
25024 PyObject * obj1 = 0 ;
25025 char * kwnames[] = {
25026 (char *) "self",(char *) "tz", NULL
25027 };
25028
25029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
25030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25031 if (!SWIG_IsOK(res1)) {
25032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25033 }
25034 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25035 if (obj1) {
25036 {
25037 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25038 temp2 = true;
25039 }
25040 }
25041 {
25042 PyThreadState* __tstate = wxPyBeginAllowThreads();
25043 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
25044 wxPyEndAllowThreads(__tstate);
25045 if (PyErr_Occurred()) SWIG_fail;
25046 }
25047 resultobj = SWIG_From_int(static_cast< int >(result));
25048 {
25049 if (temp2) delete arg2;
25050 }
25051 return resultobj;
25052 fail:
25053 {
25054 if (temp2) delete arg2;
25055 }
25056 return NULL;
25057 }
25058
25059
25060 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25061 PyObject *resultobj = 0;
25062 wxDateTime *arg1 = (wxDateTime *) 0 ;
25063 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25064 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25065 wxDateTime::WeekDay result;
25066 void *argp1 = 0 ;
25067 int res1 = 0 ;
25068 bool temp2 = false ;
25069 PyObject * obj0 = 0 ;
25070 PyObject * obj1 = 0 ;
25071 char * kwnames[] = {
25072 (char *) "self",(char *) "tz", NULL
25073 };
25074
25075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25077 if (!SWIG_IsOK(res1)) {
25078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25079 }
25080 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25081 if (obj1) {
25082 {
25083 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25084 temp2 = true;
25085 }
25086 }
25087 {
25088 PyThreadState* __tstate = wxPyBeginAllowThreads();
25089 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
25090 wxPyEndAllowThreads(__tstate);
25091 if (PyErr_Occurred()) SWIG_fail;
25092 }
25093 resultobj = SWIG_From_int(static_cast< int >(result));
25094 {
25095 if (temp2) delete arg2;
25096 }
25097 return resultobj;
25098 fail:
25099 {
25100 if (temp2) delete arg2;
25101 }
25102 return NULL;
25103 }
25104
25105
25106 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25107 PyObject *resultobj = 0;
25108 wxDateTime *arg1 = (wxDateTime *) 0 ;
25109 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25110 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25111 int result;
25112 void *argp1 = 0 ;
25113 int res1 = 0 ;
25114 bool temp2 = false ;
25115 PyObject * obj0 = 0 ;
25116 PyObject * obj1 = 0 ;
25117 char * kwnames[] = {
25118 (char *) "self",(char *) "tz", NULL
25119 };
25120
25121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
25122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25123 if (!SWIG_IsOK(res1)) {
25124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25125 }
25126 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25127 if (obj1) {
25128 {
25129 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25130 temp2 = true;
25131 }
25132 }
25133 {
25134 PyThreadState* __tstate = wxPyBeginAllowThreads();
25135 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
25136 wxPyEndAllowThreads(__tstate);
25137 if (PyErr_Occurred()) SWIG_fail;
25138 }
25139 resultobj = SWIG_From_int(static_cast< int >(result));
25140 {
25141 if (temp2) delete arg2;
25142 }
25143 return resultobj;
25144 fail:
25145 {
25146 if (temp2) delete arg2;
25147 }
25148 return NULL;
25149 }
25150
25151
25152 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25153 PyObject *resultobj = 0;
25154 wxDateTime *arg1 = (wxDateTime *) 0 ;
25155 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25156 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25157 int result;
25158 void *argp1 = 0 ;
25159 int res1 = 0 ;
25160 bool temp2 = false ;
25161 PyObject * obj0 = 0 ;
25162 PyObject * obj1 = 0 ;
25163 char * kwnames[] = {
25164 (char *) "self",(char *) "tz", NULL
25165 };
25166
25167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
25168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25169 if (!SWIG_IsOK(res1)) {
25170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25171 }
25172 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25173 if (obj1) {
25174 {
25175 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25176 temp2 = true;
25177 }
25178 }
25179 {
25180 PyThreadState* __tstate = wxPyBeginAllowThreads();
25181 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
25182 wxPyEndAllowThreads(__tstate);
25183 if (PyErr_Occurred()) SWIG_fail;
25184 }
25185 resultobj = SWIG_From_int(static_cast< int >(result));
25186 {
25187 if (temp2) delete arg2;
25188 }
25189 return resultobj;
25190 fail:
25191 {
25192 if (temp2) delete arg2;
25193 }
25194 return NULL;
25195 }
25196
25197
25198 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25199 PyObject *resultobj = 0;
25200 wxDateTime *arg1 = (wxDateTime *) 0 ;
25201 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25202 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25203 int result;
25204 void *argp1 = 0 ;
25205 int res1 = 0 ;
25206 bool temp2 = false ;
25207 PyObject * obj0 = 0 ;
25208 PyObject * obj1 = 0 ;
25209 char * kwnames[] = {
25210 (char *) "self",(char *) "tz", NULL
25211 };
25212
25213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
25214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25215 if (!SWIG_IsOK(res1)) {
25216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25217 }
25218 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25219 if (obj1) {
25220 {
25221 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25222 temp2 = true;
25223 }
25224 }
25225 {
25226 PyThreadState* __tstate = wxPyBeginAllowThreads();
25227 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
25228 wxPyEndAllowThreads(__tstate);
25229 if (PyErr_Occurred()) SWIG_fail;
25230 }
25231 resultobj = SWIG_From_int(static_cast< int >(result));
25232 {
25233 if (temp2) delete arg2;
25234 }
25235 return resultobj;
25236 fail:
25237 {
25238 if (temp2) delete arg2;
25239 }
25240 return NULL;
25241 }
25242
25243
25244 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25245 PyObject *resultobj = 0;
25246 wxDateTime *arg1 = (wxDateTime *) 0 ;
25247 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25248 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25249 int result;
25250 void *argp1 = 0 ;
25251 int res1 = 0 ;
25252 bool temp2 = false ;
25253 PyObject * obj0 = 0 ;
25254 PyObject * obj1 = 0 ;
25255 char * kwnames[] = {
25256 (char *) "self",(char *) "tz", NULL
25257 };
25258
25259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
25260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25261 if (!SWIG_IsOK(res1)) {
25262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25263 }
25264 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25265 if (obj1) {
25266 {
25267 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25268 temp2 = true;
25269 }
25270 }
25271 {
25272 PyThreadState* __tstate = wxPyBeginAllowThreads();
25273 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
25274 wxPyEndAllowThreads(__tstate);
25275 if (PyErr_Occurred()) SWIG_fail;
25276 }
25277 resultobj = SWIG_From_int(static_cast< int >(result));
25278 {
25279 if (temp2) delete arg2;
25280 }
25281 return resultobj;
25282 fail:
25283 {
25284 if (temp2) delete arg2;
25285 }
25286 return NULL;
25287 }
25288
25289
25290 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25291 PyObject *resultobj = 0;
25292 wxDateTime *arg1 = (wxDateTime *) 0 ;
25293 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25294 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25295 int result;
25296 void *argp1 = 0 ;
25297 int res1 = 0 ;
25298 bool temp2 = false ;
25299 PyObject * obj0 = 0 ;
25300 PyObject * obj1 = 0 ;
25301 char * kwnames[] = {
25302 (char *) "self",(char *) "tz", NULL
25303 };
25304
25305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
25306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25307 if (!SWIG_IsOK(res1)) {
25308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25309 }
25310 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25311 if (obj1) {
25312 {
25313 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25314 temp2 = true;
25315 }
25316 }
25317 {
25318 PyThreadState* __tstate = wxPyBeginAllowThreads();
25319 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
25320 wxPyEndAllowThreads(__tstate);
25321 if (PyErr_Occurred()) SWIG_fail;
25322 }
25323 resultobj = SWIG_From_int(static_cast< int >(result));
25324 {
25325 if (temp2) delete arg2;
25326 }
25327 return resultobj;
25328 fail:
25329 {
25330 if (temp2) delete arg2;
25331 }
25332 return NULL;
25333 }
25334
25335
25336 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25337 PyObject *resultobj = 0;
25338 wxDateTime *arg1 = (wxDateTime *) 0 ;
25339 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25340 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25341 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25342 int result;
25343 void *argp1 = 0 ;
25344 int res1 = 0 ;
25345 int val2 ;
25346 int ecode2 = 0 ;
25347 bool temp3 = false ;
25348 PyObject * obj0 = 0 ;
25349 PyObject * obj1 = 0 ;
25350 PyObject * obj2 = 0 ;
25351 char * kwnames[] = {
25352 (char *) "self",(char *) "flags",(char *) "tz", NULL
25353 };
25354
25355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25357 if (!SWIG_IsOK(res1)) {
25358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25359 }
25360 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25361 if (obj1) {
25362 ecode2 = SWIG_AsVal_int(obj1, &val2);
25363 if (!SWIG_IsOK(ecode2)) {
25364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25365 }
25366 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25367 }
25368 if (obj2) {
25369 {
25370 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25371 temp3 = true;
25372 }
25373 }
25374 {
25375 PyThreadState* __tstate = wxPyBeginAllowThreads();
25376 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
25377 wxPyEndAllowThreads(__tstate);
25378 if (PyErr_Occurred()) SWIG_fail;
25379 }
25380 resultobj = SWIG_From_int(static_cast< int >(result));
25381 {
25382 if (temp3) delete arg3;
25383 }
25384 return resultobj;
25385 fail:
25386 {
25387 if (temp3) delete arg3;
25388 }
25389 return NULL;
25390 }
25391
25392
25393 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25394 PyObject *resultobj = 0;
25395 wxDateTime *arg1 = (wxDateTime *) 0 ;
25396 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25397 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25398 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25399 int result;
25400 void *argp1 = 0 ;
25401 int res1 = 0 ;
25402 int val2 ;
25403 int ecode2 = 0 ;
25404 bool temp3 = false ;
25405 PyObject * obj0 = 0 ;
25406 PyObject * obj1 = 0 ;
25407 PyObject * obj2 = 0 ;
25408 char * kwnames[] = {
25409 (char *) "self",(char *) "flags",(char *) "tz", NULL
25410 };
25411
25412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25414 if (!SWIG_IsOK(res1)) {
25415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25416 }
25417 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25418 if (obj1) {
25419 ecode2 = SWIG_AsVal_int(obj1, &val2);
25420 if (!SWIG_IsOK(ecode2)) {
25421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25422 }
25423 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25424 }
25425 if (obj2) {
25426 {
25427 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25428 temp3 = true;
25429 }
25430 }
25431 {
25432 PyThreadState* __tstate = wxPyBeginAllowThreads();
25433 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
25434 wxPyEndAllowThreads(__tstate);
25435 if (PyErr_Occurred()) SWIG_fail;
25436 }
25437 resultobj = SWIG_From_int(static_cast< int >(result));
25438 {
25439 if (temp3) delete arg3;
25440 }
25441 return resultobj;
25442 fail:
25443 {
25444 if (temp3) delete arg3;
25445 }
25446 return NULL;
25447 }
25448
25449
25450 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25451 PyObject *resultobj = 0;
25452 wxDateTime *arg1 = (wxDateTime *) 0 ;
25453 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25454 bool result;
25455 void *argp1 = 0 ;
25456 int res1 = 0 ;
25457 int val2 ;
25458 int ecode2 = 0 ;
25459 PyObject * obj0 = 0 ;
25460 PyObject * obj1 = 0 ;
25461 char * kwnames[] = {
25462 (char *) "self",(char *) "country", NULL
25463 };
25464
25465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
25466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25467 if (!SWIG_IsOK(res1)) {
25468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25469 }
25470 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25471 if (obj1) {
25472 ecode2 = SWIG_AsVal_int(obj1, &val2);
25473 if (!SWIG_IsOK(ecode2)) {
25474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25475 }
25476 arg2 = static_cast< wxDateTime::Country >(val2);
25477 }
25478 {
25479 PyThreadState* __tstate = wxPyBeginAllowThreads();
25480 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
25481 wxPyEndAllowThreads(__tstate);
25482 if (PyErr_Occurred()) SWIG_fail;
25483 }
25484 {
25485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25486 }
25487 return resultobj;
25488 fail:
25489 return NULL;
25490 }
25491
25492
25493 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25494 PyObject *resultobj = 0;
25495 wxDateTime *arg1 = (wxDateTime *) 0 ;
25496 wxDateTime *arg2 = 0 ;
25497 bool result;
25498 void *argp1 = 0 ;
25499 int res1 = 0 ;
25500 void *argp2 = 0 ;
25501 int res2 = 0 ;
25502 PyObject * obj0 = 0 ;
25503 PyObject * obj1 = 0 ;
25504 char * kwnames[] = {
25505 (char *) "self",(char *) "datetime", NULL
25506 };
25507
25508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
25509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25510 if (!SWIG_IsOK(res1)) {
25511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25512 }
25513 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25514 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25515 if (!SWIG_IsOK(res2)) {
25516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25517 }
25518 if (!argp2) {
25519 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25520 }
25521 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25522 {
25523 PyThreadState* __tstate = wxPyBeginAllowThreads();
25524 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
25525 wxPyEndAllowThreads(__tstate);
25526 if (PyErr_Occurred()) SWIG_fail;
25527 }
25528 {
25529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25530 }
25531 return resultobj;
25532 fail:
25533 return NULL;
25534 }
25535
25536
25537 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25538 PyObject *resultobj = 0;
25539 wxDateTime *arg1 = (wxDateTime *) 0 ;
25540 wxDateTime *arg2 = 0 ;
25541 bool result;
25542 void *argp1 = 0 ;
25543 int res1 = 0 ;
25544 void *argp2 = 0 ;
25545 int res2 = 0 ;
25546 PyObject * obj0 = 0 ;
25547 PyObject * obj1 = 0 ;
25548 char * kwnames[] = {
25549 (char *) "self",(char *) "datetime", NULL
25550 };
25551
25552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
25553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25554 if (!SWIG_IsOK(res1)) {
25555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25556 }
25557 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25558 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25559 if (!SWIG_IsOK(res2)) {
25560 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25561 }
25562 if (!argp2) {
25563 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25564 }
25565 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25566 {
25567 PyThreadState* __tstate = wxPyBeginAllowThreads();
25568 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
25569 wxPyEndAllowThreads(__tstate);
25570 if (PyErr_Occurred()) SWIG_fail;
25571 }
25572 {
25573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25574 }
25575 return resultobj;
25576 fail:
25577 return NULL;
25578 }
25579
25580
25581 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25582 PyObject *resultobj = 0;
25583 wxDateTime *arg1 = (wxDateTime *) 0 ;
25584 wxDateTime *arg2 = 0 ;
25585 bool result;
25586 void *argp1 = 0 ;
25587 int res1 = 0 ;
25588 void *argp2 = 0 ;
25589 int res2 = 0 ;
25590 PyObject * obj0 = 0 ;
25591 PyObject * obj1 = 0 ;
25592 char * kwnames[] = {
25593 (char *) "self",(char *) "datetime", NULL
25594 };
25595
25596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
25597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25598 if (!SWIG_IsOK(res1)) {
25599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25600 }
25601 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25602 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25603 if (!SWIG_IsOK(res2)) {
25604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25605 }
25606 if (!argp2) {
25607 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25608 }
25609 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25610 {
25611 PyThreadState* __tstate = wxPyBeginAllowThreads();
25612 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
25613 wxPyEndAllowThreads(__tstate);
25614 if (PyErr_Occurred()) SWIG_fail;
25615 }
25616 {
25617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25618 }
25619 return resultobj;
25620 fail:
25621 return NULL;
25622 }
25623
25624
25625 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25626 PyObject *resultobj = 0;
25627 wxDateTime *arg1 = (wxDateTime *) 0 ;
25628 wxDateTime *arg2 = 0 ;
25629 wxDateTime *arg3 = 0 ;
25630 bool result;
25631 void *argp1 = 0 ;
25632 int res1 = 0 ;
25633 void *argp2 = 0 ;
25634 int res2 = 0 ;
25635 void *argp3 = 0 ;
25636 int res3 = 0 ;
25637 PyObject * obj0 = 0 ;
25638 PyObject * obj1 = 0 ;
25639 PyObject * obj2 = 0 ;
25640 char * kwnames[] = {
25641 (char *) "self",(char *) "t1",(char *) "t2", NULL
25642 };
25643
25644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25646 if (!SWIG_IsOK(res1)) {
25647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25648 }
25649 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25650 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25651 if (!SWIG_IsOK(res2)) {
25652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25653 }
25654 if (!argp2) {
25655 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25656 }
25657 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25658 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25659 if (!SWIG_IsOK(res3)) {
25660 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25661 }
25662 if (!argp3) {
25663 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25664 }
25665 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25666 {
25667 PyThreadState* __tstate = wxPyBeginAllowThreads();
25668 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25669 wxPyEndAllowThreads(__tstate);
25670 if (PyErr_Occurred()) SWIG_fail;
25671 }
25672 {
25673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25674 }
25675 return resultobj;
25676 fail:
25677 return NULL;
25678 }
25679
25680
25681 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25682 PyObject *resultobj = 0;
25683 wxDateTime *arg1 = (wxDateTime *) 0 ;
25684 wxDateTime *arg2 = 0 ;
25685 wxDateTime *arg3 = 0 ;
25686 bool result;
25687 void *argp1 = 0 ;
25688 int res1 = 0 ;
25689 void *argp2 = 0 ;
25690 int res2 = 0 ;
25691 void *argp3 = 0 ;
25692 int res3 = 0 ;
25693 PyObject * obj0 = 0 ;
25694 PyObject * obj1 = 0 ;
25695 PyObject * obj2 = 0 ;
25696 char * kwnames[] = {
25697 (char *) "self",(char *) "t1",(char *) "t2", NULL
25698 };
25699
25700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25702 if (!SWIG_IsOK(res1)) {
25703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25704 }
25705 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25706 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25707 if (!SWIG_IsOK(res2)) {
25708 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25709 }
25710 if (!argp2) {
25711 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25712 }
25713 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25714 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25715 if (!SWIG_IsOK(res3)) {
25716 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25717 }
25718 if (!argp3) {
25719 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25720 }
25721 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25722 {
25723 PyThreadState* __tstate = wxPyBeginAllowThreads();
25724 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25725 wxPyEndAllowThreads(__tstate);
25726 if (PyErr_Occurred()) SWIG_fail;
25727 }
25728 {
25729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25730 }
25731 return resultobj;
25732 fail:
25733 return NULL;
25734 }
25735
25736
25737 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25738 PyObject *resultobj = 0;
25739 wxDateTime *arg1 = (wxDateTime *) 0 ;
25740 wxDateTime *arg2 = 0 ;
25741 bool result;
25742 void *argp1 = 0 ;
25743 int res1 = 0 ;
25744 void *argp2 = 0 ;
25745 int res2 = 0 ;
25746 PyObject * obj0 = 0 ;
25747 PyObject * obj1 = 0 ;
25748 char * kwnames[] = {
25749 (char *) "self",(char *) "dt", NULL
25750 };
25751
25752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
25753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25754 if (!SWIG_IsOK(res1)) {
25755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25756 }
25757 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25758 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25759 if (!SWIG_IsOK(res2)) {
25760 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25761 }
25762 if (!argp2) {
25763 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25764 }
25765 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25766 {
25767 PyThreadState* __tstate = wxPyBeginAllowThreads();
25768 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
25769 wxPyEndAllowThreads(__tstate);
25770 if (PyErr_Occurred()) SWIG_fail;
25771 }
25772 {
25773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25774 }
25775 return resultobj;
25776 fail:
25777 return NULL;
25778 }
25779
25780
25781 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25782 PyObject *resultobj = 0;
25783 wxDateTime *arg1 = (wxDateTime *) 0 ;
25784 wxDateTime *arg2 = 0 ;
25785 bool result;
25786 void *argp1 = 0 ;
25787 int res1 = 0 ;
25788 void *argp2 = 0 ;
25789 int res2 = 0 ;
25790 PyObject * obj0 = 0 ;
25791 PyObject * obj1 = 0 ;
25792 char * kwnames[] = {
25793 (char *) "self",(char *) "dt", NULL
25794 };
25795
25796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
25797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25798 if (!SWIG_IsOK(res1)) {
25799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25800 }
25801 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25802 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25803 if (!SWIG_IsOK(res2)) {
25804 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25805 }
25806 if (!argp2) {
25807 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25808 }
25809 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25810 {
25811 PyThreadState* __tstate = wxPyBeginAllowThreads();
25812 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
25813 wxPyEndAllowThreads(__tstate);
25814 if (PyErr_Occurred()) SWIG_fail;
25815 }
25816 {
25817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25818 }
25819 return resultobj;
25820 fail:
25821 return NULL;
25822 }
25823
25824
25825 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25826 PyObject *resultobj = 0;
25827 wxDateTime *arg1 = (wxDateTime *) 0 ;
25828 wxDateTime *arg2 = 0 ;
25829 wxTimeSpan *arg3 = 0 ;
25830 bool result;
25831 void *argp1 = 0 ;
25832 int res1 = 0 ;
25833 void *argp2 = 0 ;
25834 int res2 = 0 ;
25835 void *argp3 = 0 ;
25836 int res3 = 0 ;
25837 PyObject * obj0 = 0 ;
25838 PyObject * obj1 = 0 ;
25839 PyObject * obj2 = 0 ;
25840 char * kwnames[] = {
25841 (char *) "self",(char *) "dt",(char *) "ts", NULL
25842 };
25843
25844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25846 if (!SWIG_IsOK(res1)) {
25847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25848 }
25849 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25850 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25851 if (!SWIG_IsOK(res2)) {
25852 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25853 }
25854 if (!argp2) {
25855 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25856 }
25857 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25858 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25859 if (!SWIG_IsOK(res3)) {
25860 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25861 }
25862 if (!argp3) {
25863 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25864 }
25865 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
25866 {
25867 PyThreadState* __tstate = wxPyBeginAllowThreads();
25868 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
25869 wxPyEndAllowThreads(__tstate);
25870 if (PyErr_Occurred()) SWIG_fail;
25871 }
25872 {
25873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25874 }
25875 return resultobj;
25876 fail:
25877 return NULL;
25878 }
25879
25880
25881 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25882 PyObject *resultobj = 0;
25883 wxDateTime *arg1 = (wxDateTime *) 0 ;
25884 wxTimeSpan *arg2 = 0 ;
25885 wxDateTime *result = 0 ;
25886 void *argp1 = 0 ;
25887 int res1 = 0 ;
25888 void *argp2 = 0 ;
25889 int res2 = 0 ;
25890 PyObject * obj0 = 0 ;
25891 PyObject * obj1 = 0 ;
25892 char * kwnames[] = {
25893 (char *) "self",(char *) "diff", NULL
25894 };
25895
25896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
25897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25898 if (!SWIG_IsOK(res1)) {
25899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25900 }
25901 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25902 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25903 if (!SWIG_IsOK(res2)) {
25904 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25905 }
25906 if (!argp2) {
25907 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25908 }
25909 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
25910 {
25911 PyThreadState* __tstate = wxPyBeginAllowThreads();
25912 {
25913 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
25914 result = (wxDateTime *) &_result_ref;
25915 }
25916 wxPyEndAllowThreads(__tstate);
25917 if (PyErr_Occurred()) SWIG_fail;
25918 }
25919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25920 return resultobj;
25921 fail:
25922 return NULL;
25923 }
25924
25925
25926 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25927 PyObject *resultobj = 0;
25928 wxDateTime *arg1 = (wxDateTime *) 0 ;
25929 wxDateSpan *arg2 = 0 ;
25930 wxDateTime *result = 0 ;
25931 void *argp1 = 0 ;
25932 int res1 = 0 ;
25933 void *argp2 = 0 ;
25934 int res2 = 0 ;
25935 PyObject * obj0 = 0 ;
25936 PyObject * obj1 = 0 ;
25937 char * kwnames[] = {
25938 (char *) "self",(char *) "diff", NULL
25939 };
25940
25941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
25942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25943 if (!SWIG_IsOK(res1)) {
25944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25945 }
25946 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25947 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
25948 if (!SWIG_IsOK(res2)) {
25949 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25950 }
25951 if (!argp2) {
25952 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25953 }
25954 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
25955 {
25956 PyThreadState* __tstate = wxPyBeginAllowThreads();
25957 {
25958 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25959 result = (wxDateTime *) &_result_ref;
25960 }
25961 wxPyEndAllowThreads(__tstate);
25962 if (PyErr_Occurred()) SWIG_fail;
25963 }
25964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25965 return resultobj;
25966 fail:
25967 return NULL;
25968 }
25969
25970
25971 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25972 PyObject *resultobj = 0;
25973 wxDateTime *arg1 = (wxDateTime *) 0 ;
25974 wxTimeSpan *arg2 = 0 ;
25975 wxDateTime *result = 0 ;
25976 void *argp1 = 0 ;
25977 int res1 = 0 ;
25978 void *argp2 = 0 ;
25979 int res2 = 0 ;
25980 PyObject * obj0 = 0 ;
25981 PyObject * obj1 = 0 ;
25982 char * kwnames[] = {
25983 (char *) "self",(char *) "diff", NULL
25984 };
25985
25986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
25987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25988 if (!SWIG_IsOK(res1)) {
25989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25990 }
25991 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25992 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25993 if (!SWIG_IsOK(res2)) {
25994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25995 }
25996 if (!argp2) {
25997 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25998 }
25999 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26000 {
26001 PyThreadState* __tstate = wxPyBeginAllowThreads();
26002 {
26003 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
26004 result = (wxDateTime *) &_result_ref;
26005 }
26006 wxPyEndAllowThreads(__tstate);
26007 if (PyErr_Occurred()) SWIG_fail;
26008 }
26009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26010 return resultobj;
26011 fail:
26012 return NULL;
26013 }
26014
26015
26016 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26017 PyObject *resultobj = 0;
26018 wxDateTime *arg1 = (wxDateTime *) 0 ;
26019 wxDateSpan *arg2 = 0 ;
26020 wxDateTime *result = 0 ;
26021 void *argp1 = 0 ;
26022 int res1 = 0 ;
26023 void *argp2 = 0 ;
26024 int res2 = 0 ;
26025 PyObject * obj0 = 0 ;
26026 PyObject * obj1 = 0 ;
26027 char * kwnames[] = {
26028 (char *) "self",(char *) "diff", NULL
26029 };
26030
26031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
26032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26033 if (!SWIG_IsOK(res1)) {
26034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26035 }
26036 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26037 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26038 if (!SWIG_IsOK(res2)) {
26039 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26040 }
26041 if (!argp2) {
26042 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26043 }
26044 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26045 {
26046 PyThreadState* __tstate = wxPyBeginAllowThreads();
26047 {
26048 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26049 result = (wxDateTime *) &_result_ref;
26050 }
26051 wxPyEndAllowThreads(__tstate);
26052 if (PyErr_Occurred()) SWIG_fail;
26053 }
26054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26055 return resultobj;
26056 fail:
26057 return NULL;
26058 }
26059
26060
26061 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26062 PyObject *resultobj = 0;
26063 wxDateTime *arg1 = (wxDateTime *) 0 ;
26064 wxDateTime *arg2 = 0 ;
26065 wxTimeSpan result;
26066 void *argp1 = 0 ;
26067 int res1 = 0 ;
26068 void *argp2 = 0 ;
26069 int res2 = 0 ;
26070 PyObject * obj0 = 0 ;
26071 PyObject * obj1 = 0 ;
26072 char * kwnames[] = {
26073 (char *) "self",(char *) "dt", NULL
26074 };
26075
26076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
26077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26078 if (!SWIG_IsOK(res1)) {
26079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26080 }
26081 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26082 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26083 if (!SWIG_IsOK(res2)) {
26084 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26085 }
26086 if (!argp2) {
26087 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26088 }
26089 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26090 {
26091 PyThreadState* __tstate = wxPyBeginAllowThreads();
26092 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
26093 wxPyEndAllowThreads(__tstate);
26094 if (PyErr_Occurred()) SWIG_fail;
26095 }
26096 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26097 return resultobj;
26098 fail:
26099 return NULL;
26100 }
26101
26102
26103 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26104 PyObject *resultobj = 0;
26105 wxDateTime *arg1 = (wxDateTime *) 0 ;
26106 wxTimeSpan *arg2 = 0 ;
26107 wxDateTime *result = 0 ;
26108 void *argp1 = 0 ;
26109 int res1 = 0 ;
26110 void *argp2 = 0 ;
26111 int res2 = 0 ;
26112
26113 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26115 if (!SWIG_IsOK(res1)) {
26116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26117 }
26118 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26119 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26120 if (!SWIG_IsOK(res2)) {
26121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26122 }
26123 if (!argp2) {
26124 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26125 }
26126 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26127 {
26128 PyThreadState* __tstate = wxPyBeginAllowThreads();
26129 {
26130 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
26131 result = (wxDateTime *) &_result_ref;
26132 }
26133 wxPyEndAllowThreads(__tstate);
26134 if (PyErr_Occurred()) SWIG_fail;
26135 }
26136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26137 return resultobj;
26138 fail:
26139 return NULL;
26140 }
26141
26142
26143 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26144 PyObject *resultobj = 0;
26145 wxDateTime *arg1 = (wxDateTime *) 0 ;
26146 wxDateSpan *arg2 = 0 ;
26147 wxDateTime *result = 0 ;
26148 void *argp1 = 0 ;
26149 int res1 = 0 ;
26150 void *argp2 = 0 ;
26151 int res2 = 0 ;
26152
26153 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26155 if (!SWIG_IsOK(res1)) {
26156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26157 }
26158 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26159 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26160 if (!SWIG_IsOK(res2)) {
26161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26162 }
26163 if (!argp2) {
26164 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26165 }
26166 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26167 {
26168 PyThreadState* __tstate = wxPyBeginAllowThreads();
26169 {
26170 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26171 result = (wxDateTime *) &_result_ref;
26172 }
26173 wxPyEndAllowThreads(__tstate);
26174 if (PyErr_Occurred()) SWIG_fail;
26175 }
26176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26177 return resultobj;
26178 fail:
26179 return NULL;
26180 }
26181
26182
26183 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
26184 int argc;
26185 PyObject *argv[3];
26186
26187 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
26188 --argc;
26189 if (argc == 2) {
26190 int _v = 0;
26191 {
26192 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26193 _v = SWIG_CheckState(res);
26194 }
26195 if (!_v) goto check_1;
26196 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
26197 }
26198 check_1:
26199
26200 if (argc == 2) {
26201 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
26202 }
26203
26204 fail:
26205 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
26206 return NULL;
26207 }
26208
26209
26210 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26211 PyObject *resultobj = 0;
26212 wxDateTime *arg1 = (wxDateTime *) 0 ;
26213 wxTimeSpan *arg2 = 0 ;
26214 wxDateTime *result = 0 ;
26215 void *argp1 = 0 ;
26216 int res1 = 0 ;
26217 void *argp2 = 0 ;
26218 int res2 = 0 ;
26219
26220 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26222 if (!SWIG_IsOK(res1)) {
26223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26224 }
26225 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26226 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26227 if (!SWIG_IsOK(res2)) {
26228 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26229 }
26230 if (!argp2) {
26231 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26232 }
26233 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26234 {
26235 PyThreadState* __tstate = wxPyBeginAllowThreads();
26236 {
26237 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
26238 result = (wxDateTime *) &_result_ref;
26239 }
26240 wxPyEndAllowThreads(__tstate);
26241 if (PyErr_Occurred()) SWIG_fail;
26242 }
26243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26244 return resultobj;
26245 fail:
26246 return NULL;
26247 }
26248
26249
26250 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26251 PyObject *resultobj = 0;
26252 wxDateTime *arg1 = (wxDateTime *) 0 ;
26253 wxDateSpan *arg2 = 0 ;
26254 wxDateTime *result = 0 ;
26255 void *argp1 = 0 ;
26256 int res1 = 0 ;
26257 void *argp2 = 0 ;
26258 int res2 = 0 ;
26259
26260 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26262 if (!SWIG_IsOK(res1)) {
26263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26264 }
26265 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26266 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26267 if (!SWIG_IsOK(res2)) {
26268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26269 }
26270 if (!argp2) {
26271 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26272 }
26273 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26274 {
26275 PyThreadState* __tstate = wxPyBeginAllowThreads();
26276 {
26277 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26278 result = (wxDateTime *) &_result_ref;
26279 }
26280 wxPyEndAllowThreads(__tstate);
26281 if (PyErr_Occurred()) SWIG_fail;
26282 }
26283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26284 return resultobj;
26285 fail:
26286 return NULL;
26287 }
26288
26289
26290 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
26291 int argc;
26292 PyObject *argv[3];
26293
26294 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
26295 --argc;
26296 if (argc == 2) {
26297 int _v = 0;
26298 {
26299 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26300 _v = SWIG_CheckState(res);
26301 }
26302 if (!_v) goto check_1;
26303 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
26304 }
26305 check_1:
26306
26307 if (argc == 2) {
26308 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
26309 }
26310
26311 fail:
26312 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
26313 return NULL;
26314 }
26315
26316
26317 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26318 PyObject *resultobj = 0;
26319 wxDateTime *arg1 = (wxDateTime *) 0 ;
26320 wxTimeSpan *arg2 = 0 ;
26321 wxDateTime result;
26322 void *argp1 = 0 ;
26323 int res1 = 0 ;
26324 void *argp2 = 0 ;
26325 int res2 = 0 ;
26326
26327 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26329 if (!SWIG_IsOK(res1)) {
26330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26331 }
26332 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26333 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26334 if (!SWIG_IsOK(res2)) {
26335 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26336 }
26337 if (!argp2) {
26338 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26339 }
26340 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26341 {
26342 PyThreadState* __tstate = wxPyBeginAllowThreads();
26343 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
26344 wxPyEndAllowThreads(__tstate);
26345 if (PyErr_Occurred()) SWIG_fail;
26346 }
26347 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26348 return resultobj;
26349 fail:
26350 return NULL;
26351 }
26352
26353
26354 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26355 PyObject *resultobj = 0;
26356 wxDateTime *arg1 = (wxDateTime *) 0 ;
26357 wxDateSpan *arg2 = 0 ;
26358 wxDateTime result;
26359 void *argp1 = 0 ;
26360 int res1 = 0 ;
26361 void *argp2 = 0 ;
26362 int res2 = 0 ;
26363
26364 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26366 if (!SWIG_IsOK(res1)) {
26367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26368 }
26369 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26370 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26371 if (!SWIG_IsOK(res2)) {
26372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26373 }
26374 if (!argp2) {
26375 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26376 }
26377 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26378 {
26379 PyThreadState* __tstate = wxPyBeginAllowThreads();
26380 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
26381 wxPyEndAllowThreads(__tstate);
26382 if (PyErr_Occurred()) SWIG_fail;
26383 }
26384 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26385 return resultobj;
26386 fail:
26387 return NULL;
26388 }
26389
26390
26391 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
26392 int argc;
26393 PyObject *argv[3];
26394
26395 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
26396 --argc;
26397 if (argc == 2) {
26398 int _v = 0;
26399 {
26400 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26401 _v = SWIG_CheckState(res);
26402 }
26403 if (!_v) goto check_1;
26404 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
26405 }
26406 check_1:
26407
26408 if (argc == 2) {
26409 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
26410 }
26411
26412 fail:
26413 Py_INCREF(Py_NotImplemented);
26414 return Py_NotImplemented;
26415 }
26416
26417
26418 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26419 PyObject *resultobj = 0;
26420 wxDateTime *arg1 = (wxDateTime *) 0 ;
26421 wxDateTime *arg2 = 0 ;
26422 wxTimeSpan result;
26423 void *argp1 = 0 ;
26424 int res1 = 0 ;
26425 void *argp2 = 0 ;
26426 int res2 = 0 ;
26427
26428 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26430 if (!SWIG_IsOK(res1)) {
26431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26432 }
26433 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26434 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26435 if (!SWIG_IsOK(res2)) {
26436 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26437 }
26438 if (!argp2) {
26439 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26440 }
26441 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26442 {
26443 PyThreadState* __tstate = wxPyBeginAllowThreads();
26444 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
26445 wxPyEndAllowThreads(__tstate);
26446 if (PyErr_Occurred()) SWIG_fail;
26447 }
26448 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26449 return resultobj;
26450 fail:
26451 return NULL;
26452 }
26453
26454
26455 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26456 PyObject *resultobj = 0;
26457 wxDateTime *arg1 = (wxDateTime *) 0 ;
26458 wxTimeSpan *arg2 = 0 ;
26459 wxDateTime result;
26460 void *argp1 = 0 ;
26461 int res1 = 0 ;
26462 void *argp2 = 0 ;
26463 int res2 = 0 ;
26464
26465 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26467 if (!SWIG_IsOK(res1)) {
26468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26469 }
26470 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26471 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26472 if (!SWIG_IsOK(res2)) {
26473 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26474 }
26475 if (!argp2) {
26476 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26477 }
26478 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26479 {
26480 PyThreadState* __tstate = wxPyBeginAllowThreads();
26481 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
26482 wxPyEndAllowThreads(__tstate);
26483 if (PyErr_Occurred()) SWIG_fail;
26484 }
26485 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26486 return resultobj;
26487 fail:
26488 return NULL;
26489 }
26490
26491
26492 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26493 PyObject *resultobj = 0;
26494 wxDateTime *arg1 = (wxDateTime *) 0 ;
26495 wxDateSpan *arg2 = 0 ;
26496 wxDateTime result;
26497 void *argp1 = 0 ;
26498 int res1 = 0 ;
26499 void *argp2 = 0 ;
26500 int res2 = 0 ;
26501
26502 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26504 if (!SWIG_IsOK(res1)) {
26505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26506 }
26507 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26508 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26509 if (!SWIG_IsOK(res2)) {
26510 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26511 }
26512 if (!argp2) {
26513 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26514 }
26515 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26516 {
26517 PyThreadState* __tstate = wxPyBeginAllowThreads();
26518 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
26519 wxPyEndAllowThreads(__tstate);
26520 if (PyErr_Occurred()) SWIG_fail;
26521 }
26522 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26523 return resultobj;
26524 fail:
26525 return NULL;
26526 }
26527
26528
26529 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
26530 int argc;
26531 PyObject *argv[3];
26532
26533 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
26534 --argc;
26535 if (argc == 2) {
26536 int _v = 0;
26537 {
26538 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
26539 _v = SWIG_CheckState(res);
26540 }
26541 if (!_v) goto check_1;
26542 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
26543 }
26544 check_1:
26545
26546 if (argc == 2) {
26547 int _v = 0;
26548 {
26549 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26550 _v = SWIG_CheckState(res);
26551 }
26552 if (!_v) goto check_2;
26553 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
26554 }
26555 check_2:
26556
26557 if (argc == 2) {
26558 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
26559 }
26560
26561 fail:
26562 Py_INCREF(Py_NotImplemented);
26563 return Py_NotImplemented;
26564 }
26565
26566
26567 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26568 PyObject *resultobj = 0;
26569 wxDateTime *arg1 = (wxDateTime *) 0 ;
26570 wxDateTime *arg2 = (wxDateTime *) 0 ;
26571 bool result;
26572 void *argp1 = 0 ;
26573 int res1 = 0 ;
26574 void *argp2 = 0 ;
26575 int res2 = 0 ;
26576 PyObject * obj0 = 0 ;
26577 PyObject * obj1 = 0 ;
26578 char * kwnames[] = {
26579 (char *) "self",(char *) "other", NULL
26580 };
26581
26582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
26583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26584 if (!SWIG_IsOK(res1)) {
26585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26586 }
26587 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26588 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26589 if (!SWIG_IsOK(res2)) {
26590 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26591 }
26592 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26593 {
26594 PyThreadState* __tstate = wxPyBeginAllowThreads();
26595 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
26596 wxPyEndAllowThreads(__tstate);
26597 if (PyErr_Occurred()) SWIG_fail;
26598 }
26599 {
26600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26601 }
26602 return resultobj;
26603 fail:
26604 return NULL;
26605 }
26606
26607
26608 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26609 PyObject *resultobj = 0;
26610 wxDateTime *arg1 = (wxDateTime *) 0 ;
26611 wxDateTime *arg2 = (wxDateTime *) 0 ;
26612 bool result;
26613 void *argp1 = 0 ;
26614 int res1 = 0 ;
26615 void *argp2 = 0 ;
26616 int res2 = 0 ;
26617 PyObject * obj0 = 0 ;
26618 PyObject * obj1 = 0 ;
26619 char * kwnames[] = {
26620 (char *) "self",(char *) "other", NULL
26621 };
26622
26623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
26624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26625 if (!SWIG_IsOK(res1)) {
26626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26627 }
26628 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26629 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26630 if (!SWIG_IsOK(res2)) {
26631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26632 }
26633 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26634 {
26635 PyThreadState* __tstate = wxPyBeginAllowThreads();
26636 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
26637 wxPyEndAllowThreads(__tstate);
26638 if (PyErr_Occurred()) SWIG_fail;
26639 }
26640 {
26641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26642 }
26643 return resultobj;
26644 fail:
26645 return NULL;
26646 }
26647
26648
26649 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26650 PyObject *resultobj = 0;
26651 wxDateTime *arg1 = (wxDateTime *) 0 ;
26652 wxDateTime *arg2 = (wxDateTime *) 0 ;
26653 bool result;
26654 void *argp1 = 0 ;
26655 int res1 = 0 ;
26656 void *argp2 = 0 ;
26657 int res2 = 0 ;
26658 PyObject * obj0 = 0 ;
26659 PyObject * obj1 = 0 ;
26660 char * kwnames[] = {
26661 (char *) "self",(char *) "other", NULL
26662 };
26663
26664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
26665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26666 if (!SWIG_IsOK(res1)) {
26667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26668 }
26669 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26670 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26671 if (!SWIG_IsOK(res2)) {
26672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26673 }
26674 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26675 {
26676 PyThreadState* __tstate = wxPyBeginAllowThreads();
26677 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
26678 wxPyEndAllowThreads(__tstate);
26679 if (PyErr_Occurred()) SWIG_fail;
26680 }
26681 {
26682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26683 }
26684 return resultobj;
26685 fail:
26686 return NULL;
26687 }
26688
26689
26690 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26691 PyObject *resultobj = 0;
26692 wxDateTime *arg1 = (wxDateTime *) 0 ;
26693 wxDateTime *arg2 = (wxDateTime *) 0 ;
26694 bool result;
26695 void *argp1 = 0 ;
26696 int res1 = 0 ;
26697 void *argp2 = 0 ;
26698 int res2 = 0 ;
26699 PyObject * obj0 = 0 ;
26700 PyObject * obj1 = 0 ;
26701 char * kwnames[] = {
26702 (char *) "self",(char *) "other", NULL
26703 };
26704
26705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
26706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26707 if (!SWIG_IsOK(res1)) {
26708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26709 }
26710 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26711 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26712 if (!SWIG_IsOK(res2)) {
26713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26714 }
26715 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26716 {
26717 PyThreadState* __tstate = wxPyBeginAllowThreads();
26718 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
26719 wxPyEndAllowThreads(__tstate);
26720 if (PyErr_Occurred()) SWIG_fail;
26721 }
26722 {
26723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26724 }
26725 return resultobj;
26726 fail:
26727 return NULL;
26728 }
26729
26730
26731 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26732 PyObject *resultobj = 0;
26733 wxDateTime *arg1 = (wxDateTime *) 0 ;
26734 wxDateTime *arg2 = (wxDateTime *) 0 ;
26735 bool result;
26736 void *argp1 = 0 ;
26737 int res1 = 0 ;
26738 void *argp2 = 0 ;
26739 int res2 = 0 ;
26740 PyObject * obj0 = 0 ;
26741 PyObject * obj1 = 0 ;
26742 char * kwnames[] = {
26743 (char *) "self",(char *) "other", NULL
26744 };
26745
26746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
26747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26748 if (!SWIG_IsOK(res1)) {
26749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26750 }
26751 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26752 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26753 if (!SWIG_IsOK(res2)) {
26754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26755 }
26756 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26757 {
26758 PyThreadState* __tstate = wxPyBeginAllowThreads();
26759 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
26760 wxPyEndAllowThreads(__tstate);
26761 if (PyErr_Occurred()) SWIG_fail;
26762 }
26763 {
26764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26765 }
26766 return resultobj;
26767 fail:
26768 return NULL;
26769 }
26770
26771
26772 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26773 PyObject *resultobj = 0;
26774 wxDateTime *arg1 = (wxDateTime *) 0 ;
26775 wxDateTime *arg2 = (wxDateTime *) 0 ;
26776 bool result;
26777 void *argp1 = 0 ;
26778 int res1 = 0 ;
26779 void *argp2 = 0 ;
26780 int res2 = 0 ;
26781 PyObject * obj0 = 0 ;
26782 PyObject * obj1 = 0 ;
26783 char * kwnames[] = {
26784 (char *) "self",(char *) "other", NULL
26785 };
26786
26787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
26788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26789 if (!SWIG_IsOK(res1)) {
26790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26791 }
26792 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26793 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26794 if (!SWIG_IsOK(res2)) {
26795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26796 }
26797 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26798 {
26799 PyThreadState* __tstate = wxPyBeginAllowThreads();
26800 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
26801 wxPyEndAllowThreads(__tstate);
26802 if (PyErr_Occurred()) SWIG_fail;
26803 }
26804 {
26805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26806 }
26807 return resultobj;
26808 fail:
26809 return NULL;
26810 }
26811
26812
26813 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26814 PyObject *resultobj = 0;
26815 wxDateTime *arg1 = (wxDateTime *) 0 ;
26816 wxString *arg2 = 0 ;
26817 int result;
26818 void *argp1 = 0 ;
26819 int res1 = 0 ;
26820 bool temp2 = false ;
26821 PyObject * obj0 = 0 ;
26822 PyObject * obj1 = 0 ;
26823 char * kwnames[] = {
26824 (char *) "self",(char *) "date", NULL
26825 };
26826
26827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
26828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26829 if (!SWIG_IsOK(res1)) {
26830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
26831 }
26832 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26833 {
26834 arg2 = wxString_in_helper(obj1);
26835 if (arg2 == NULL) SWIG_fail;
26836 temp2 = true;
26837 }
26838 {
26839 PyThreadState* __tstate = wxPyBeginAllowThreads();
26840 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
26841 wxPyEndAllowThreads(__tstate);
26842 if (PyErr_Occurred()) SWIG_fail;
26843 }
26844 resultobj = SWIG_From_int(static_cast< int >(result));
26845 {
26846 if (temp2)
26847 delete arg2;
26848 }
26849 return resultobj;
26850 fail:
26851 {
26852 if (temp2)
26853 delete arg2;
26854 }
26855 return NULL;
26856 }
26857
26858
26859 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26860 PyObject *resultobj = 0;
26861 wxDateTime *arg1 = (wxDateTime *) 0 ;
26862 wxString *arg2 = 0 ;
26863 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
26864 wxString *arg3 = (wxString *) &arg3_defvalue ;
26865 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
26866 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
26867 int result;
26868 void *argp1 = 0 ;
26869 int res1 = 0 ;
26870 bool temp2 = false ;
26871 bool temp3 = false ;
26872 void *argp4 = 0 ;
26873 int res4 = 0 ;
26874 PyObject * obj0 = 0 ;
26875 PyObject * obj1 = 0 ;
26876 PyObject * obj2 = 0 ;
26877 PyObject * obj3 = 0 ;
26878 char * kwnames[] = {
26879 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
26880 };
26881
26882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26884 if (!SWIG_IsOK(res1)) {
26885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
26886 }
26887 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26888 {
26889 arg2 = wxString_in_helper(obj1);
26890 if (arg2 == NULL) SWIG_fail;
26891 temp2 = true;
26892 }
26893 if (obj2) {
26894 {
26895 arg3 = wxString_in_helper(obj2);
26896 if (arg3 == NULL) SWIG_fail;
26897 temp3 = true;
26898 }
26899 }
26900 if (obj3) {
26901 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
26902 if (!SWIG_IsOK(res4)) {
26903 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26904 }
26905 if (!argp4) {
26906 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26907 }
26908 arg4 = reinterpret_cast< wxDateTime * >(argp4);
26909 }
26910 {
26911 PyThreadState* __tstate = wxPyBeginAllowThreads();
26912 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
26913 wxPyEndAllowThreads(__tstate);
26914 if (PyErr_Occurred()) SWIG_fail;
26915 }
26916 resultobj = SWIG_From_int(static_cast< int >(result));
26917 {
26918 if (temp2)
26919 delete arg2;
26920 }
26921 {
26922 if (temp3)
26923 delete arg3;
26924 }
26925 return resultobj;
26926 fail:
26927 {
26928 if (temp2)
26929 delete arg2;
26930 }
26931 {
26932 if (temp3)
26933 delete arg3;
26934 }
26935 return NULL;
26936 }
26937
26938
26939 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26940 PyObject *resultobj = 0;
26941 wxDateTime *arg1 = (wxDateTime *) 0 ;
26942 wxString *arg2 = 0 ;
26943 int result;
26944 void *argp1 = 0 ;
26945 int res1 = 0 ;
26946 bool temp2 = false ;
26947 PyObject * obj0 = 0 ;
26948 PyObject * obj1 = 0 ;
26949 char * kwnames[] = {
26950 (char *) "self",(char *) "datetime", NULL
26951 };
26952
26953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
26954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26955 if (!SWIG_IsOK(res1)) {
26956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
26957 }
26958 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26959 {
26960 arg2 = wxString_in_helper(obj1);
26961 if (arg2 == NULL) SWIG_fail;
26962 temp2 = true;
26963 }
26964 {
26965 PyThreadState* __tstate = wxPyBeginAllowThreads();
26966 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
26967 wxPyEndAllowThreads(__tstate);
26968 if (PyErr_Occurred()) SWIG_fail;
26969 }
26970 resultobj = SWIG_From_int(static_cast< int >(result));
26971 {
26972 if (temp2)
26973 delete arg2;
26974 }
26975 return resultobj;
26976 fail:
26977 {
26978 if (temp2)
26979 delete arg2;
26980 }
26981 return NULL;
26982 }
26983
26984
26985 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26986 PyObject *resultobj = 0;
26987 wxDateTime *arg1 = (wxDateTime *) 0 ;
26988 wxString *arg2 = 0 ;
26989 int result;
26990 void *argp1 = 0 ;
26991 int res1 = 0 ;
26992 bool temp2 = false ;
26993 PyObject * obj0 = 0 ;
26994 PyObject * obj1 = 0 ;
26995 char * kwnames[] = {
26996 (char *) "self",(char *) "date", NULL
26997 };
26998
26999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
27000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27001 if (!SWIG_IsOK(res1)) {
27002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
27003 }
27004 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27005 {
27006 arg2 = wxString_in_helper(obj1);
27007 if (arg2 == NULL) SWIG_fail;
27008 temp2 = true;
27009 }
27010 {
27011 PyThreadState* __tstate = wxPyBeginAllowThreads();
27012 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
27013 wxPyEndAllowThreads(__tstate);
27014 if (PyErr_Occurred()) SWIG_fail;
27015 }
27016 resultobj = SWIG_From_int(static_cast< int >(result));
27017 {
27018 if (temp2)
27019 delete arg2;
27020 }
27021 return resultobj;
27022 fail:
27023 {
27024 if (temp2)
27025 delete arg2;
27026 }
27027 return NULL;
27028 }
27029
27030
27031 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27032 PyObject *resultobj = 0;
27033 wxDateTime *arg1 = (wxDateTime *) 0 ;
27034 wxString *arg2 = 0 ;
27035 int result;
27036 void *argp1 = 0 ;
27037 int res1 = 0 ;
27038 bool temp2 = false ;
27039 PyObject * obj0 = 0 ;
27040 PyObject * obj1 = 0 ;
27041 char * kwnames[] = {
27042 (char *) "self",(char *) "time", NULL
27043 };
27044
27045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
27046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27047 if (!SWIG_IsOK(res1)) {
27048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27049 }
27050 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27051 {
27052 arg2 = wxString_in_helper(obj1);
27053 if (arg2 == NULL) SWIG_fail;
27054 temp2 = true;
27055 }
27056 {
27057 PyThreadState* __tstate = wxPyBeginAllowThreads();
27058 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
27059 wxPyEndAllowThreads(__tstate);
27060 if (PyErr_Occurred()) SWIG_fail;
27061 }
27062 resultobj = SWIG_From_int(static_cast< int >(result));
27063 {
27064 if (temp2)
27065 delete arg2;
27066 }
27067 return resultobj;
27068 fail:
27069 {
27070 if (temp2)
27071 delete arg2;
27072 }
27073 return NULL;
27074 }
27075
27076
27077 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27078 PyObject *resultobj = 0;
27079 wxDateTime *arg1 = (wxDateTime *) 0 ;
27080 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
27081 wxString *arg2 = (wxString *) &arg2_defvalue ;
27082 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
27083 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
27084 wxString result;
27085 void *argp1 = 0 ;
27086 int res1 = 0 ;
27087 bool temp2 = false ;
27088 bool temp3 = false ;
27089 PyObject * obj0 = 0 ;
27090 PyObject * obj1 = 0 ;
27091 PyObject * obj2 = 0 ;
27092 char * kwnames[] = {
27093 (char *) "self",(char *) "format",(char *) "tz", NULL
27094 };
27095
27096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27098 if (!SWIG_IsOK(res1)) {
27099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27100 }
27101 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27102 if (obj1) {
27103 {
27104 arg2 = wxString_in_helper(obj1);
27105 if (arg2 == NULL) SWIG_fail;
27106 temp2 = true;
27107 }
27108 }
27109 if (obj2) {
27110 {
27111 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
27112 temp3 = true;
27113 }
27114 }
27115 {
27116 PyThreadState* __tstate = wxPyBeginAllowThreads();
27117 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
27118 wxPyEndAllowThreads(__tstate);
27119 if (PyErr_Occurred()) SWIG_fail;
27120 }
27121 {
27122 #if wxUSE_UNICODE
27123 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27124 #else
27125 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27126 #endif
27127 }
27128 {
27129 if (temp2)
27130 delete arg2;
27131 }
27132 {
27133 if (temp3) delete arg3;
27134 }
27135 return resultobj;
27136 fail:
27137 {
27138 if (temp2)
27139 delete arg2;
27140 }
27141 {
27142 if (temp3) delete arg3;
27143 }
27144 return NULL;
27145 }
27146
27147
27148 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27149 PyObject *resultobj = 0;
27150 wxDateTime *arg1 = (wxDateTime *) 0 ;
27151 wxString result;
27152 void *argp1 = 0 ;
27153 int res1 = 0 ;
27154 PyObject *swig_obj[1] ;
27155
27156 if (!args) SWIG_fail;
27157 swig_obj[0] = args;
27158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27159 if (!SWIG_IsOK(res1)) {
27160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27161 }
27162 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27163 {
27164 PyThreadState* __tstate = wxPyBeginAllowThreads();
27165 result = ((wxDateTime const *)arg1)->FormatDate();
27166 wxPyEndAllowThreads(__tstate);
27167 if (PyErr_Occurred()) SWIG_fail;
27168 }
27169 {
27170 #if wxUSE_UNICODE
27171 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27172 #else
27173 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27174 #endif
27175 }
27176 return resultobj;
27177 fail:
27178 return NULL;
27179 }
27180
27181
27182 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27183 PyObject *resultobj = 0;
27184 wxDateTime *arg1 = (wxDateTime *) 0 ;
27185 wxString result;
27186 void *argp1 = 0 ;
27187 int res1 = 0 ;
27188 PyObject *swig_obj[1] ;
27189
27190 if (!args) SWIG_fail;
27191 swig_obj[0] = args;
27192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27193 if (!SWIG_IsOK(res1)) {
27194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27195 }
27196 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27197 {
27198 PyThreadState* __tstate = wxPyBeginAllowThreads();
27199 result = ((wxDateTime const *)arg1)->FormatTime();
27200 wxPyEndAllowThreads(__tstate);
27201 if (PyErr_Occurred()) SWIG_fail;
27202 }
27203 {
27204 #if wxUSE_UNICODE
27205 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27206 #else
27207 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27208 #endif
27209 }
27210 return resultobj;
27211 fail:
27212 return NULL;
27213 }
27214
27215
27216 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27217 PyObject *resultobj = 0;
27218 wxDateTime *arg1 = (wxDateTime *) 0 ;
27219 wxString result;
27220 void *argp1 = 0 ;
27221 int res1 = 0 ;
27222 PyObject *swig_obj[1] ;
27223
27224 if (!args) SWIG_fail;
27225 swig_obj[0] = args;
27226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27227 if (!SWIG_IsOK(res1)) {
27228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27229 }
27230 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27231 {
27232 PyThreadState* __tstate = wxPyBeginAllowThreads();
27233 result = ((wxDateTime const *)arg1)->FormatISODate();
27234 wxPyEndAllowThreads(__tstate);
27235 if (PyErr_Occurred()) SWIG_fail;
27236 }
27237 {
27238 #if wxUSE_UNICODE
27239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27240 #else
27241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27242 #endif
27243 }
27244 return resultobj;
27245 fail:
27246 return NULL;
27247 }
27248
27249
27250 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27251 PyObject *resultobj = 0;
27252 wxDateTime *arg1 = (wxDateTime *) 0 ;
27253 wxString result;
27254 void *argp1 = 0 ;
27255 int res1 = 0 ;
27256 PyObject *swig_obj[1] ;
27257
27258 if (!args) SWIG_fail;
27259 swig_obj[0] = args;
27260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27261 if (!SWIG_IsOK(res1)) {
27262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27263 }
27264 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27265 {
27266 PyThreadState* __tstate = wxPyBeginAllowThreads();
27267 result = ((wxDateTime const *)arg1)->FormatISOTime();
27268 wxPyEndAllowThreads(__tstate);
27269 if (PyErr_Occurred()) SWIG_fail;
27270 }
27271 {
27272 #if wxUSE_UNICODE
27273 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27274 #else
27275 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27276 #endif
27277 }
27278 return resultobj;
27279 fail:
27280 return NULL;
27281 }
27282
27283
27284 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27285 PyObject *obj;
27286 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27287 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
27288 return SWIG_Py_Void();
27289 }
27290
27291 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27292 return SWIG_Python_InitShadowInstance(args);
27293 }
27294
27295 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27296 PyObject *resultobj = 0;
27297 long arg1 ;
27298 wxTimeSpan result;
27299 long val1 ;
27300 int ecode1 = 0 ;
27301 PyObject * obj0 = 0 ;
27302 char * kwnames[] = {
27303 (char *) "ms", NULL
27304 };
27305
27306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
27307 ecode1 = SWIG_AsVal_long(obj0, &val1);
27308 if (!SWIG_IsOK(ecode1)) {
27309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
27310 }
27311 arg1 = static_cast< long >(val1);
27312 {
27313 PyThreadState* __tstate = wxPyBeginAllowThreads();
27314 result = wxTimeSpan::Milliseconds(arg1);
27315 wxPyEndAllowThreads(__tstate);
27316 if (PyErr_Occurred()) SWIG_fail;
27317 }
27318 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27319 return resultobj;
27320 fail:
27321 return NULL;
27322 }
27323
27324
27325 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27326 PyObject *resultobj = 0;
27327 wxTimeSpan result;
27328
27329 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
27330 {
27331 PyThreadState* __tstate = wxPyBeginAllowThreads();
27332 result = wxTimeSpan::Millisecond();
27333 wxPyEndAllowThreads(__tstate);
27334 if (PyErr_Occurred()) SWIG_fail;
27335 }
27336 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27337 return resultobj;
27338 fail:
27339 return NULL;
27340 }
27341
27342
27343 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27344 PyObject *resultobj = 0;
27345 long arg1 ;
27346 wxTimeSpan result;
27347 long val1 ;
27348 int ecode1 = 0 ;
27349 PyObject * obj0 = 0 ;
27350 char * kwnames[] = {
27351 (char *) "sec", NULL
27352 };
27353
27354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
27355 ecode1 = SWIG_AsVal_long(obj0, &val1);
27356 if (!SWIG_IsOK(ecode1)) {
27357 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
27358 }
27359 arg1 = static_cast< long >(val1);
27360 {
27361 PyThreadState* __tstate = wxPyBeginAllowThreads();
27362 result = wxTimeSpan::Seconds(arg1);
27363 wxPyEndAllowThreads(__tstate);
27364 if (PyErr_Occurred()) SWIG_fail;
27365 }
27366 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27367 return resultobj;
27368 fail:
27369 return NULL;
27370 }
27371
27372
27373 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27374 PyObject *resultobj = 0;
27375 wxTimeSpan result;
27376
27377 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
27378 {
27379 PyThreadState* __tstate = wxPyBeginAllowThreads();
27380 result = wxTimeSpan::Second();
27381 wxPyEndAllowThreads(__tstate);
27382 if (PyErr_Occurred()) SWIG_fail;
27383 }
27384 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27385 return resultobj;
27386 fail:
27387 return NULL;
27388 }
27389
27390
27391 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27392 PyObject *resultobj = 0;
27393 long arg1 ;
27394 wxTimeSpan result;
27395 long val1 ;
27396 int ecode1 = 0 ;
27397 PyObject * obj0 = 0 ;
27398 char * kwnames[] = {
27399 (char *) "min", NULL
27400 };
27401
27402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
27403 ecode1 = SWIG_AsVal_long(obj0, &val1);
27404 if (!SWIG_IsOK(ecode1)) {
27405 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
27406 }
27407 arg1 = static_cast< long >(val1);
27408 {
27409 PyThreadState* __tstate = wxPyBeginAllowThreads();
27410 result = wxTimeSpan::Minutes(arg1);
27411 wxPyEndAllowThreads(__tstate);
27412 if (PyErr_Occurred()) SWIG_fail;
27413 }
27414 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27415 return resultobj;
27416 fail:
27417 return NULL;
27418 }
27419
27420
27421 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27422 PyObject *resultobj = 0;
27423 wxTimeSpan result;
27424
27425 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
27426 {
27427 PyThreadState* __tstate = wxPyBeginAllowThreads();
27428 result = wxTimeSpan::Minute();
27429 wxPyEndAllowThreads(__tstate);
27430 if (PyErr_Occurred()) SWIG_fail;
27431 }
27432 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27433 return resultobj;
27434 fail:
27435 return NULL;
27436 }
27437
27438
27439 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27440 PyObject *resultobj = 0;
27441 long arg1 ;
27442 wxTimeSpan result;
27443 long val1 ;
27444 int ecode1 = 0 ;
27445 PyObject * obj0 = 0 ;
27446 char * kwnames[] = {
27447 (char *) "hours", NULL
27448 };
27449
27450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
27451 ecode1 = SWIG_AsVal_long(obj0, &val1);
27452 if (!SWIG_IsOK(ecode1)) {
27453 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
27454 }
27455 arg1 = static_cast< long >(val1);
27456 {
27457 PyThreadState* __tstate = wxPyBeginAllowThreads();
27458 result = wxTimeSpan::Hours(arg1);
27459 wxPyEndAllowThreads(__tstate);
27460 if (PyErr_Occurred()) SWIG_fail;
27461 }
27462 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27463 return resultobj;
27464 fail:
27465 return NULL;
27466 }
27467
27468
27469 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27470 PyObject *resultobj = 0;
27471 wxTimeSpan result;
27472
27473 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
27474 {
27475 PyThreadState* __tstate = wxPyBeginAllowThreads();
27476 result = wxTimeSpan::Hour();
27477 wxPyEndAllowThreads(__tstate);
27478 if (PyErr_Occurred()) SWIG_fail;
27479 }
27480 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27481 return resultobj;
27482 fail:
27483 return NULL;
27484 }
27485
27486
27487 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27488 PyObject *resultobj = 0;
27489 long arg1 ;
27490 wxTimeSpan result;
27491 long val1 ;
27492 int ecode1 = 0 ;
27493 PyObject * obj0 = 0 ;
27494 char * kwnames[] = {
27495 (char *) "days", NULL
27496 };
27497
27498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
27499 ecode1 = SWIG_AsVal_long(obj0, &val1);
27500 if (!SWIG_IsOK(ecode1)) {
27501 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
27502 }
27503 arg1 = static_cast< long >(val1);
27504 {
27505 PyThreadState* __tstate = wxPyBeginAllowThreads();
27506 result = wxTimeSpan::Days(arg1);
27507 wxPyEndAllowThreads(__tstate);
27508 if (PyErr_Occurred()) SWIG_fail;
27509 }
27510 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27511 return resultobj;
27512 fail:
27513 return NULL;
27514 }
27515
27516
27517 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27518 PyObject *resultobj = 0;
27519 wxTimeSpan result;
27520
27521 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
27522 {
27523 PyThreadState* __tstate = wxPyBeginAllowThreads();
27524 result = wxTimeSpan::Day();
27525 wxPyEndAllowThreads(__tstate);
27526 if (PyErr_Occurred()) SWIG_fail;
27527 }
27528 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27529 return resultobj;
27530 fail:
27531 return NULL;
27532 }
27533
27534
27535 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27536 PyObject *resultobj = 0;
27537 long arg1 ;
27538 wxTimeSpan result;
27539 long val1 ;
27540 int ecode1 = 0 ;
27541 PyObject * obj0 = 0 ;
27542 char * kwnames[] = {
27543 (char *) "days", NULL
27544 };
27545
27546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
27547 ecode1 = SWIG_AsVal_long(obj0, &val1);
27548 if (!SWIG_IsOK(ecode1)) {
27549 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
27550 }
27551 arg1 = static_cast< long >(val1);
27552 {
27553 PyThreadState* __tstate = wxPyBeginAllowThreads();
27554 result = wxTimeSpan::Weeks(arg1);
27555 wxPyEndAllowThreads(__tstate);
27556 if (PyErr_Occurred()) SWIG_fail;
27557 }
27558 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27559 return resultobj;
27560 fail:
27561 return NULL;
27562 }
27563
27564
27565 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27566 PyObject *resultobj = 0;
27567 wxTimeSpan result;
27568
27569 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
27570 {
27571 PyThreadState* __tstate = wxPyBeginAllowThreads();
27572 result = wxTimeSpan::Week();
27573 wxPyEndAllowThreads(__tstate);
27574 if (PyErr_Occurred()) SWIG_fail;
27575 }
27576 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27577 return resultobj;
27578 fail:
27579 return NULL;
27580 }
27581
27582
27583 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27584 PyObject *resultobj = 0;
27585 long arg1 = (long) 0 ;
27586 long arg2 = (long) 0 ;
27587 long arg3 = (long) 0 ;
27588 long arg4 = (long) 0 ;
27589 wxTimeSpan *result = 0 ;
27590 long val1 ;
27591 int ecode1 = 0 ;
27592 long val2 ;
27593 int ecode2 = 0 ;
27594 long val3 ;
27595 int ecode3 = 0 ;
27596 long val4 ;
27597 int ecode4 = 0 ;
27598 PyObject * obj0 = 0 ;
27599 PyObject * obj1 = 0 ;
27600 PyObject * obj2 = 0 ;
27601 PyObject * obj3 = 0 ;
27602 char * kwnames[] = {
27603 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
27604 };
27605
27606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27607 if (obj0) {
27608 ecode1 = SWIG_AsVal_long(obj0, &val1);
27609 if (!SWIG_IsOK(ecode1)) {
27610 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
27611 }
27612 arg1 = static_cast< long >(val1);
27613 }
27614 if (obj1) {
27615 ecode2 = SWIG_AsVal_long(obj1, &val2);
27616 if (!SWIG_IsOK(ecode2)) {
27617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
27618 }
27619 arg2 = static_cast< long >(val2);
27620 }
27621 if (obj2) {
27622 ecode3 = SWIG_AsVal_long(obj2, &val3);
27623 if (!SWIG_IsOK(ecode3)) {
27624 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
27625 }
27626 arg3 = static_cast< long >(val3);
27627 }
27628 if (obj3) {
27629 ecode4 = SWIG_AsVal_long(obj3, &val4);
27630 if (!SWIG_IsOK(ecode4)) {
27631 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
27632 }
27633 arg4 = static_cast< long >(val4);
27634 }
27635 {
27636 PyThreadState* __tstate = wxPyBeginAllowThreads();
27637 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
27638 wxPyEndAllowThreads(__tstate);
27639 if (PyErr_Occurred()) SWIG_fail;
27640 }
27641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
27642 return resultobj;
27643 fail:
27644 return NULL;
27645 }
27646
27647
27648 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27649 PyObject *resultobj = 0;
27650 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27651 void *argp1 = 0 ;
27652 int res1 = 0 ;
27653 PyObject *swig_obj[1] ;
27654
27655 if (!args) SWIG_fail;
27656 swig_obj[0] = args;
27657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27658 if (!SWIG_IsOK(res1)) {
27659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27660 }
27661 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27662 {
27663 PyThreadState* __tstate = wxPyBeginAllowThreads();
27664 delete arg1;
27665
27666 wxPyEndAllowThreads(__tstate);
27667 if (PyErr_Occurred()) SWIG_fail;
27668 }
27669 resultobj = SWIG_Py_Void();
27670 return resultobj;
27671 fail:
27672 return NULL;
27673 }
27674
27675
27676 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27677 PyObject *resultobj = 0;
27678 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27679 wxTimeSpan *arg2 = 0 ;
27680 wxTimeSpan *result = 0 ;
27681 void *argp1 = 0 ;
27682 int res1 = 0 ;
27683 void *argp2 = 0 ;
27684 int res2 = 0 ;
27685 PyObject * obj0 = 0 ;
27686 PyObject * obj1 = 0 ;
27687 char * kwnames[] = {
27688 (char *) "self",(char *) "diff", NULL
27689 };
27690
27691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
27692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27693 if (!SWIG_IsOK(res1)) {
27694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27695 }
27696 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27697 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27698 if (!SWIG_IsOK(res2)) {
27699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27700 }
27701 if (!argp2) {
27702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27703 }
27704 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27705 {
27706 PyThreadState* __tstate = wxPyBeginAllowThreads();
27707 {
27708 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27709 result = (wxTimeSpan *) &_result_ref;
27710 }
27711 wxPyEndAllowThreads(__tstate);
27712 if (PyErr_Occurred()) SWIG_fail;
27713 }
27714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27715 return resultobj;
27716 fail:
27717 return NULL;
27718 }
27719
27720
27721 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27722 PyObject *resultobj = 0;
27723 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27724 wxTimeSpan *arg2 = 0 ;
27725 wxTimeSpan *result = 0 ;
27726 void *argp1 = 0 ;
27727 int res1 = 0 ;
27728 void *argp2 = 0 ;
27729 int res2 = 0 ;
27730 PyObject * obj0 = 0 ;
27731 PyObject * obj1 = 0 ;
27732 char * kwnames[] = {
27733 (char *) "self",(char *) "diff", NULL
27734 };
27735
27736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27738 if (!SWIG_IsOK(res1)) {
27739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27740 }
27741 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27742 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27743 if (!SWIG_IsOK(res2)) {
27744 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27745 }
27746 if (!argp2) {
27747 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27748 }
27749 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27750 {
27751 PyThreadState* __tstate = wxPyBeginAllowThreads();
27752 {
27753 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27754 result = (wxTimeSpan *) &_result_ref;
27755 }
27756 wxPyEndAllowThreads(__tstate);
27757 if (PyErr_Occurred()) SWIG_fail;
27758 }
27759 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27760 return resultobj;
27761 fail:
27762 return NULL;
27763 }
27764
27765
27766 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27767 PyObject *resultobj = 0;
27768 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27769 int arg2 ;
27770 wxTimeSpan *result = 0 ;
27771 void *argp1 = 0 ;
27772 int res1 = 0 ;
27773 int val2 ;
27774 int ecode2 = 0 ;
27775 PyObject * obj0 = 0 ;
27776 PyObject * obj1 = 0 ;
27777 char * kwnames[] = {
27778 (char *) "self",(char *) "n", NULL
27779 };
27780
27781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
27782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27783 if (!SWIG_IsOK(res1)) {
27784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27785 }
27786 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27787 ecode2 = SWIG_AsVal_int(obj1, &val2);
27788 if (!SWIG_IsOK(ecode2)) {
27789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
27790 }
27791 arg2 = static_cast< int >(val2);
27792 {
27793 PyThreadState* __tstate = wxPyBeginAllowThreads();
27794 {
27795 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
27796 result = (wxTimeSpan *) &_result_ref;
27797 }
27798 wxPyEndAllowThreads(__tstate);
27799 if (PyErr_Occurred()) SWIG_fail;
27800 }
27801 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27802 return resultobj;
27803 fail:
27804 return NULL;
27805 }
27806
27807
27808 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27809 PyObject *resultobj = 0;
27810 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27811 wxTimeSpan *result = 0 ;
27812 void *argp1 = 0 ;
27813 int res1 = 0 ;
27814 PyObject *swig_obj[1] ;
27815
27816 if (!args) SWIG_fail;
27817 swig_obj[0] = args;
27818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27819 if (!SWIG_IsOK(res1)) {
27820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27821 }
27822 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27823 {
27824 PyThreadState* __tstate = wxPyBeginAllowThreads();
27825 {
27826 wxTimeSpan &_result_ref = (arg1)->Neg();
27827 result = (wxTimeSpan *) &_result_ref;
27828 }
27829 wxPyEndAllowThreads(__tstate);
27830 if (PyErr_Occurred()) SWIG_fail;
27831 }
27832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27833 return resultobj;
27834 fail:
27835 return NULL;
27836 }
27837
27838
27839 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27840 PyObject *resultobj = 0;
27841 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27842 wxTimeSpan result;
27843 void *argp1 = 0 ;
27844 int res1 = 0 ;
27845 PyObject *swig_obj[1] ;
27846
27847 if (!args) SWIG_fail;
27848 swig_obj[0] = args;
27849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27850 if (!SWIG_IsOK(res1)) {
27851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
27852 }
27853 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27854 {
27855 PyThreadState* __tstate = wxPyBeginAllowThreads();
27856 result = ((wxTimeSpan const *)arg1)->Abs();
27857 wxPyEndAllowThreads(__tstate);
27858 if (PyErr_Occurred()) SWIG_fail;
27859 }
27860 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27861 return resultobj;
27862 fail:
27863 return NULL;
27864 }
27865
27866
27867 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27868 PyObject *resultobj = 0;
27869 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27870 wxTimeSpan *arg2 = 0 ;
27871 wxTimeSpan *result = 0 ;
27872 void *argp1 = 0 ;
27873 int res1 = 0 ;
27874 void *argp2 = 0 ;
27875 int res2 = 0 ;
27876 PyObject * obj0 = 0 ;
27877 PyObject * obj1 = 0 ;
27878 char * kwnames[] = {
27879 (char *) "self",(char *) "diff", NULL
27880 };
27881
27882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
27883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27884 if (!SWIG_IsOK(res1)) {
27885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27886 }
27887 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27888 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27889 if (!SWIG_IsOK(res2)) {
27890 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27891 }
27892 if (!argp2) {
27893 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27894 }
27895 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27896 {
27897 PyThreadState* __tstate = wxPyBeginAllowThreads();
27898 {
27899 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27900 result = (wxTimeSpan *) &_result_ref;
27901 }
27902 wxPyEndAllowThreads(__tstate);
27903 if (PyErr_Occurred()) SWIG_fail;
27904 }
27905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27906 return resultobj;
27907 fail:
27908 return NULL;
27909 }
27910
27911
27912 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27913 PyObject *resultobj = 0;
27914 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27915 wxTimeSpan *arg2 = 0 ;
27916 wxTimeSpan *result = 0 ;
27917 void *argp1 = 0 ;
27918 int res1 = 0 ;
27919 void *argp2 = 0 ;
27920 int res2 = 0 ;
27921 PyObject * obj0 = 0 ;
27922 PyObject * obj1 = 0 ;
27923 char * kwnames[] = {
27924 (char *) "self",(char *) "diff", NULL
27925 };
27926
27927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
27928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27929 if (!SWIG_IsOK(res1)) {
27930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27931 }
27932 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27933 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27934 if (!SWIG_IsOK(res2)) {
27935 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27936 }
27937 if (!argp2) {
27938 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27939 }
27940 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27941 {
27942 PyThreadState* __tstate = wxPyBeginAllowThreads();
27943 {
27944 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27945 result = (wxTimeSpan *) &_result_ref;
27946 }
27947 wxPyEndAllowThreads(__tstate);
27948 if (PyErr_Occurred()) SWIG_fail;
27949 }
27950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27951 return resultobj;
27952 fail:
27953 return NULL;
27954 }
27955
27956
27957 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27958 PyObject *resultobj = 0;
27959 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27960 int arg2 ;
27961 wxTimeSpan *result = 0 ;
27962 void *argp1 = 0 ;
27963 int res1 = 0 ;
27964 int val2 ;
27965 int ecode2 = 0 ;
27966 PyObject * obj0 = 0 ;
27967 PyObject * obj1 = 0 ;
27968 char * kwnames[] = {
27969 (char *) "self",(char *) "n", NULL
27970 };
27971
27972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
27973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27974 if (!SWIG_IsOK(res1)) {
27975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27976 }
27977 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27978 ecode2 = SWIG_AsVal_int(obj1, &val2);
27979 if (!SWIG_IsOK(ecode2)) {
27980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
27981 }
27982 arg2 = static_cast< int >(val2);
27983 {
27984 PyThreadState* __tstate = wxPyBeginAllowThreads();
27985 {
27986 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
27987 result = (wxTimeSpan *) &_result_ref;
27988 }
27989 wxPyEndAllowThreads(__tstate);
27990 if (PyErr_Occurred()) SWIG_fail;
27991 }
27992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27993 return resultobj;
27994 fail:
27995 return NULL;
27996 }
27997
27998
27999 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28000 PyObject *resultobj = 0;
28001 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28002 wxTimeSpan *result = 0 ;
28003 void *argp1 = 0 ;
28004 int res1 = 0 ;
28005 PyObject *swig_obj[1] ;
28006
28007 if (!args) SWIG_fail;
28008 swig_obj[0] = args;
28009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28010 if (!SWIG_IsOK(res1)) {
28011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28012 }
28013 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28014 {
28015 PyThreadState* __tstate = wxPyBeginAllowThreads();
28016 {
28017 wxTimeSpan &_result_ref = (arg1)->operator -();
28018 result = (wxTimeSpan *) &_result_ref;
28019 }
28020 wxPyEndAllowThreads(__tstate);
28021 if (PyErr_Occurred()) SWIG_fail;
28022 }
28023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28024 return resultobj;
28025 fail:
28026 return NULL;
28027 }
28028
28029
28030 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28031 PyObject *resultobj = 0;
28032 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28033 wxTimeSpan *arg2 = 0 ;
28034 wxTimeSpan result;
28035 void *argp1 = 0 ;
28036 int res1 = 0 ;
28037 void *argp2 = 0 ;
28038 int res2 = 0 ;
28039 PyObject * obj0 = 0 ;
28040 PyObject * obj1 = 0 ;
28041 char * kwnames[] = {
28042 (char *) "self",(char *) "other", NULL
28043 };
28044
28045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
28046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28047 if (!SWIG_IsOK(res1)) {
28048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28049 }
28050 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28051 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28052 if (!SWIG_IsOK(res2)) {
28053 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28054 }
28055 if (!argp2) {
28056 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28057 }
28058 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28059 {
28060 PyThreadState* __tstate = wxPyBeginAllowThreads();
28061 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
28062 wxPyEndAllowThreads(__tstate);
28063 if (PyErr_Occurred()) SWIG_fail;
28064 }
28065 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28066 return resultobj;
28067 fail:
28068 return NULL;
28069 }
28070
28071
28072 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28073 PyObject *resultobj = 0;
28074 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28075 wxTimeSpan *arg2 = 0 ;
28076 wxTimeSpan result;
28077 void *argp1 = 0 ;
28078 int res1 = 0 ;
28079 void *argp2 = 0 ;
28080 int res2 = 0 ;
28081 PyObject * obj0 = 0 ;
28082 PyObject * obj1 = 0 ;
28083 char * kwnames[] = {
28084 (char *) "self",(char *) "other", NULL
28085 };
28086
28087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
28088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28089 if (!SWIG_IsOK(res1)) {
28090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28091 }
28092 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28093 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28094 if (!SWIG_IsOK(res2)) {
28095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28096 }
28097 if (!argp2) {
28098 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28099 }
28100 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28101 {
28102 PyThreadState* __tstate = wxPyBeginAllowThreads();
28103 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
28104 wxPyEndAllowThreads(__tstate);
28105 if (PyErr_Occurred()) SWIG_fail;
28106 }
28107 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28108 return resultobj;
28109 fail:
28110 return NULL;
28111 }
28112
28113
28114 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28115 PyObject *resultobj = 0;
28116 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28117 int arg2 ;
28118 wxTimeSpan result;
28119 void *argp1 = 0 ;
28120 int res1 = 0 ;
28121 int val2 ;
28122 int ecode2 = 0 ;
28123 PyObject * obj0 = 0 ;
28124 PyObject * obj1 = 0 ;
28125 char * kwnames[] = {
28126 (char *) "self",(char *) "n", NULL
28127 };
28128
28129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
28130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28131 if (!SWIG_IsOK(res1)) {
28132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28133 }
28134 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28135 ecode2 = SWIG_AsVal_int(obj1, &val2);
28136 if (!SWIG_IsOK(ecode2)) {
28137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
28138 }
28139 arg2 = static_cast< int >(val2);
28140 {
28141 PyThreadState* __tstate = wxPyBeginAllowThreads();
28142 result = wxTimeSpan___mul__(arg1,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___rmul__(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___rmul__",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___rmul__" "', 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___rmul__" "', expected argument " "2"" of type '" "int""'");
28177 }
28178 arg2 = static_cast< int >(val2);
28179 {
28180 PyThreadState* __tstate = wxPyBeginAllowThreads();
28181 result = wxTimeSpan___rmul__(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___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28193 PyObject *resultobj = 0;
28194 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28195 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28196 bool result;
28197 void *argp1 = 0 ;
28198 int res1 = 0 ;
28199 void *argp2 = 0 ;
28200 int res2 = 0 ;
28201 PyObject * obj0 = 0 ;
28202 PyObject * obj1 = 0 ;
28203 char * kwnames[] = {
28204 (char *) "self",(char *) "other", NULL
28205 };
28206
28207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",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___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28211 }
28212 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28213 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28214 if (!SWIG_IsOK(res2)) {
28215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28216 }
28217 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28218 {
28219 PyThreadState* __tstate = wxPyBeginAllowThreads();
28220 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
28221 wxPyEndAllowThreads(__tstate);
28222 if (PyErr_Occurred()) SWIG_fail;
28223 }
28224 {
28225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28226 }
28227 return resultobj;
28228 fail:
28229 return NULL;
28230 }
28231
28232
28233 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28234 PyObject *resultobj = 0;
28235 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28236 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28237 bool result;
28238 void *argp1 = 0 ;
28239 int res1 = 0 ;
28240 void *argp2 = 0 ;
28241 int res2 = 0 ;
28242 PyObject * obj0 = 0 ;
28243 PyObject * obj1 = 0 ;
28244 char * kwnames[] = {
28245 (char *) "self",(char *) "other", NULL
28246 };
28247
28248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28250 if (!SWIG_IsOK(res1)) {
28251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28252 }
28253 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28254 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28255 if (!SWIG_IsOK(res2)) {
28256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28257 }
28258 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28259 {
28260 PyThreadState* __tstate = wxPyBeginAllowThreads();
28261 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
28262 wxPyEndAllowThreads(__tstate);
28263 if (PyErr_Occurred()) SWIG_fail;
28264 }
28265 {
28266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28267 }
28268 return resultobj;
28269 fail:
28270 return NULL;
28271 }
28272
28273
28274 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28275 PyObject *resultobj = 0;
28276 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28277 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28278 bool result;
28279 void *argp1 = 0 ;
28280 int res1 = 0 ;
28281 void *argp2 = 0 ;
28282 int res2 = 0 ;
28283 PyObject * obj0 = 0 ;
28284 PyObject * obj1 = 0 ;
28285 char * kwnames[] = {
28286 (char *) "self",(char *) "other", NULL
28287 };
28288
28289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28291 if (!SWIG_IsOK(res1)) {
28292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28293 }
28294 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28295 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28296 if (!SWIG_IsOK(res2)) {
28297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28298 }
28299 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28300 {
28301 PyThreadState* __tstate = wxPyBeginAllowThreads();
28302 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
28303 wxPyEndAllowThreads(__tstate);
28304 if (PyErr_Occurred()) SWIG_fail;
28305 }
28306 {
28307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28308 }
28309 return resultobj;
28310 fail:
28311 return NULL;
28312 }
28313
28314
28315 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28316 PyObject *resultobj = 0;
28317 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28318 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28319 bool result;
28320 void *argp1 = 0 ;
28321 int res1 = 0 ;
28322 void *argp2 = 0 ;
28323 int res2 = 0 ;
28324 PyObject * obj0 = 0 ;
28325 PyObject * obj1 = 0 ;
28326 char * kwnames[] = {
28327 (char *) "self",(char *) "other", NULL
28328 };
28329
28330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28332 if (!SWIG_IsOK(res1)) {
28333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28334 }
28335 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28336 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28337 if (!SWIG_IsOK(res2)) {
28338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28339 }
28340 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28341 {
28342 PyThreadState* __tstate = wxPyBeginAllowThreads();
28343 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
28344 wxPyEndAllowThreads(__tstate);
28345 if (PyErr_Occurred()) SWIG_fail;
28346 }
28347 {
28348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28349 }
28350 return resultobj;
28351 fail:
28352 return NULL;
28353 }
28354
28355
28356 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28357 PyObject *resultobj = 0;
28358 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28359 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28360 bool result;
28361 void *argp1 = 0 ;
28362 int res1 = 0 ;
28363 void *argp2 = 0 ;
28364 int res2 = 0 ;
28365 PyObject * obj0 = 0 ;
28366 PyObject * obj1 = 0 ;
28367 char * kwnames[] = {
28368 (char *) "self",(char *) "other", NULL
28369 };
28370
28371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28373 if (!SWIG_IsOK(res1)) {
28374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28375 }
28376 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28377 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28378 if (!SWIG_IsOK(res2)) {
28379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28380 }
28381 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28382 {
28383 PyThreadState* __tstate = wxPyBeginAllowThreads();
28384 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
28385 wxPyEndAllowThreads(__tstate);
28386 if (PyErr_Occurred()) SWIG_fail;
28387 }
28388 {
28389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28390 }
28391 return resultobj;
28392 fail:
28393 return NULL;
28394 }
28395
28396
28397 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28398 PyObject *resultobj = 0;
28399 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28400 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28401 bool result;
28402 void *argp1 = 0 ;
28403 int res1 = 0 ;
28404 void *argp2 = 0 ;
28405 int res2 = 0 ;
28406 PyObject * obj0 = 0 ;
28407 PyObject * obj1 = 0 ;
28408 char * kwnames[] = {
28409 (char *) "self",(char *) "other", NULL
28410 };
28411
28412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28414 if (!SWIG_IsOK(res1)) {
28415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28416 }
28417 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28418 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28419 if (!SWIG_IsOK(res2)) {
28420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28421 }
28422 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28423 {
28424 PyThreadState* __tstate = wxPyBeginAllowThreads();
28425 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
28426 wxPyEndAllowThreads(__tstate);
28427 if (PyErr_Occurred()) SWIG_fail;
28428 }
28429 {
28430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28431 }
28432 return resultobj;
28433 fail:
28434 return NULL;
28435 }
28436
28437
28438 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28439 PyObject *resultobj = 0;
28440 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28441 bool result;
28442 void *argp1 = 0 ;
28443 int res1 = 0 ;
28444 PyObject *swig_obj[1] ;
28445
28446 if (!args) SWIG_fail;
28447 swig_obj[0] = args;
28448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28449 if (!SWIG_IsOK(res1)) {
28450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28451 }
28452 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28453 {
28454 PyThreadState* __tstate = wxPyBeginAllowThreads();
28455 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
28456 wxPyEndAllowThreads(__tstate);
28457 if (PyErr_Occurred()) SWIG_fail;
28458 }
28459 {
28460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28461 }
28462 return resultobj;
28463 fail:
28464 return NULL;
28465 }
28466
28467
28468 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28469 PyObject *resultobj = 0;
28470 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28471 bool result;
28472 void *argp1 = 0 ;
28473 int res1 = 0 ;
28474 PyObject *swig_obj[1] ;
28475
28476 if (!args) SWIG_fail;
28477 swig_obj[0] = args;
28478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28479 if (!SWIG_IsOK(res1)) {
28480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28481 }
28482 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28483 {
28484 PyThreadState* __tstate = wxPyBeginAllowThreads();
28485 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
28486 wxPyEndAllowThreads(__tstate);
28487 if (PyErr_Occurred()) SWIG_fail;
28488 }
28489 {
28490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28491 }
28492 return resultobj;
28493 fail:
28494 return NULL;
28495 }
28496
28497
28498 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28499 PyObject *resultobj = 0;
28500 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28501 bool result;
28502 void *argp1 = 0 ;
28503 int res1 = 0 ;
28504 PyObject *swig_obj[1] ;
28505
28506 if (!args) SWIG_fail;
28507 swig_obj[0] = args;
28508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28509 if (!SWIG_IsOK(res1)) {
28510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28511 }
28512 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28513 {
28514 PyThreadState* __tstate = wxPyBeginAllowThreads();
28515 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
28516 wxPyEndAllowThreads(__tstate);
28517 if (PyErr_Occurred()) SWIG_fail;
28518 }
28519 {
28520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28521 }
28522 return resultobj;
28523 fail:
28524 return NULL;
28525 }
28526
28527
28528 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28529 PyObject *resultobj = 0;
28530 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28531 wxTimeSpan *arg2 = 0 ;
28532 bool result;
28533 void *argp1 = 0 ;
28534 int res1 = 0 ;
28535 void *argp2 = 0 ;
28536 int res2 = 0 ;
28537 PyObject * obj0 = 0 ;
28538 PyObject * obj1 = 0 ;
28539 char * kwnames[] = {
28540 (char *) "self",(char *) "ts", NULL
28541 };
28542
28543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
28544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28545 if (!SWIG_IsOK(res1)) {
28546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28547 }
28548 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28549 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28550 if (!SWIG_IsOK(res2)) {
28551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28552 }
28553 if (!argp2) {
28554 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28555 }
28556 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28557 {
28558 PyThreadState* __tstate = wxPyBeginAllowThreads();
28559 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
28560 wxPyEndAllowThreads(__tstate);
28561 if (PyErr_Occurred()) SWIG_fail;
28562 }
28563 {
28564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28565 }
28566 return resultobj;
28567 fail:
28568 return NULL;
28569 }
28570
28571
28572 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28573 PyObject *resultobj = 0;
28574 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28575 wxTimeSpan *arg2 = 0 ;
28576 bool result;
28577 void *argp1 = 0 ;
28578 int res1 = 0 ;
28579 void *argp2 = 0 ;
28580 int res2 = 0 ;
28581 PyObject * obj0 = 0 ;
28582 PyObject * obj1 = 0 ;
28583 char * kwnames[] = {
28584 (char *) "self",(char *) "ts", NULL
28585 };
28586
28587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
28588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28589 if (!SWIG_IsOK(res1)) {
28590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28591 }
28592 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28593 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28594 if (!SWIG_IsOK(res2)) {
28595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28596 }
28597 if (!argp2) {
28598 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28599 }
28600 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28601 {
28602 PyThreadState* __tstate = wxPyBeginAllowThreads();
28603 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
28604 wxPyEndAllowThreads(__tstate);
28605 if (PyErr_Occurred()) SWIG_fail;
28606 }
28607 {
28608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28609 }
28610 return resultobj;
28611 fail:
28612 return NULL;
28613 }
28614
28615
28616 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28617 PyObject *resultobj = 0;
28618 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28619 wxTimeSpan *arg2 = 0 ;
28620 bool result;
28621 void *argp1 = 0 ;
28622 int res1 = 0 ;
28623 void *argp2 = 0 ;
28624 int res2 = 0 ;
28625 PyObject * obj0 = 0 ;
28626 PyObject * obj1 = 0 ;
28627 char * kwnames[] = {
28628 (char *) "self",(char *) "t", NULL
28629 };
28630
28631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
28632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28633 if (!SWIG_IsOK(res1)) {
28634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28635 }
28636 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28637 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28638 if (!SWIG_IsOK(res2)) {
28639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28640 }
28641 if (!argp2) {
28642 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28643 }
28644 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28645 {
28646 PyThreadState* __tstate = wxPyBeginAllowThreads();
28647 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
28648 wxPyEndAllowThreads(__tstate);
28649 if (PyErr_Occurred()) SWIG_fail;
28650 }
28651 {
28652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28653 }
28654 return resultobj;
28655 fail:
28656 return NULL;
28657 }
28658
28659
28660 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28661 PyObject *resultobj = 0;
28662 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28663 int result;
28664 void *argp1 = 0 ;
28665 int res1 = 0 ;
28666 PyObject *swig_obj[1] ;
28667
28668 if (!args) SWIG_fail;
28669 swig_obj[0] = args;
28670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28671 if (!SWIG_IsOK(res1)) {
28672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28673 }
28674 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28675 {
28676 PyThreadState* __tstate = wxPyBeginAllowThreads();
28677 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
28678 wxPyEndAllowThreads(__tstate);
28679 if (PyErr_Occurred()) SWIG_fail;
28680 }
28681 resultobj = SWIG_From_int(static_cast< int >(result));
28682 return resultobj;
28683 fail:
28684 return NULL;
28685 }
28686
28687
28688 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28689 PyObject *resultobj = 0;
28690 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28691 int result;
28692 void *argp1 = 0 ;
28693 int res1 = 0 ;
28694 PyObject *swig_obj[1] ;
28695
28696 if (!args) SWIG_fail;
28697 swig_obj[0] = args;
28698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28699 if (!SWIG_IsOK(res1)) {
28700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28701 }
28702 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28703 {
28704 PyThreadState* __tstate = wxPyBeginAllowThreads();
28705 result = (int)((wxTimeSpan const *)arg1)->GetDays();
28706 wxPyEndAllowThreads(__tstate);
28707 if (PyErr_Occurred()) SWIG_fail;
28708 }
28709 resultobj = SWIG_From_int(static_cast< int >(result));
28710 return resultobj;
28711 fail:
28712 return NULL;
28713 }
28714
28715
28716 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28717 PyObject *resultobj = 0;
28718 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28719 int result;
28720 void *argp1 = 0 ;
28721 int res1 = 0 ;
28722 PyObject *swig_obj[1] ;
28723
28724 if (!args) SWIG_fail;
28725 swig_obj[0] = args;
28726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28727 if (!SWIG_IsOK(res1)) {
28728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28729 }
28730 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28731 {
28732 PyThreadState* __tstate = wxPyBeginAllowThreads();
28733 result = (int)((wxTimeSpan const *)arg1)->GetHours();
28734 wxPyEndAllowThreads(__tstate);
28735 if (PyErr_Occurred()) SWIG_fail;
28736 }
28737 resultobj = SWIG_From_int(static_cast< int >(result));
28738 return resultobj;
28739 fail:
28740 return NULL;
28741 }
28742
28743
28744 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28745 PyObject *resultobj = 0;
28746 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28747 int result;
28748 void *argp1 = 0 ;
28749 int res1 = 0 ;
28750 PyObject *swig_obj[1] ;
28751
28752 if (!args) SWIG_fail;
28753 swig_obj[0] = args;
28754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28755 if (!SWIG_IsOK(res1)) {
28756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28757 }
28758 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28759 {
28760 PyThreadState* __tstate = wxPyBeginAllowThreads();
28761 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
28762 wxPyEndAllowThreads(__tstate);
28763 if (PyErr_Occurred()) SWIG_fail;
28764 }
28765 resultobj = SWIG_From_int(static_cast< int >(result));
28766 return resultobj;
28767 fail:
28768 return NULL;
28769 }
28770
28771
28772 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28773 PyObject *resultobj = 0;
28774 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28775 wxLongLong result;
28776 void *argp1 = 0 ;
28777 int res1 = 0 ;
28778 PyObject *swig_obj[1] ;
28779
28780 if (!args) SWIG_fail;
28781 swig_obj[0] = args;
28782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28783 if (!SWIG_IsOK(res1)) {
28784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28785 }
28786 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28787 {
28788 PyThreadState* __tstate = wxPyBeginAllowThreads();
28789 result = ((wxTimeSpan const *)arg1)->GetSeconds();
28790 wxPyEndAllowThreads(__tstate);
28791 if (PyErr_Occurred()) SWIG_fail;
28792 }
28793 {
28794 PyObject *hi, *lo, *shifter, *shifted;
28795 hi = PyLong_FromLong( (&result)->GetHi() );
28796 lo = PyLong_FromLong( (&result)->GetLo() );
28797 shifter = PyLong_FromLong(32);
28798 shifted = PyNumber_Lshift(hi, shifter);
28799 resultobj = PyNumber_Or(shifted, lo);
28800 Py_DECREF(hi);
28801 Py_DECREF(lo);
28802 Py_DECREF(shifter);
28803 Py_DECREF(shifted);
28804 }
28805 return resultobj;
28806 fail:
28807 return NULL;
28808 }
28809
28810
28811 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(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_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28824 }
28825 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28826 {
28827 PyThreadState* __tstate = wxPyBeginAllowThreads();
28828 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
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_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28851 PyObject *resultobj = 0;
28852 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28853 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
28854 wxString *arg2 = (wxString *) &arg2_defvalue ;
28855 wxString result;
28856 void *argp1 = 0 ;
28857 int res1 = 0 ;
28858 bool temp2 = false ;
28859 PyObject * obj0 = 0 ;
28860 PyObject * obj1 = 0 ;
28861 char * kwnames[] = {
28862 (char *) "self",(char *) "format", NULL
28863 };
28864
28865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
28866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28867 if (!SWIG_IsOK(res1)) {
28868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28869 }
28870 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28871 if (obj1) {
28872 {
28873 arg2 = wxString_in_helper(obj1);
28874 if (arg2 == NULL) SWIG_fail;
28875 temp2 = true;
28876 }
28877 }
28878 {
28879 PyThreadState* __tstate = wxPyBeginAllowThreads();
28880 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
28881 wxPyEndAllowThreads(__tstate);
28882 if (PyErr_Occurred()) SWIG_fail;
28883 }
28884 {
28885 #if wxUSE_UNICODE
28886 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28887 #else
28888 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28889 #endif
28890 }
28891 {
28892 if (temp2)
28893 delete arg2;
28894 }
28895 return resultobj;
28896 fail:
28897 {
28898 if (temp2)
28899 delete arg2;
28900 }
28901 return NULL;
28902 }
28903
28904
28905 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28906 PyObject *obj;
28907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28908 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
28909 return SWIG_Py_Void();
28910 }
28911
28912 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28913 return SWIG_Python_InitShadowInstance(args);
28914 }
28915
28916 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28917 PyObject *resultobj = 0;
28918 int arg1 = (int) 0 ;
28919 int arg2 = (int) 0 ;
28920 int arg3 = (int) 0 ;
28921 int arg4 = (int) 0 ;
28922 wxDateSpan *result = 0 ;
28923 int val1 ;
28924 int ecode1 = 0 ;
28925 int val2 ;
28926 int ecode2 = 0 ;
28927 int val3 ;
28928 int ecode3 = 0 ;
28929 int val4 ;
28930 int ecode4 = 0 ;
28931 PyObject * obj0 = 0 ;
28932 PyObject * obj1 = 0 ;
28933 PyObject * obj2 = 0 ;
28934 PyObject * obj3 = 0 ;
28935 char * kwnames[] = {
28936 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
28937 };
28938
28939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28940 if (obj0) {
28941 ecode1 = SWIG_AsVal_int(obj0, &val1);
28942 if (!SWIG_IsOK(ecode1)) {
28943 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
28944 }
28945 arg1 = static_cast< int >(val1);
28946 }
28947 if (obj1) {
28948 ecode2 = SWIG_AsVal_int(obj1, &val2);
28949 if (!SWIG_IsOK(ecode2)) {
28950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
28951 }
28952 arg2 = static_cast< int >(val2);
28953 }
28954 if (obj2) {
28955 ecode3 = SWIG_AsVal_int(obj2, &val3);
28956 if (!SWIG_IsOK(ecode3)) {
28957 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
28958 }
28959 arg3 = static_cast< int >(val3);
28960 }
28961 if (obj3) {
28962 ecode4 = SWIG_AsVal_int(obj3, &val4);
28963 if (!SWIG_IsOK(ecode4)) {
28964 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
28965 }
28966 arg4 = static_cast< int >(val4);
28967 }
28968 {
28969 PyThreadState* __tstate = wxPyBeginAllowThreads();
28970 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
28971 wxPyEndAllowThreads(__tstate);
28972 if (PyErr_Occurred()) SWIG_fail;
28973 }
28974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
28975 return resultobj;
28976 fail:
28977 return NULL;
28978 }
28979
28980
28981 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28982 PyObject *resultobj = 0;
28983 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
28984 void *argp1 = 0 ;
28985 int res1 = 0 ;
28986 PyObject *swig_obj[1] ;
28987
28988 if (!args) SWIG_fail;
28989 swig_obj[0] = args;
28990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
28991 if (!SWIG_IsOK(res1)) {
28992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
28993 }
28994 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
28995 {
28996 PyThreadState* __tstate = wxPyBeginAllowThreads();
28997 delete arg1;
28998
28999 wxPyEndAllowThreads(__tstate);
29000 if (PyErr_Occurred()) SWIG_fail;
29001 }
29002 resultobj = SWIG_Py_Void();
29003 return resultobj;
29004 fail:
29005 return NULL;
29006 }
29007
29008
29009 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29010 PyObject *resultobj = 0;
29011 int arg1 ;
29012 wxDateSpan result;
29013 int val1 ;
29014 int ecode1 = 0 ;
29015 PyObject * obj0 = 0 ;
29016 char * kwnames[] = {
29017 (char *) "days", NULL
29018 };
29019
29020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
29021 ecode1 = SWIG_AsVal_int(obj0, &val1);
29022 if (!SWIG_IsOK(ecode1)) {
29023 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
29024 }
29025 arg1 = static_cast< int >(val1);
29026 {
29027 PyThreadState* __tstate = wxPyBeginAllowThreads();
29028 result = wxDateSpan::Days(arg1);
29029 wxPyEndAllowThreads(__tstate);
29030 if (PyErr_Occurred()) SWIG_fail;
29031 }
29032 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29033 return resultobj;
29034 fail:
29035 return NULL;
29036 }
29037
29038
29039 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29040 PyObject *resultobj = 0;
29041 wxDateSpan result;
29042
29043 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
29044 {
29045 PyThreadState* __tstate = wxPyBeginAllowThreads();
29046 result = wxDateSpan::Day();
29047 wxPyEndAllowThreads(__tstate);
29048 if (PyErr_Occurred()) SWIG_fail;
29049 }
29050 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29051 return resultobj;
29052 fail:
29053 return NULL;
29054 }
29055
29056
29057 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29058 PyObject *resultobj = 0;
29059 int arg1 ;
29060 wxDateSpan result;
29061 int val1 ;
29062 int ecode1 = 0 ;
29063 PyObject * obj0 = 0 ;
29064 char * kwnames[] = {
29065 (char *) "weeks", NULL
29066 };
29067
29068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
29069 ecode1 = SWIG_AsVal_int(obj0, &val1);
29070 if (!SWIG_IsOK(ecode1)) {
29071 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
29072 }
29073 arg1 = static_cast< int >(val1);
29074 {
29075 PyThreadState* __tstate = wxPyBeginAllowThreads();
29076 result = wxDateSpan::Weeks(arg1);
29077 wxPyEndAllowThreads(__tstate);
29078 if (PyErr_Occurred()) SWIG_fail;
29079 }
29080 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29081 return resultobj;
29082 fail:
29083 return NULL;
29084 }
29085
29086
29087 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29088 PyObject *resultobj = 0;
29089 wxDateSpan result;
29090
29091 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
29092 {
29093 PyThreadState* __tstate = wxPyBeginAllowThreads();
29094 result = wxDateSpan::Week();
29095 wxPyEndAllowThreads(__tstate);
29096 if (PyErr_Occurred()) SWIG_fail;
29097 }
29098 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29099 return resultobj;
29100 fail:
29101 return NULL;
29102 }
29103
29104
29105 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29106 PyObject *resultobj = 0;
29107 int arg1 ;
29108 wxDateSpan result;
29109 int val1 ;
29110 int ecode1 = 0 ;
29111 PyObject * obj0 = 0 ;
29112 char * kwnames[] = {
29113 (char *) "mon", NULL
29114 };
29115
29116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
29117 ecode1 = SWIG_AsVal_int(obj0, &val1);
29118 if (!SWIG_IsOK(ecode1)) {
29119 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
29120 }
29121 arg1 = static_cast< int >(val1);
29122 {
29123 PyThreadState* __tstate = wxPyBeginAllowThreads();
29124 result = wxDateSpan::Months(arg1);
29125 wxPyEndAllowThreads(__tstate);
29126 if (PyErr_Occurred()) SWIG_fail;
29127 }
29128 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29129 return resultobj;
29130 fail:
29131 return NULL;
29132 }
29133
29134
29135 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29136 PyObject *resultobj = 0;
29137 wxDateSpan result;
29138
29139 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
29140 {
29141 PyThreadState* __tstate = wxPyBeginAllowThreads();
29142 result = wxDateSpan::Month();
29143 wxPyEndAllowThreads(__tstate);
29144 if (PyErr_Occurred()) SWIG_fail;
29145 }
29146 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29147 return resultobj;
29148 fail:
29149 return NULL;
29150 }
29151
29152
29153 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29154 PyObject *resultobj = 0;
29155 int arg1 ;
29156 wxDateSpan result;
29157 int val1 ;
29158 int ecode1 = 0 ;
29159 PyObject * obj0 = 0 ;
29160 char * kwnames[] = {
29161 (char *) "years", NULL
29162 };
29163
29164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
29165 ecode1 = SWIG_AsVal_int(obj0, &val1);
29166 if (!SWIG_IsOK(ecode1)) {
29167 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
29168 }
29169 arg1 = static_cast< int >(val1);
29170 {
29171 PyThreadState* __tstate = wxPyBeginAllowThreads();
29172 result = wxDateSpan::Years(arg1);
29173 wxPyEndAllowThreads(__tstate);
29174 if (PyErr_Occurred()) SWIG_fail;
29175 }
29176 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29177 return resultobj;
29178 fail:
29179 return NULL;
29180 }
29181
29182
29183 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29184 PyObject *resultobj = 0;
29185 wxDateSpan result;
29186
29187 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
29188 {
29189 PyThreadState* __tstate = wxPyBeginAllowThreads();
29190 result = wxDateSpan::Year();
29191 wxPyEndAllowThreads(__tstate);
29192 if (PyErr_Occurred()) SWIG_fail;
29193 }
29194 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29195 return resultobj;
29196 fail:
29197 return NULL;
29198 }
29199
29200
29201 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29202 PyObject *resultobj = 0;
29203 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29204 int arg2 ;
29205 wxDateSpan *result = 0 ;
29206 void *argp1 = 0 ;
29207 int res1 = 0 ;
29208 int val2 ;
29209 int ecode2 = 0 ;
29210 PyObject * obj0 = 0 ;
29211 PyObject * obj1 = 0 ;
29212 char * kwnames[] = {
29213 (char *) "self",(char *) "n", NULL
29214 };
29215
29216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
29217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29218 if (!SWIG_IsOK(res1)) {
29219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29220 }
29221 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29222 ecode2 = SWIG_AsVal_int(obj1, &val2);
29223 if (!SWIG_IsOK(ecode2)) {
29224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
29225 }
29226 arg2 = static_cast< int >(val2);
29227 {
29228 PyThreadState* __tstate = wxPyBeginAllowThreads();
29229 {
29230 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
29231 result = (wxDateSpan *) &_result_ref;
29232 }
29233 wxPyEndAllowThreads(__tstate);
29234 if (PyErr_Occurred()) SWIG_fail;
29235 }
29236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29237 return resultobj;
29238 fail:
29239 return NULL;
29240 }
29241
29242
29243 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29244 PyObject *resultobj = 0;
29245 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29246 int arg2 ;
29247 wxDateSpan *result = 0 ;
29248 void *argp1 = 0 ;
29249 int res1 = 0 ;
29250 int val2 ;
29251 int ecode2 = 0 ;
29252 PyObject * obj0 = 0 ;
29253 PyObject * obj1 = 0 ;
29254 char * kwnames[] = {
29255 (char *) "self",(char *) "n", NULL
29256 };
29257
29258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
29259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29260 if (!SWIG_IsOK(res1)) {
29261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29262 }
29263 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29264 ecode2 = SWIG_AsVal_int(obj1, &val2);
29265 if (!SWIG_IsOK(ecode2)) {
29266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
29267 }
29268 arg2 = static_cast< int >(val2);
29269 {
29270 PyThreadState* __tstate = wxPyBeginAllowThreads();
29271 {
29272 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
29273 result = (wxDateSpan *) &_result_ref;
29274 }
29275 wxPyEndAllowThreads(__tstate);
29276 if (PyErr_Occurred()) SWIG_fail;
29277 }
29278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29279 return resultobj;
29280 fail:
29281 return NULL;
29282 }
29283
29284
29285 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29286 PyObject *resultobj = 0;
29287 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29288 int arg2 ;
29289 wxDateSpan *result = 0 ;
29290 void *argp1 = 0 ;
29291 int res1 = 0 ;
29292 int val2 ;
29293 int ecode2 = 0 ;
29294 PyObject * obj0 = 0 ;
29295 PyObject * obj1 = 0 ;
29296 char * kwnames[] = {
29297 (char *) "self",(char *) "n", NULL
29298 };
29299
29300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
29301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29302 if (!SWIG_IsOK(res1)) {
29303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29304 }
29305 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29306 ecode2 = SWIG_AsVal_int(obj1, &val2);
29307 if (!SWIG_IsOK(ecode2)) {
29308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
29309 }
29310 arg2 = static_cast< int >(val2);
29311 {
29312 PyThreadState* __tstate = wxPyBeginAllowThreads();
29313 {
29314 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
29315 result = (wxDateSpan *) &_result_ref;
29316 }
29317 wxPyEndAllowThreads(__tstate);
29318 if (PyErr_Occurred()) SWIG_fail;
29319 }
29320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29321 return resultobj;
29322 fail:
29323 return NULL;
29324 }
29325
29326
29327 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29328 PyObject *resultobj = 0;
29329 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29330 int arg2 ;
29331 wxDateSpan *result = 0 ;
29332 void *argp1 = 0 ;
29333 int res1 = 0 ;
29334 int val2 ;
29335 int ecode2 = 0 ;
29336 PyObject * obj0 = 0 ;
29337 PyObject * obj1 = 0 ;
29338 char * kwnames[] = {
29339 (char *) "self",(char *) "n", NULL
29340 };
29341
29342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
29343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29344 if (!SWIG_IsOK(res1)) {
29345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29346 }
29347 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29348 ecode2 = SWIG_AsVal_int(obj1, &val2);
29349 if (!SWIG_IsOK(ecode2)) {
29350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
29351 }
29352 arg2 = static_cast< int >(val2);
29353 {
29354 PyThreadState* __tstate = wxPyBeginAllowThreads();
29355 {
29356 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
29357 result = (wxDateSpan *) &_result_ref;
29358 }
29359 wxPyEndAllowThreads(__tstate);
29360 if (PyErr_Occurred()) SWIG_fail;
29361 }
29362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29363 return resultobj;
29364 fail:
29365 return NULL;
29366 }
29367
29368
29369 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29370 PyObject *resultobj = 0;
29371 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29372 int result;
29373 void *argp1 = 0 ;
29374 int res1 = 0 ;
29375 PyObject *swig_obj[1] ;
29376
29377 if (!args) SWIG_fail;
29378 swig_obj[0] = args;
29379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29380 if (!SWIG_IsOK(res1)) {
29381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29382 }
29383 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29384 {
29385 PyThreadState* __tstate = wxPyBeginAllowThreads();
29386 result = (int)((wxDateSpan const *)arg1)->GetYears();
29387 wxPyEndAllowThreads(__tstate);
29388 if (PyErr_Occurred()) SWIG_fail;
29389 }
29390 resultobj = SWIG_From_int(static_cast< int >(result));
29391 return resultobj;
29392 fail:
29393 return NULL;
29394 }
29395
29396
29397 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29398 PyObject *resultobj = 0;
29399 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29400 int result;
29401 void *argp1 = 0 ;
29402 int res1 = 0 ;
29403 PyObject *swig_obj[1] ;
29404
29405 if (!args) SWIG_fail;
29406 swig_obj[0] = args;
29407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29408 if (!SWIG_IsOK(res1)) {
29409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29410 }
29411 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29412 {
29413 PyThreadState* __tstate = wxPyBeginAllowThreads();
29414 result = (int)((wxDateSpan const *)arg1)->GetMonths();
29415 wxPyEndAllowThreads(__tstate);
29416 if (PyErr_Occurred()) SWIG_fail;
29417 }
29418 resultobj = SWIG_From_int(static_cast< int >(result));
29419 return resultobj;
29420 fail:
29421 return NULL;
29422 }
29423
29424
29425 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29426 PyObject *resultobj = 0;
29427 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29428 int result;
29429 void *argp1 = 0 ;
29430 int res1 = 0 ;
29431 PyObject *swig_obj[1] ;
29432
29433 if (!args) SWIG_fail;
29434 swig_obj[0] = args;
29435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29436 if (!SWIG_IsOK(res1)) {
29437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29438 }
29439 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29440 {
29441 PyThreadState* __tstate = wxPyBeginAllowThreads();
29442 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
29443 wxPyEndAllowThreads(__tstate);
29444 if (PyErr_Occurred()) SWIG_fail;
29445 }
29446 resultobj = SWIG_From_int(static_cast< int >(result));
29447 return resultobj;
29448 fail:
29449 return NULL;
29450 }
29451
29452
29453 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29454 PyObject *resultobj = 0;
29455 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29456 int result;
29457 void *argp1 = 0 ;
29458 int res1 = 0 ;
29459 PyObject *swig_obj[1] ;
29460
29461 if (!args) SWIG_fail;
29462 swig_obj[0] = args;
29463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29464 if (!SWIG_IsOK(res1)) {
29465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29466 }
29467 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29468 {
29469 PyThreadState* __tstate = wxPyBeginAllowThreads();
29470 result = (int)((wxDateSpan const *)arg1)->GetDays();
29471 wxPyEndAllowThreads(__tstate);
29472 if (PyErr_Occurred()) SWIG_fail;
29473 }
29474 resultobj = SWIG_From_int(static_cast< int >(result));
29475 return resultobj;
29476 fail:
29477 return NULL;
29478 }
29479
29480
29481 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29482 PyObject *resultobj = 0;
29483 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29484 int result;
29485 void *argp1 = 0 ;
29486 int res1 = 0 ;
29487 PyObject *swig_obj[1] ;
29488
29489 if (!args) SWIG_fail;
29490 swig_obj[0] = args;
29491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29492 if (!SWIG_IsOK(res1)) {
29493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29494 }
29495 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29496 {
29497 PyThreadState* __tstate = wxPyBeginAllowThreads();
29498 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
29499 wxPyEndAllowThreads(__tstate);
29500 if (PyErr_Occurred()) SWIG_fail;
29501 }
29502 resultobj = SWIG_From_int(static_cast< int >(result));
29503 return resultobj;
29504 fail:
29505 return NULL;
29506 }
29507
29508
29509 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29510 PyObject *resultobj = 0;
29511 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29512 wxDateSpan *arg2 = 0 ;
29513 wxDateSpan *result = 0 ;
29514 void *argp1 = 0 ;
29515 int res1 = 0 ;
29516 void *argp2 = 0 ;
29517 int res2 = 0 ;
29518 PyObject * obj0 = 0 ;
29519 PyObject * obj1 = 0 ;
29520 char * kwnames[] = {
29521 (char *) "self",(char *) "other", NULL
29522 };
29523
29524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29526 if (!SWIG_IsOK(res1)) {
29527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29528 }
29529 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29530 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29531 if (!SWIG_IsOK(res2)) {
29532 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29533 }
29534 if (!argp2) {
29535 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29536 }
29537 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29538 {
29539 PyThreadState* __tstate = wxPyBeginAllowThreads();
29540 {
29541 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
29542 result = (wxDateSpan *) &_result_ref;
29543 }
29544 wxPyEndAllowThreads(__tstate);
29545 if (PyErr_Occurred()) SWIG_fail;
29546 }
29547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29548 return resultobj;
29549 fail:
29550 return NULL;
29551 }
29552
29553
29554 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29555 PyObject *resultobj = 0;
29556 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29557 wxDateSpan *arg2 = 0 ;
29558 wxDateSpan *result = 0 ;
29559 void *argp1 = 0 ;
29560 int res1 = 0 ;
29561 void *argp2 = 0 ;
29562 int res2 = 0 ;
29563 PyObject * obj0 = 0 ;
29564 PyObject * obj1 = 0 ;
29565 char * kwnames[] = {
29566 (char *) "self",(char *) "other", NULL
29567 };
29568
29569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29571 if (!SWIG_IsOK(res1)) {
29572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29573 }
29574 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29575 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29576 if (!SWIG_IsOK(res2)) {
29577 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29578 }
29579 if (!argp2) {
29580 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29581 }
29582 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29583 {
29584 PyThreadState* __tstate = wxPyBeginAllowThreads();
29585 {
29586 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
29587 result = (wxDateSpan *) &_result_ref;
29588 }
29589 wxPyEndAllowThreads(__tstate);
29590 if (PyErr_Occurred()) SWIG_fail;
29591 }
29592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29593 return resultobj;
29594 fail:
29595 return NULL;
29596 }
29597
29598
29599 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29600 PyObject *resultobj = 0;
29601 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29602 wxDateSpan *result = 0 ;
29603 void *argp1 = 0 ;
29604 int res1 = 0 ;
29605 PyObject *swig_obj[1] ;
29606
29607 if (!args) SWIG_fail;
29608 swig_obj[0] = args;
29609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29610 if (!SWIG_IsOK(res1)) {
29611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29612 }
29613 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29614 {
29615 PyThreadState* __tstate = wxPyBeginAllowThreads();
29616 {
29617 wxDateSpan &_result_ref = (arg1)->Neg();
29618 result = (wxDateSpan *) &_result_ref;
29619 }
29620 wxPyEndAllowThreads(__tstate);
29621 if (PyErr_Occurred()) SWIG_fail;
29622 }
29623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29624 return resultobj;
29625 fail:
29626 return NULL;
29627 }
29628
29629
29630 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29631 PyObject *resultobj = 0;
29632 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29633 int arg2 ;
29634 wxDateSpan *result = 0 ;
29635 void *argp1 = 0 ;
29636 int res1 = 0 ;
29637 int val2 ;
29638 int ecode2 = 0 ;
29639 PyObject * obj0 = 0 ;
29640 PyObject * obj1 = 0 ;
29641 char * kwnames[] = {
29642 (char *) "self",(char *) "factor", NULL
29643 };
29644
29645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29647 if (!SWIG_IsOK(res1)) {
29648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29649 }
29650 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29651 ecode2 = SWIG_AsVal_int(obj1, &val2);
29652 if (!SWIG_IsOK(ecode2)) {
29653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29654 }
29655 arg2 = static_cast< int >(val2);
29656 {
29657 PyThreadState* __tstate = wxPyBeginAllowThreads();
29658 {
29659 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
29660 result = (wxDateSpan *) &_result_ref;
29661 }
29662 wxPyEndAllowThreads(__tstate);
29663 if (PyErr_Occurred()) SWIG_fail;
29664 }
29665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29666 return resultobj;
29667 fail:
29668 return NULL;
29669 }
29670
29671
29672 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29673 PyObject *resultobj = 0;
29674 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29675 wxDateSpan *arg2 = 0 ;
29676 wxDateSpan *result = 0 ;
29677 void *argp1 = 0 ;
29678 int res1 = 0 ;
29679 void *argp2 = 0 ;
29680 int res2 = 0 ;
29681 PyObject * obj0 = 0 ;
29682 PyObject * obj1 = 0 ;
29683 char * kwnames[] = {
29684 (char *) "self",(char *) "other", NULL
29685 };
29686
29687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29689 if (!SWIG_IsOK(res1)) {
29690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29691 }
29692 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29693 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29694 if (!SWIG_IsOK(res2)) {
29695 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29696 }
29697 if (!argp2) {
29698 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29699 }
29700 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29701 {
29702 PyThreadState* __tstate = wxPyBeginAllowThreads();
29703 {
29704 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
29705 result = (wxDateSpan *) &_result_ref;
29706 }
29707 wxPyEndAllowThreads(__tstate);
29708 if (PyErr_Occurred()) SWIG_fail;
29709 }
29710 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29711 return resultobj;
29712 fail:
29713 return NULL;
29714 }
29715
29716
29717 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29718 PyObject *resultobj = 0;
29719 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29720 wxDateSpan *arg2 = 0 ;
29721 wxDateSpan *result = 0 ;
29722 void *argp1 = 0 ;
29723 int res1 = 0 ;
29724 void *argp2 = 0 ;
29725 int res2 = 0 ;
29726 PyObject * obj0 = 0 ;
29727 PyObject * obj1 = 0 ;
29728 char * kwnames[] = {
29729 (char *) "self",(char *) "other", NULL
29730 };
29731
29732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29734 if (!SWIG_IsOK(res1)) {
29735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29736 }
29737 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29738 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29739 if (!SWIG_IsOK(res2)) {
29740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29741 }
29742 if (!argp2) {
29743 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29744 }
29745 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29746 {
29747 PyThreadState* __tstate = wxPyBeginAllowThreads();
29748 {
29749 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
29750 result = (wxDateSpan *) &_result_ref;
29751 }
29752 wxPyEndAllowThreads(__tstate);
29753 if (PyErr_Occurred()) SWIG_fail;
29754 }
29755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29756 return resultobj;
29757 fail:
29758 return NULL;
29759 }
29760
29761
29762 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29763 PyObject *resultobj = 0;
29764 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29765 wxDateSpan *result = 0 ;
29766 void *argp1 = 0 ;
29767 int res1 = 0 ;
29768 PyObject *swig_obj[1] ;
29769
29770 if (!args) SWIG_fail;
29771 swig_obj[0] = args;
29772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29773 if (!SWIG_IsOK(res1)) {
29774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29775 }
29776 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29777 {
29778 PyThreadState* __tstate = wxPyBeginAllowThreads();
29779 {
29780 wxDateSpan &_result_ref = (arg1)->operator -();
29781 result = (wxDateSpan *) &_result_ref;
29782 }
29783 wxPyEndAllowThreads(__tstate);
29784 if (PyErr_Occurred()) SWIG_fail;
29785 }
29786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29787 return resultobj;
29788 fail:
29789 return NULL;
29790 }
29791
29792
29793 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29794 PyObject *resultobj = 0;
29795 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29796 int arg2 ;
29797 wxDateSpan *result = 0 ;
29798 void *argp1 = 0 ;
29799 int res1 = 0 ;
29800 int val2 ;
29801 int ecode2 = 0 ;
29802 PyObject * obj0 = 0 ;
29803 PyObject * obj1 = 0 ;
29804 char * kwnames[] = {
29805 (char *) "self",(char *) "factor", NULL
29806 };
29807
29808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29810 if (!SWIG_IsOK(res1)) {
29811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29812 }
29813 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29814 ecode2 = SWIG_AsVal_int(obj1, &val2);
29815 if (!SWIG_IsOK(ecode2)) {
29816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29817 }
29818 arg2 = static_cast< int >(val2);
29819 {
29820 PyThreadState* __tstate = wxPyBeginAllowThreads();
29821 {
29822 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
29823 result = (wxDateSpan *) &_result_ref;
29824 }
29825 wxPyEndAllowThreads(__tstate);
29826 if (PyErr_Occurred()) SWIG_fail;
29827 }
29828 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29829 return resultobj;
29830 fail:
29831 return NULL;
29832 }
29833
29834
29835 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29836 PyObject *resultobj = 0;
29837 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29838 wxDateSpan *arg2 = 0 ;
29839 wxDateSpan result;
29840 void *argp1 = 0 ;
29841 int res1 = 0 ;
29842 void *argp2 = 0 ;
29843 int res2 = 0 ;
29844 PyObject * obj0 = 0 ;
29845 PyObject * obj1 = 0 ;
29846 char * kwnames[] = {
29847 (char *) "self",(char *) "other", NULL
29848 };
29849
29850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29852 if (!SWIG_IsOK(res1)) {
29853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29854 }
29855 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29856 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29857 if (!SWIG_IsOK(res2)) {
29858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29859 }
29860 if (!argp2) {
29861 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29862 }
29863 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29864 {
29865 PyThreadState* __tstate = wxPyBeginAllowThreads();
29866 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
29867 wxPyEndAllowThreads(__tstate);
29868 if (PyErr_Occurred()) SWIG_fail;
29869 }
29870 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29871 return resultobj;
29872 fail:
29873 return NULL;
29874 }
29875
29876
29877 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29878 PyObject *resultobj = 0;
29879 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29880 wxDateSpan *arg2 = 0 ;
29881 wxDateSpan result;
29882 void *argp1 = 0 ;
29883 int res1 = 0 ;
29884 void *argp2 = 0 ;
29885 int res2 = 0 ;
29886 PyObject * obj0 = 0 ;
29887 PyObject * obj1 = 0 ;
29888 char * kwnames[] = {
29889 (char *) "self",(char *) "other", NULL
29890 };
29891
29892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29894 if (!SWIG_IsOK(res1)) {
29895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29896 }
29897 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29898 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29899 if (!SWIG_IsOK(res2)) {
29900 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29901 }
29902 if (!argp2) {
29903 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29904 }
29905 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29906 {
29907 PyThreadState* __tstate = wxPyBeginAllowThreads();
29908 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
29909 wxPyEndAllowThreads(__tstate);
29910 if (PyErr_Occurred()) SWIG_fail;
29911 }
29912 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29913 return resultobj;
29914 fail:
29915 return NULL;
29916 }
29917
29918
29919 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29920 PyObject *resultobj = 0;
29921 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29922 int arg2 ;
29923 wxDateSpan result;
29924 void *argp1 = 0 ;
29925 int res1 = 0 ;
29926 int val2 ;
29927 int ecode2 = 0 ;
29928 PyObject * obj0 = 0 ;
29929 PyObject * obj1 = 0 ;
29930 char * kwnames[] = {
29931 (char *) "self",(char *) "n", NULL
29932 };
29933
29934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29936 if (!SWIG_IsOK(res1)) {
29937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29938 }
29939 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29940 ecode2 = SWIG_AsVal_int(obj1, &val2);
29941 if (!SWIG_IsOK(ecode2)) {
29942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29943 }
29944 arg2 = static_cast< int >(val2);
29945 {
29946 PyThreadState* __tstate = wxPyBeginAllowThreads();
29947 result = wxDateSpan___mul__(arg1,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___rmul__(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___rmul__",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___rmul__" "', 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___rmul__" "', expected argument " "2"" of type '" "int""'");
29982 }
29983 arg2 = static_cast< int >(val2);
29984 {
29985 PyThreadState* __tstate = wxPyBeginAllowThreads();
29986 result = wxDateSpan___rmul__(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___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29998 PyObject *resultobj = 0;
29999 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30000 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30001 bool result;
30002 void *argp1 = 0 ;
30003 int res1 = 0 ;
30004 void *argp2 = 0 ;
30005 int res2 = 0 ;
30006 PyObject * obj0 = 0 ;
30007 PyObject * obj1 = 0 ;
30008 char * kwnames[] = {
30009 (char *) "self",(char *) "other", NULL
30010 };
30011
30012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",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___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30016 }
30017 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30018 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30019 if (!SWIG_IsOK(res2)) {
30020 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30021 }
30022 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30023 {
30024 PyThreadState* __tstate = wxPyBeginAllowThreads();
30025 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
30026 wxPyEndAllowThreads(__tstate);
30027 if (PyErr_Occurred()) SWIG_fail;
30028 }
30029 {
30030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30031 }
30032 return resultobj;
30033 fail:
30034 return NULL;
30035 }
30036
30037
30038 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30039 PyObject *resultobj = 0;
30040 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30041 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30042 bool result;
30043 void *argp1 = 0 ;
30044 int res1 = 0 ;
30045 void *argp2 = 0 ;
30046 int res2 = 0 ;
30047 PyObject * obj0 = 0 ;
30048 PyObject * obj1 = 0 ;
30049 char * kwnames[] = {
30050 (char *) "self",(char *) "other", NULL
30051 };
30052
30053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
30054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30055 if (!SWIG_IsOK(res1)) {
30056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30057 }
30058 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30059 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30060 if (!SWIG_IsOK(res2)) {
30061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30062 }
30063 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30064 {
30065 PyThreadState* __tstate = wxPyBeginAllowThreads();
30066 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
30067 wxPyEndAllowThreads(__tstate);
30068 if (PyErr_Occurred()) SWIG_fail;
30069 }
30070 {
30071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30072 }
30073 return resultobj;
30074 fail:
30075 return NULL;
30076 }
30077
30078
30079 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30080 PyObject *obj;
30081 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30082 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
30083 return SWIG_Py_Void();
30084 }
30085
30086 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30087 return SWIG_Python_InitShadowInstance(args);
30088 }
30089
30090 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30091 PyObject *resultobj = 0;
30092 long result;
30093
30094 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
30095 {
30096 PyThreadState* __tstate = wxPyBeginAllowThreads();
30097 result = (long)wxGetLocalTime();
30098 wxPyEndAllowThreads(__tstate);
30099 if (PyErr_Occurred()) SWIG_fail;
30100 }
30101 resultobj = SWIG_From_long(static_cast< long >(result));
30102 return resultobj;
30103 fail:
30104 return NULL;
30105 }
30106
30107
30108 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30109 PyObject *resultobj = 0;
30110 long result;
30111
30112 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
30113 {
30114 PyThreadState* __tstate = wxPyBeginAllowThreads();
30115 result = (long)wxGetUTCTime();
30116 wxPyEndAllowThreads(__tstate);
30117 if (PyErr_Occurred()) SWIG_fail;
30118 }
30119 resultobj = SWIG_From_long(static_cast< long >(result));
30120 return resultobj;
30121 fail:
30122 return NULL;
30123 }
30124
30125
30126 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30127 PyObject *resultobj = 0;
30128 long result;
30129
30130 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
30131 {
30132 PyThreadState* __tstate = wxPyBeginAllowThreads();
30133 result = (long)wxGetCurrentTime();
30134 wxPyEndAllowThreads(__tstate);
30135 if (PyErr_Occurred()) SWIG_fail;
30136 }
30137 resultobj = SWIG_From_long(static_cast< long >(result));
30138 return resultobj;
30139 fail:
30140 return NULL;
30141 }
30142
30143
30144 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30145 PyObject *resultobj = 0;
30146 wxLongLong result;
30147
30148 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
30149 {
30150 PyThreadState* __tstate = wxPyBeginAllowThreads();
30151 result = wxGetLocalTimeMillis();
30152 wxPyEndAllowThreads(__tstate);
30153 if (PyErr_Occurred()) SWIG_fail;
30154 }
30155 {
30156 PyObject *hi, *lo, *shifter, *shifted;
30157 hi = PyLong_FromLong( (&result)->GetHi() );
30158 lo = PyLong_FromLong( (&result)->GetLo() );
30159 shifter = PyLong_FromLong(32);
30160 shifted = PyNumber_Lshift(hi, shifter);
30161 resultobj = PyNumber_Or(shifted, lo);
30162 Py_DECREF(hi);
30163 Py_DECREF(lo);
30164 Py_DECREF(shifter);
30165 Py_DECREF(shifted);
30166 }
30167 return resultobj;
30168 fail:
30169 return NULL;
30170 }
30171
30172
30173 SWIGINTERN int DefaultDateTime_set(PyObject *) {
30174 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
30175 return 1;
30176 }
30177
30178
30179 SWIGINTERN PyObject *DefaultDateTime_get(void) {
30180 PyObject *pyobj = 0;
30181
30182 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
30183 return pyobj;
30184 }
30185
30186
30187 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30188 PyObject *resultobj = 0;
30189 wxDataFormatId arg1 ;
30190 wxDataFormat *result = 0 ;
30191 int val1 ;
30192 int ecode1 = 0 ;
30193 PyObject * obj0 = 0 ;
30194 char * kwnames[] = {
30195 (char *) "type", NULL
30196 };
30197
30198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
30199 ecode1 = SWIG_AsVal_int(obj0, &val1);
30200 if (!SWIG_IsOK(ecode1)) {
30201 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
30202 }
30203 arg1 = static_cast< wxDataFormatId >(val1);
30204 {
30205 PyThreadState* __tstate = wxPyBeginAllowThreads();
30206 result = (wxDataFormat *)new wxDataFormat(arg1);
30207 wxPyEndAllowThreads(__tstate);
30208 if (PyErr_Occurred()) SWIG_fail;
30209 }
30210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
30211 return resultobj;
30212 fail:
30213 return NULL;
30214 }
30215
30216
30217 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30218 PyObject *resultobj = 0;
30219 wxString *arg1 = 0 ;
30220 wxDataFormat *result = 0 ;
30221 bool temp1 = false ;
30222 PyObject * obj0 = 0 ;
30223 char * kwnames[] = {
30224 (char *) "format", NULL
30225 };
30226
30227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
30228 {
30229 arg1 = wxString_in_helper(obj0);
30230 if (arg1 == NULL) SWIG_fail;
30231 temp1 = true;
30232 }
30233 {
30234 PyThreadState* __tstate = wxPyBeginAllowThreads();
30235 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
30236 wxPyEndAllowThreads(__tstate);
30237 if (PyErr_Occurred()) SWIG_fail;
30238 }
30239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30240 {
30241 if (temp1)
30242 delete arg1;
30243 }
30244 return resultobj;
30245 fail:
30246 {
30247 if (temp1)
30248 delete arg1;
30249 }
30250 return NULL;
30251 }
30252
30253
30254 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30255 PyObject *resultobj = 0;
30256 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30257 void *argp1 = 0 ;
30258 int res1 = 0 ;
30259 PyObject *swig_obj[1] ;
30260
30261 if (!args) SWIG_fail;
30262 swig_obj[0] = args;
30263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
30264 if (!SWIG_IsOK(res1)) {
30265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30266 }
30267 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30268 {
30269 PyThreadState* __tstate = wxPyBeginAllowThreads();
30270 delete arg1;
30271
30272 wxPyEndAllowThreads(__tstate);
30273 if (PyErr_Occurred()) SWIG_fail;
30274 }
30275 resultobj = SWIG_Py_Void();
30276 return resultobj;
30277 fail:
30278 return NULL;
30279 }
30280
30281
30282 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30283 PyObject *resultobj = 0;
30284 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30285 wxDataFormatId arg2 ;
30286 bool result;
30287 void *argp1 = 0 ;
30288 int res1 = 0 ;
30289 int val2 ;
30290 int ecode2 = 0 ;
30291
30292 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30294 if (!SWIG_IsOK(res1)) {
30295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30296 }
30297 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30298 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30299 if (!SWIG_IsOK(ecode2)) {
30300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30301 }
30302 arg2 = static_cast< wxDataFormatId >(val2);
30303 {
30304 PyThreadState* __tstate = wxPyBeginAllowThreads();
30305 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
30306 wxPyEndAllowThreads(__tstate);
30307 if (PyErr_Occurred()) SWIG_fail;
30308 }
30309 {
30310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30311 }
30312 return resultobj;
30313 fail:
30314 return NULL;
30315 }
30316
30317
30318 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30319 PyObject *resultobj = 0;
30320 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30321 wxDataFormatId arg2 ;
30322 bool result;
30323 void *argp1 = 0 ;
30324 int res1 = 0 ;
30325 int val2 ;
30326 int ecode2 = 0 ;
30327
30328 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30330 if (!SWIG_IsOK(res1)) {
30331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30332 }
30333 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30334 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30335 if (!SWIG_IsOK(ecode2)) {
30336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30337 }
30338 arg2 = static_cast< wxDataFormatId >(val2);
30339 {
30340 PyThreadState* __tstate = wxPyBeginAllowThreads();
30341 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
30342 wxPyEndAllowThreads(__tstate);
30343 if (PyErr_Occurred()) SWIG_fail;
30344 }
30345 {
30346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30347 }
30348 return resultobj;
30349 fail:
30350 return NULL;
30351 }
30352
30353
30354 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30355 PyObject *resultobj = 0;
30356 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30357 wxDataFormat *arg2 = 0 ;
30358 bool result;
30359 void *argp1 = 0 ;
30360 int res1 = 0 ;
30361 void *argp2 = 0 ;
30362 int res2 = 0 ;
30363
30364 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30366 if (!SWIG_IsOK(res1)) {
30367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30368 }
30369 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30370 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30371 if (!SWIG_IsOK(res2)) {
30372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30373 }
30374 if (!argp2) {
30375 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30376 }
30377 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30378 {
30379 PyThreadState* __tstate = wxPyBeginAllowThreads();
30380 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*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__(PyObject *self, PyObject *args) {
30394 int argc;
30395 PyObject *argv[3];
30396
30397 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
30398 --argc;
30399 if (argc == 2) {
30400 int _v = 0;
30401 {
30402 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30403 _v = SWIG_CheckState(res);
30404 }
30405 if (!_v) goto check_1;
30406 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
30407 }
30408 check_1:
30409
30410 if (argc == 2) {
30411 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
30412 }
30413
30414 fail:
30415 Py_INCREF(Py_NotImplemented);
30416 return Py_NotImplemented;
30417 }
30418
30419
30420 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30421 PyObject *resultobj = 0;
30422 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30423 wxDataFormat *arg2 = 0 ;
30424 bool result;
30425 void *argp1 = 0 ;
30426 int res1 = 0 ;
30427 void *argp2 = 0 ;
30428 int res2 = 0 ;
30429
30430 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30432 if (!SWIG_IsOK(res1)) {
30433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30434 }
30435 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30436 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30437 if (!SWIG_IsOK(res2)) {
30438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30439 }
30440 if (!argp2) {
30441 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30442 }
30443 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30444 {
30445 PyThreadState* __tstate = wxPyBeginAllowThreads();
30446 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
30447 wxPyEndAllowThreads(__tstate);
30448 if (PyErr_Occurred()) SWIG_fail;
30449 }
30450 {
30451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30452 }
30453 return resultobj;
30454 fail:
30455 return NULL;
30456 }
30457
30458
30459 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
30460 int argc;
30461 PyObject *argv[3];
30462
30463 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
30464 --argc;
30465 if (argc == 2) {
30466 int _v = 0;
30467 {
30468 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30469 _v = SWIG_CheckState(res);
30470 }
30471 if (!_v) goto check_1;
30472 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
30473 }
30474 check_1:
30475
30476 if (argc == 2) {
30477 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
30478 }
30479
30480 fail:
30481 Py_INCREF(Py_NotImplemented);
30482 return Py_NotImplemented;
30483 }
30484
30485
30486 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30487 PyObject *resultobj = 0;
30488 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30489 wxDataFormatId arg2 ;
30490 void *argp1 = 0 ;
30491 int res1 = 0 ;
30492 int val2 ;
30493 int ecode2 = 0 ;
30494 PyObject * obj0 = 0 ;
30495 PyObject * obj1 = 0 ;
30496 char * kwnames[] = {
30497 (char *) "self",(char *) "format", NULL
30498 };
30499
30500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
30501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30502 if (!SWIG_IsOK(res1)) {
30503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30504 }
30505 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30506 ecode2 = SWIG_AsVal_int(obj1, &val2);
30507 if (!SWIG_IsOK(ecode2)) {
30508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30509 }
30510 arg2 = static_cast< wxDataFormatId >(val2);
30511 {
30512 PyThreadState* __tstate = wxPyBeginAllowThreads();
30513 (arg1)->SetType(arg2);
30514 wxPyEndAllowThreads(__tstate);
30515 if (PyErr_Occurred()) SWIG_fail;
30516 }
30517 resultobj = SWIG_Py_Void();
30518 return resultobj;
30519 fail:
30520 return NULL;
30521 }
30522
30523
30524 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30525 PyObject *resultobj = 0;
30526 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30527 wxDataFormatId result;
30528 void *argp1 = 0 ;
30529 int res1 = 0 ;
30530 PyObject *swig_obj[1] ;
30531
30532 if (!args) SWIG_fail;
30533 swig_obj[0] = args;
30534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30535 if (!SWIG_IsOK(res1)) {
30536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30537 }
30538 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30539 {
30540 PyThreadState* __tstate = wxPyBeginAllowThreads();
30541 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
30542 wxPyEndAllowThreads(__tstate);
30543 if (PyErr_Occurred()) SWIG_fail;
30544 }
30545 resultobj = SWIG_From_int(static_cast< int >(result));
30546 return resultobj;
30547 fail:
30548 return NULL;
30549 }
30550
30551
30552 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30553 PyObject *resultobj = 0;
30554 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30555 wxString result;
30556 void *argp1 = 0 ;
30557 int res1 = 0 ;
30558 PyObject *swig_obj[1] ;
30559
30560 if (!args) SWIG_fail;
30561 swig_obj[0] = args;
30562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30563 if (!SWIG_IsOK(res1)) {
30564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30565 }
30566 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30567 {
30568 PyThreadState* __tstate = wxPyBeginAllowThreads();
30569 result = ((wxDataFormat const *)arg1)->GetId();
30570 wxPyEndAllowThreads(__tstate);
30571 if (PyErr_Occurred()) SWIG_fail;
30572 }
30573 {
30574 #if wxUSE_UNICODE
30575 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30576 #else
30577 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30578 #endif
30579 }
30580 return resultobj;
30581 fail:
30582 return NULL;
30583 }
30584
30585
30586 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30587 PyObject *resultobj = 0;
30588 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30589 wxString *arg2 = 0 ;
30590 void *argp1 = 0 ;
30591 int res1 = 0 ;
30592 bool temp2 = false ;
30593 PyObject * obj0 = 0 ;
30594 PyObject * obj1 = 0 ;
30595 char * kwnames[] = {
30596 (char *) "self",(char *) "format", NULL
30597 };
30598
30599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30601 if (!SWIG_IsOK(res1)) {
30602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30603 }
30604 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30605 {
30606 arg2 = wxString_in_helper(obj1);
30607 if (arg2 == NULL) SWIG_fail;
30608 temp2 = true;
30609 }
30610 {
30611 PyThreadState* __tstate = wxPyBeginAllowThreads();
30612 (arg1)->SetId((wxString const &)*arg2);
30613 wxPyEndAllowThreads(__tstate);
30614 if (PyErr_Occurred()) SWIG_fail;
30615 }
30616 resultobj = SWIG_Py_Void();
30617 {
30618 if (temp2)
30619 delete arg2;
30620 }
30621 return resultobj;
30622 fail:
30623 {
30624 if (temp2)
30625 delete arg2;
30626 }
30627 return NULL;
30628 }
30629
30630
30631 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30632 PyObject *obj;
30633 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30634 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
30635 return SWIG_Py_Void();
30636 }
30637
30638 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30639 return SWIG_Python_InitShadowInstance(args);
30640 }
30641
30642 SWIGINTERN int FormatInvalid_set(PyObject *) {
30643 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
30644 return 1;
30645 }
30646
30647
30648 SWIGINTERN PyObject *FormatInvalid_get(void) {
30649 PyObject *pyobj = 0;
30650
30651 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
30652 return pyobj;
30653 }
30654
30655
30656 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30657 PyObject *resultobj = 0;
30658 wxDataObject *arg1 = (wxDataObject *) 0 ;
30659 void *argp1 = 0 ;
30660 int res1 = 0 ;
30661 PyObject *swig_obj[1] ;
30662
30663 if (!args) SWIG_fail;
30664 swig_obj[0] = args;
30665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
30666 if (!SWIG_IsOK(res1)) {
30667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
30668 }
30669 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30670 {
30671 PyThreadState* __tstate = wxPyBeginAllowThreads();
30672 delete arg1;
30673
30674 wxPyEndAllowThreads(__tstate);
30675 if (PyErr_Occurred()) SWIG_fail;
30676 }
30677 resultobj = SWIG_Py_Void();
30678 return resultobj;
30679 fail:
30680 return NULL;
30681 }
30682
30683
30684 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30685 PyObject *resultobj = 0;
30686 wxDataObject *arg1 = (wxDataObject *) 0 ;
30687 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30688 SwigValueWrapper<wxDataFormat > result;
30689 void *argp1 = 0 ;
30690 int res1 = 0 ;
30691 int val2 ;
30692 int ecode2 = 0 ;
30693 PyObject * obj0 = 0 ;
30694 PyObject * obj1 = 0 ;
30695 char * kwnames[] = {
30696 (char *) "self",(char *) "dir", NULL
30697 };
30698
30699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
30700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30701 if (!SWIG_IsOK(res1)) {
30702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30703 }
30704 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30705 if (obj1) {
30706 ecode2 = SWIG_AsVal_int(obj1, &val2);
30707 if (!SWIG_IsOK(ecode2)) {
30708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30709 }
30710 arg2 = static_cast< wxDataObject::Direction >(val2);
30711 }
30712 {
30713 PyThreadState* __tstate = wxPyBeginAllowThreads();
30714 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
30715 wxPyEndAllowThreads(__tstate);
30716 if (PyErr_Occurred()) SWIG_fail;
30717 }
30718 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30719 return resultobj;
30720 fail:
30721 return NULL;
30722 }
30723
30724
30725 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30726 PyObject *resultobj = 0;
30727 wxDataObject *arg1 = (wxDataObject *) 0 ;
30728 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30729 size_t result;
30730 void *argp1 = 0 ;
30731 int res1 = 0 ;
30732 int val2 ;
30733 int ecode2 = 0 ;
30734 PyObject * obj0 = 0 ;
30735 PyObject * obj1 = 0 ;
30736 char * kwnames[] = {
30737 (char *) "self",(char *) "dir", NULL
30738 };
30739
30740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
30741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30742 if (!SWIG_IsOK(res1)) {
30743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30744 }
30745 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30746 if (obj1) {
30747 ecode2 = SWIG_AsVal_int(obj1, &val2);
30748 if (!SWIG_IsOK(ecode2)) {
30749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30750 }
30751 arg2 = static_cast< wxDataObject::Direction >(val2);
30752 }
30753 {
30754 PyThreadState* __tstate = wxPyBeginAllowThreads();
30755 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
30756 wxPyEndAllowThreads(__tstate);
30757 if (PyErr_Occurred()) SWIG_fail;
30758 }
30759 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30760 return resultobj;
30761 fail:
30762 return NULL;
30763 }
30764
30765
30766 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30767 PyObject *resultobj = 0;
30768 wxDataObject *arg1 = (wxDataObject *) 0 ;
30769 wxDataFormat *arg2 = 0 ;
30770 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
30771 bool result;
30772 void *argp1 = 0 ;
30773 int res1 = 0 ;
30774 void *argp2 = 0 ;
30775 int res2 = 0 ;
30776 int val3 ;
30777 int ecode3 = 0 ;
30778 PyObject * obj0 = 0 ;
30779 PyObject * obj1 = 0 ;
30780 PyObject * obj2 = 0 ;
30781 char * kwnames[] = {
30782 (char *) "self",(char *) "format",(char *) "dir", NULL
30783 };
30784
30785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30787 if (!SWIG_IsOK(res1)) {
30788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30789 }
30790 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30791 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30792 if (!SWIG_IsOK(res2)) {
30793 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30794 }
30795 if (!argp2) {
30796 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30797 }
30798 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30799 if (obj2) {
30800 ecode3 = SWIG_AsVal_int(obj2, &val3);
30801 if (!SWIG_IsOK(ecode3)) {
30802 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
30803 }
30804 arg3 = static_cast< wxDataObject::Direction >(val3);
30805 }
30806 {
30807 PyThreadState* __tstate = wxPyBeginAllowThreads();
30808 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
30809 wxPyEndAllowThreads(__tstate);
30810 if (PyErr_Occurred()) SWIG_fail;
30811 }
30812 {
30813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30814 }
30815 return resultobj;
30816 fail:
30817 return NULL;
30818 }
30819
30820
30821 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30822 PyObject *resultobj = 0;
30823 wxDataObject *arg1 = (wxDataObject *) 0 ;
30824 wxDataFormat *arg2 = 0 ;
30825 size_t result;
30826 void *argp1 = 0 ;
30827 int res1 = 0 ;
30828 void *argp2 = 0 ;
30829 int res2 = 0 ;
30830 PyObject * obj0 = 0 ;
30831 PyObject * obj1 = 0 ;
30832 char * kwnames[] = {
30833 (char *) "self",(char *) "format", NULL
30834 };
30835
30836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
30837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30838 if (!SWIG_IsOK(res1)) {
30839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30840 }
30841 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30842 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30843 if (!SWIG_IsOK(res2)) {
30844 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30845 }
30846 if (!argp2) {
30847 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30848 }
30849 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30850 {
30851 PyThreadState* __tstate = wxPyBeginAllowThreads();
30852 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
30853 wxPyEndAllowThreads(__tstate);
30854 if (PyErr_Occurred()) SWIG_fail;
30855 }
30856 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30857 return resultobj;
30858 fail:
30859 return NULL;
30860 }
30861
30862
30863 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30864 PyObject *resultobj = 0;
30865 wxDataObject *arg1 = (wxDataObject *) 0 ;
30866 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30867 PyObject *result = 0 ;
30868 void *argp1 = 0 ;
30869 int res1 = 0 ;
30870 int val2 ;
30871 int ecode2 = 0 ;
30872 PyObject * obj0 = 0 ;
30873 PyObject * obj1 = 0 ;
30874 char * kwnames[] = {
30875 (char *) "self",(char *) "dir", NULL
30876 };
30877
30878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
30879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30880 if (!SWIG_IsOK(res1)) {
30881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
30882 }
30883 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30884 if (obj1) {
30885 ecode2 = SWIG_AsVal_int(obj1, &val2);
30886 if (!SWIG_IsOK(ecode2)) {
30887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30888 }
30889 arg2 = static_cast< wxDataObject::Direction >(val2);
30890 }
30891 {
30892 PyThreadState* __tstate = wxPyBeginAllowThreads();
30893 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
30894 wxPyEndAllowThreads(__tstate);
30895 if (PyErr_Occurred()) SWIG_fail;
30896 }
30897 resultobj = result;
30898 return resultobj;
30899 fail:
30900 return NULL;
30901 }
30902
30903
30904 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30905 PyObject *resultobj = 0;
30906 wxDataObject *arg1 = (wxDataObject *) 0 ;
30907 wxDataFormat *arg2 = 0 ;
30908 PyObject *result = 0 ;
30909 void *argp1 = 0 ;
30910 int res1 = 0 ;
30911 void *argp2 = 0 ;
30912 int res2 = 0 ;
30913 PyObject * obj0 = 0 ;
30914 PyObject * obj1 = 0 ;
30915 char * kwnames[] = {
30916 (char *) "self",(char *) "format", NULL
30917 };
30918
30919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
30920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30921 if (!SWIG_IsOK(res1)) {
30922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
30923 }
30924 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30925 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30926 if (!SWIG_IsOK(res2)) {
30927 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30928 }
30929 if (!argp2) {
30930 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30931 }
30932 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30933 {
30934 PyThreadState* __tstate = wxPyBeginAllowThreads();
30935 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
30936 wxPyEndAllowThreads(__tstate);
30937 if (PyErr_Occurred()) SWIG_fail;
30938 }
30939 resultobj = result;
30940 return resultobj;
30941 fail:
30942 return NULL;
30943 }
30944
30945
30946 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30947 PyObject *resultobj = 0;
30948 wxDataObject *arg1 = (wxDataObject *) 0 ;
30949 wxDataFormat *arg2 = 0 ;
30950 PyObject *arg3 = (PyObject *) 0 ;
30951 bool result;
30952 void *argp1 = 0 ;
30953 int res1 = 0 ;
30954 void *argp2 = 0 ;
30955 int res2 = 0 ;
30956 PyObject * obj0 = 0 ;
30957 PyObject * obj1 = 0 ;
30958 PyObject * obj2 = 0 ;
30959 char * kwnames[] = {
30960 (char *) "self",(char *) "format",(char *) "data", NULL
30961 };
30962
30963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30965 if (!SWIG_IsOK(res1)) {
30966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
30967 }
30968 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30969 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30970 if (!SWIG_IsOK(res2)) {
30971 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30972 }
30973 if (!argp2) {
30974 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30975 }
30976 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30977 arg3 = obj2;
30978 {
30979 PyThreadState* __tstate = wxPyBeginAllowThreads();
30980 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
30981 wxPyEndAllowThreads(__tstate);
30982 if (PyErr_Occurred()) SWIG_fail;
30983 }
30984 {
30985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30986 }
30987 return resultobj;
30988 fail:
30989 return NULL;
30990 }
30991
30992
30993 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30994 PyObject *obj;
30995 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30996 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
30997 return SWIG_Py_Void();
30998 }
30999
31000 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31001 PyObject *resultobj = 0;
31002 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31003 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31004 wxDataObjectSimple *result = 0 ;
31005 void *argp1 = 0 ;
31006 int res1 = 0 ;
31007 PyObject * obj0 = 0 ;
31008 char * kwnames[] = {
31009 (char *) "format", NULL
31010 };
31011
31012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
31013 if (obj0) {
31014 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31015 if (!SWIG_IsOK(res1)) {
31016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31017 }
31018 if (!argp1) {
31019 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31020 }
31021 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31022 }
31023 {
31024 PyThreadState* __tstate = wxPyBeginAllowThreads();
31025 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
31026 wxPyEndAllowThreads(__tstate);
31027 if (PyErr_Occurred()) SWIG_fail;
31028 }
31029 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
31030 return resultobj;
31031 fail:
31032 return NULL;
31033 }
31034
31035
31036 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31037 PyObject *resultobj = 0;
31038 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31039 wxDataFormat *result = 0 ;
31040 void *argp1 = 0 ;
31041 int res1 = 0 ;
31042 PyObject *swig_obj[1] ;
31043
31044 if (!args) SWIG_fail;
31045 swig_obj[0] = args;
31046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31047 if (!SWIG_IsOK(res1)) {
31048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31049 }
31050 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31051 {
31052 PyThreadState* __tstate = wxPyBeginAllowThreads();
31053 {
31054 wxDataFormat const &_result_ref = (arg1)->GetFormat();
31055 result = (wxDataFormat *) &_result_ref;
31056 }
31057 wxPyEndAllowThreads(__tstate);
31058 if (PyErr_Occurred()) SWIG_fail;
31059 }
31060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
31061 return resultobj;
31062 fail:
31063 return NULL;
31064 }
31065
31066
31067 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31068 PyObject *resultobj = 0;
31069 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31070 wxDataFormat *arg2 = 0 ;
31071 void *argp1 = 0 ;
31072 int res1 = 0 ;
31073 void *argp2 = 0 ;
31074 int res2 = 0 ;
31075 PyObject * obj0 = 0 ;
31076 PyObject * obj1 = 0 ;
31077 char * kwnames[] = {
31078 (char *) "self",(char *) "format", NULL
31079 };
31080
31081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31083 if (!SWIG_IsOK(res1)) {
31084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31085 }
31086 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31087 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31088 if (!SWIG_IsOK(res2)) {
31089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31090 }
31091 if (!argp2) {
31092 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31093 }
31094 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31095 {
31096 PyThreadState* __tstate = wxPyBeginAllowThreads();
31097 (arg1)->SetFormat((wxDataFormat const &)*arg2);
31098 wxPyEndAllowThreads(__tstate);
31099 if (PyErr_Occurred()) SWIG_fail;
31100 }
31101 resultobj = SWIG_Py_Void();
31102 return resultobj;
31103 fail:
31104 return NULL;
31105 }
31106
31107
31108 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31109 PyObject *resultobj = 0;
31110 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31111 size_t result;
31112 void *argp1 = 0 ;
31113 int res1 = 0 ;
31114 PyObject *swig_obj[1] ;
31115
31116 if (!args) SWIG_fail;
31117 swig_obj[0] = args;
31118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31119 if (!SWIG_IsOK(res1)) {
31120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
31121 }
31122 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31123 {
31124 PyThreadState* __tstate = wxPyBeginAllowThreads();
31125 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
31126 wxPyEndAllowThreads(__tstate);
31127 if (PyErr_Occurred()) SWIG_fail;
31128 }
31129 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31130 return resultobj;
31131 fail:
31132 return NULL;
31133 }
31134
31135
31136 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31137 PyObject *resultobj = 0;
31138 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31139 PyObject *result = 0 ;
31140 void *argp1 = 0 ;
31141 int res1 = 0 ;
31142 PyObject *swig_obj[1] ;
31143
31144 if (!args) SWIG_fail;
31145 swig_obj[0] = args;
31146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31147 if (!SWIG_IsOK(res1)) {
31148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31149 }
31150 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31151 {
31152 PyThreadState* __tstate = wxPyBeginAllowThreads();
31153 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
31154 wxPyEndAllowThreads(__tstate);
31155 if (PyErr_Occurred()) SWIG_fail;
31156 }
31157 resultobj = result;
31158 return resultobj;
31159 fail:
31160 return NULL;
31161 }
31162
31163
31164 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31165 PyObject *resultobj = 0;
31166 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31167 PyObject *arg2 = (PyObject *) 0 ;
31168 bool result;
31169 void *argp1 = 0 ;
31170 int res1 = 0 ;
31171 PyObject * obj0 = 0 ;
31172 PyObject * obj1 = 0 ;
31173 char * kwnames[] = {
31174 (char *) "self",(char *) "data", NULL
31175 };
31176
31177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31179 if (!SWIG_IsOK(res1)) {
31180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31181 }
31182 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31183 arg2 = obj1;
31184 {
31185 PyThreadState* __tstate = wxPyBeginAllowThreads();
31186 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
31187 wxPyEndAllowThreads(__tstate);
31188 if (PyErr_Occurred()) SWIG_fail;
31189 }
31190 {
31191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31192 }
31193 return resultobj;
31194 fail:
31195 return NULL;
31196 }
31197
31198
31199 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31200 PyObject *obj;
31201 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31202 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
31203 return SWIG_Py_Void();
31204 }
31205
31206 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31207 return SWIG_Python_InitShadowInstance(args);
31208 }
31209
31210 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31211 PyObject *resultobj = 0;
31212 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31213 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31214 wxPyDataObjectSimple *result = 0 ;
31215 void *argp1 = 0 ;
31216 int res1 = 0 ;
31217 PyObject * obj0 = 0 ;
31218 char * kwnames[] = {
31219 (char *) "format", NULL
31220 };
31221
31222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
31223 if (obj0) {
31224 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31225 if (!SWIG_IsOK(res1)) {
31226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31227 }
31228 if (!argp1) {
31229 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31230 }
31231 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31232 }
31233 {
31234 PyThreadState* __tstate = wxPyBeginAllowThreads();
31235 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
31236 wxPyEndAllowThreads(__tstate);
31237 if (PyErr_Occurred()) SWIG_fail;
31238 }
31239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
31240 return resultobj;
31241 fail:
31242 return NULL;
31243 }
31244
31245
31246 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31247 PyObject *resultobj = 0;
31248 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
31249 PyObject *arg2 = (PyObject *) 0 ;
31250 PyObject *arg3 = (PyObject *) 0 ;
31251 void *argp1 = 0 ;
31252 int res1 = 0 ;
31253 PyObject * obj0 = 0 ;
31254 PyObject * obj1 = 0 ;
31255 PyObject * obj2 = 0 ;
31256 char * kwnames[] = {
31257 (char *) "self",(char *) "self",(char *) "_class", NULL
31258 };
31259
31260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
31262 if (!SWIG_IsOK(res1)) {
31263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
31264 }
31265 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
31266 arg2 = obj1;
31267 arg3 = obj2;
31268 {
31269 PyThreadState* __tstate = wxPyBeginAllowThreads();
31270 (arg1)->_setCallbackInfo(arg2,arg3);
31271 wxPyEndAllowThreads(__tstate);
31272 if (PyErr_Occurred()) SWIG_fail;
31273 }
31274 resultobj = SWIG_Py_Void();
31275 return resultobj;
31276 fail:
31277 return NULL;
31278 }
31279
31280
31281 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31282 PyObject *obj;
31283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31284 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
31285 return SWIG_Py_Void();
31286 }
31287
31288 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31289 return SWIG_Python_InitShadowInstance(args);
31290 }
31291
31292 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31293 PyObject *resultobj = 0;
31294 wxDataObjectComposite *result = 0 ;
31295
31296 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
31297 {
31298 PyThreadState* __tstate = wxPyBeginAllowThreads();
31299 result = (wxDataObjectComposite *)new wxDataObjectComposite();
31300 wxPyEndAllowThreads(__tstate);
31301 if (PyErr_Occurred()) SWIG_fail;
31302 }
31303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
31304 return resultobj;
31305 fail:
31306 return NULL;
31307 }
31308
31309
31310 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31311 PyObject *resultobj = 0;
31312 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31313 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
31314 bool arg3 = (bool) false ;
31315 void *argp1 = 0 ;
31316 int res1 = 0 ;
31317 int res2 = 0 ;
31318 bool val3 ;
31319 int ecode3 = 0 ;
31320 PyObject * obj0 = 0 ;
31321 PyObject * obj1 = 0 ;
31322 PyObject * obj2 = 0 ;
31323 char * kwnames[] = {
31324 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
31325 };
31326
31327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31329 if (!SWIG_IsOK(res1)) {
31330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
31331 }
31332 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31333 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
31334 if (!SWIG_IsOK(res2)) {
31335 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
31336 }
31337 if (obj2) {
31338 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31339 if (!SWIG_IsOK(ecode3)) {
31340 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
31341 }
31342 arg3 = static_cast< bool >(val3);
31343 }
31344 {
31345 PyThreadState* __tstate = wxPyBeginAllowThreads();
31346 (arg1)->Add(arg2,arg3);
31347 wxPyEndAllowThreads(__tstate);
31348 if (PyErr_Occurred()) SWIG_fail;
31349 }
31350 resultobj = SWIG_Py_Void();
31351 return resultobj;
31352 fail:
31353 return NULL;
31354 }
31355
31356
31357 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31358 PyObject *resultobj = 0;
31359 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31360 SwigValueWrapper<wxDataFormat > result;
31361 void *argp1 = 0 ;
31362 int res1 = 0 ;
31363 PyObject *swig_obj[1] ;
31364
31365 if (!args) SWIG_fail;
31366 swig_obj[0] = args;
31367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31368 if (!SWIG_IsOK(res1)) {
31369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
31370 }
31371 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31372 {
31373 PyThreadState* __tstate = wxPyBeginAllowThreads();
31374 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
31375 wxPyEndAllowThreads(__tstate);
31376 if (PyErr_Occurred()) SWIG_fail;
31377 }
31378 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31379 return resultobj;
31380 fail:
31381 return NULL;
31382 }
31383
31384
31385 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31386 PyObject *obj;
31387 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31388 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
31389 return SWIG_Py_Void();
31390 }
31391
31392 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31393 return SWIG_Python_InitShadowInstance(args);
31394 }
31395
31396 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31397 PyObject *resultobj = 0;
31398 wxString const &arg1_defvalue = wxPyEmptyString ;
31399 wxString *arg1 = (wxString *) &arg1_defvalue ;
31400 wxTextDataObject *result = 0 ;
31401 bool temp1 = false ;
31402 PyObject * obj0 = 0 ;
31403 char * kwnames[] = {
31404 (char *) "text", NULL
31405 };
31406
31407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
31408 if (obj0) {
31409 {
31410 arg1 = wxString_in_helper(obj0);
31411 if (arg1 == NULL) SWIG_fail;
31412 temp1 = true;
31413 }
31414 }
31415 {
31416 PyThreadState* __tstate = wxPyBeginAllowThreads();
31417 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
31418 wxPyEndAllowThreads(__tstate);
31419 if (PyErr_Occurred()) SWIG_fail;
31420 }
31421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
31422 {
31423 if (temp1)
31424 delete arg1;
31425 }
31426 return resultobj;
31427 fail:
31428 {
31429 if (temp1)
31430 delete arg1;
31431 }
31432 return NULL;
31433 }
31434
31435
31436 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31437 PyObject *resultobj = 0;
31438 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31439 size_t result;
31440 void *argp1 = 0 ;
31441 int res1 = 0 ;
31442 PyObject *swig_obj[1] ;
31443
31444 if (!args) SWIG_fail;
31445 swig_obj[0] = args;
31446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31447 if (!SWIG_IsOK(res1)) {
31448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31449 }
31450 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31451 {
31452 PyThreadState* __tstate = wxPyBeginAllowThreads();
31453 result = (size_t)(arg1)->GetTextLength();
31454 wxPyEndAllowThreads(__tstate);
31455 if (PyErr_Occurred()) SWIG_fail;
31456 }
31457 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31458 return resultobj;
31459 fail:
31460 return NULL;
31461 }
31462
31463
31464 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31465 PyObject *resultobj = 0;
31466 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31467 wxString result;
31468 void *argp1 = 0 ;
31469 int res1 = 0 ;
31470 PyObject *swig_obj[1] ;
31471
31472 if (!args) SWIG_fail;
31473 swig_obj[0] = args;
31474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31475 if (!SWIG_IsOK(res1)) {
31476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31477 }
31478 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31479 {
31480 PyThreadState* __tstate = wxPyBeginAllowThreads();
31481 result = (arg1)->GetText();
31482 wxPyEndAllowThreads(__tstate);
31483 if (PyErr_Occurred()) SWIG_fail;
31484 }
31485 {
31486 #if wxUSE_UNICODE
31487 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31488 #else
31489 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31490 #endif
31491 }
31492 return resultobj;
31493 fail:
31494 return NULL;
31495 }
31496
31497
31498 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31499 PyObject *resultobj = 0;
31500 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31501 wxString *arg2 = 0 ;
31502 void *argp1 = 0 ;
31503 int res1 = 0 ;
31504 bool temp2 = false ;
31505 PyObject * obj0 = 0 ;
31506 PyObject * obj1 = 0 ;
31507 char * kwnames[] = {
31508 (char *) "self",(char *) "text", NULL
31509 };
31510
31511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
31512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31513 if (!SWIG_IsOK(res1)) {
31514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31515 }
31516 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31517 {
31518 arg2 = wxString_in_helper(obj1);
31519 if (arg2 == NULL) SWIG_fail;
31520 temp2 = true;
31521 }
31522 {
31523 PyThreadState* __tstate = wxPyBeginAllowThreads();
31524 (arg1)->SetText((wxString const &)*arg2);
31525 wxPyEndAllowThreads(__tstate);
31526 if (PyErr_Occurred()) SWIG_fail;
31527 }
31528 resultobj = SWIG_Py_Void();
31529 {
31530 if (temp2)
31531 delete arg2;
31532 }
31533 return resultobj;
31534 fail:
31535 {
31536 if (temp2)
31537 delete arg2;
31538 }
31539 return NULL;
31540 }
31541
31542
31543 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31544 PyObject *obj;
31545 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31546 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
31547 return SWIG_Py_Void();
31548 }
31549
31550 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31551 return SWIG_Python_InitShadowInstance(args);
31552 }
31553
31554 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31555 PyObject *resultobj = 0;
31556 wxString const &arg1_defvalue = wxPyEmptyString ;
31557 wxString *arg1 = (wxString *) &arg1_defvalue ;
31558 wxPyTextDataObject *result = 0 ;
31559 bool temp1 = false ;
31560 PyObject * obj0 = 0 ;
31561 char * kwnames[] = {
31562 (char *) "text", NULL
31563 };
31564
31565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
31566 if (obj0) {
31567 {
31568 arg1 = wxString_in_helper(obj0);
31569 if (arg1 == NULL) SWIG_fail;
31570 temp1 = true;
31571 }
31572 }
31573 {
31574 PyThreadState* __tstate = wxPyBeginAllowThreads();
31575 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
31576 wxPyEndAllowThreads(__tstate);
31577 if (PyErr_Occurred()) SWIG_fail;
31578 }
31579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
31580 {
31581 if (temp1)
31582 delete arg1;
31583 }
31584 return resultobj;
31585 fail:
31586 {
31587 if (temp1)
31588 delete arg1;
31589 }
31590 return NULL;
31591 }
31592
31593
31594 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31595 PyObject *resultobj = 0;
31596 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
31597 PyObject *arg2 = (PyObject *) 0 ;
31598 PyObject *arg3 = (PyObject *) 0 ;
31599 void *argp1 = 0 ;
31600 int res1 = 0 ;
31601 PyObject * obj0 = 0 ;
31602 PyObject * obj1 = 0 ;
31603 PyObject * obj2 = 0 ;
31604 char * kwnames[] = {
31605 (char *) "self",(char *) "self",(char *) "_class", NULL
31606 };
31607
31608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
31610 if (!SWIG_IsOK(res1)) {
31611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
31612 }
31613 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
31614 arg2 = obj1;
31615 arg3 = obj2;
31616 {
31617 PyThreadState* __tstate = wxPyBeginAllowThreads();
31618 (arg1)->_setCallbackInfo(arg2,arg3);
31619 wxPyEndAllowThreads(__tstate);
31620 if (PyErr_Occurred()) SWIG_fail;
31621 }
31622 resultobj = SWIG_Py_Void();
31623 return resultobj;
31624 fail:
31625 return NULL;
31626 }
31627
31628
31629 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31630 PyObject *obj;
31631 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31632 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
31633 return SWIG_Py_Void();
31634 }
31635
31636 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31637 return SWIG_Python_InitShadowInstance(args);
31638 }
31639
31640 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31641 PyObject *resultobj = 0;
31642 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31643 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31644 wxBitmapDataObject *result = 0 ;
31645 void *argp1 = 0 ;
31646 int res1 = 0 ;
31647 PyObject * obj0 = 0 ;
31648 char * kwnames[] = {
31649 (char *) "bitmap", NULL
31650 };
31651
31652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
31653 if (obj0) {
31654 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31655 if (!SWIG_IsOK(res1)) {
31656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31657 }
31658 if (!argp1) {
31659 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31660 }
31661 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31662 }
31663 {
31664 PyThreadState* __tstate = wxPyBeginAllowThreads();
31665 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
31666 wxPyEndAllowThreads(__tstate);
31667 if (PyErr_Occurred()) SWIG_fail;
31668 }
31669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
31670 return resultobj;
31671 fail:
31672 return NULL;
31673 }
31674
31675
31676 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31677 PyObject *resultobj = 0;
31678 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31679 wxBitmap result;
31680 void *argp1 = 0 ;
31681 int res1 = 0 ;
31682 PyObject *swig_obj[1] ;
31683
31684 if (!args) SWIG_fail;
31685 swig_obj[0] = args;
31686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31687 if (!SWIG_IsOK(res1)) {
31688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
31689 }
31690 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31691 {
31692 PyThreadState* __tstate = wxPyBeginAllowThreads();
31693 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
31694 wxPyEndAllowThreads(__tstate);
31695 if (PyErr_Occurred()) SWIG_fail;
31696 }
31697 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
31698 return resultobj;
31699 fail:
31700 return NULL;
31701 }
31702
31703
31704 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31705 PyObject *resultobj = 0;
31706 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31707 wxBitmap *arg2 = 0 ;
31708 void *argp1 = 0 ;
31709 int res1 = 0 ;
31710 void *argp2 = 0 ;
31711 int res2 = 0 ;
31712 PyObject * obj0 = 0 ;
31713 PyObject * obj1 = 0 ;
31714 char * kwnames[] = {
31715 (char *) "self",(char *) "bitmap", NULL
31716 };
31717
31718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
31719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31720 if (!SWIG_IsOK(res1)) {
31721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
31722 }
31723 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31724 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
31725 if (!SWIG_IsOK(res2)) {
31726 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31727 }
31728 if (!argp2) {
31729 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31730 }
31731 arg2 = reinterpret_cast< wxBitmap * >(argp2);
31732 {
31733 PyThreadState* __tstate = wxPyBeginAllowThreads();
31734 (arg1)->SetBitmap((wxBitmap const &)*arg2);
31735 wxPyEndAllowThreads(__tstate);
31736 if (PyErr_Occurred()) SWIG_fail;
31737 }
31738 resultobj = SWIG_Py_Void();
31739 return resultobj;
31740 fail:
31741 return NULL;
31742 }
31743
31744
31745 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31746 PyObject *obj;
31747 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31748 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
31749 return SWIG_Py_Void();
31750 }
31751
31752 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31753 return SWIG_Python_InitShadowInstance(args);
31754 }
31755
31756 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31757 PyObject *resultobj = 0;
31758 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31759 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31760 wxPyBitmapDataObject *result = 0 ;
31761 void *argp1 = 0 ;
31762 int res1 = 0 ;
31763 PyObject * obj0 = 0 ;
31764 char * kwnames[] = {
31765 (char *) "bitmap", NULL
31766 };
31767
31768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
31769 if (obj0) {
31770 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31771 if (!SWIG_IsOK(res1)) {
31772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31773 }
31774 if (!argp1) {
31775 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31776 }
31777 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31778 }
31779 {
31780 PyThreadState* __tstate = wxPyBeginAllowThreads();
31781 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
31782 wxPyEndAllowThreads(__tstate);
31783 if (PyErr_Occurred()) SWIG_fail;
31784 }
31785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
31786 return resultobj;
31787 fail:
31788 return NULL;
31789 }
31790
31791
31792 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31793 PyObject *resultobj = 0;
31794 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
31795 PyObject *arg2 = (PyObject *) 0 ;
31796 PyObject *arg3 = (PyObject *) 0 ;
31797 void *argp1 = 0 ;
31798 int res1 = 0 ;
31799 PyObject * obj0 = 0 ;
31800 PyObject * obj1 = 0 ;
31801 PyObject * obj2 = 0 ;
31802 char * kwnames[] = {
31803 (char *) "self",(char *) "self",(char *) "_class", NULL
31804 };
31805
31806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
31808 if (!SWIG_IsOK(res1)) {
31809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
31810 }
31811 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
31812 arg2 = obj1;
31813 arg3 = obj2;
31814 {
31815 PyThreadState* __tstate = wxPyBeginAllowThreads();
31816 (arg1)->_setCallbackInfo(arg2,arg3);
31817 wxPyEndAllowThreads(__tstate);
31818 if (PyErr_Occurred()) SWIG_fail;
31819 }
31820 resultobj = SWIG_Py_Void();
31821 return resultobj;
31822 fail:
31823 return NULL;
31824 }
31825
31826
31827 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31828 PyObject *obj;
31829 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31830 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
31831 return SWIG_Py_Void();
31832 }
31833
31834 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31835 return SWIG_Python_InitShadowInstance(args);
31836 }
31837
31838 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31839 PyObject *resultobj = 0;
31840 wxFileDataObject *result = 0 ;
31841
31842 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
31843 {
31844 PyThreadState* __tstate = wxPyBeginAllowThreads();
31845 result = (wxFileDataObject *)new wxFileDataObject();
31846 wxPyEndAllowThreads(__tstate);
31847 if (PyErr_Occurred()) SWIG_fail;
31848 }
31849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
31850 return resultobj;
31851 fail:
31852 return NULL;
31853 }
31854
31855
31856 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31857 PyObject *resultobj = 0;
31858 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31859 wxArrayString *result = 0 ;
31860 void *argp1 = 0 ;
31861 int res1 = 0 ;
31862 PyObject *swig_obj[1] ;
31863
31864 if (!args) SWIG_fail;
31865 swig_obj[0] = args;
31866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31867 if (!SWIG_IsOK(res1)) {
31868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31869 }
31870 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31871 {
31872 PyThreadState* __tstate = wxPyBeginAllowThreads();
31873 {
31874 wxArrayString const &_result_ref = (arg1)->GetFilenames();
31875 result = (wxArrayString *) &_result_ref;
31876 }
31877 wxPyEndAllowThreads(__tstate);
31878 if (PyErr_Occurred()) SWIG_fail;
31879 }
31880 {
31881 resultobj = wxArrayString2PyList_helper(*result);
31882 }
31883 return resultobj;
31884 fail:
31885 return NULL;
31886 }
31887
31888
31889 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31890 PyObject *resultobj = 0;
31891 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31892 wxString *arg2 = 0 ;
31893 void *argp1 = 0 ;
31894 int res1 = 0 ;
31895 bool temp2 = false ;
31896 PyObject * obj0 = 0 ;
31897 PyObject * obj1 = 0 ;
31898 char * kwnames[] = {
31899 (char *) "self",(char *) "filename", NULL
31900 };
31901
31902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
31903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31904 if (!SWIG_IsOK(res1)) {
31905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31906 }
31907 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31908 {
31909 arg2 = wxString_in_helper(obj1);
31910 if (arg2 == NULL) SWIG_fail;
31911 temp2 = true;
31912 }
31913 {
31914 PyThreadState* __tstate = wxPyBeginAllowThreads();
31915 (arg1)->AddFile((wxString const &)*arg2);
31916 wxPyEndAllowThreads(__tstate);
31917 if (PyErr_Occurred()) SWIG_fail;
31918 }
31919 resultobj = SWIG_Py_Void();
31920 {
31921 if (temp2)
31922 delete arg2;
31923 }
31924 return resultobj;
31925 fail:
31926 {
31927 if (temp2)
31928 delete arg2;
31929 }
31930 return NULL;
31931 }
31932
31933
31934 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31935 PyObject *obj;
31936 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31937 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
31938 return SWIG_Py_Void();
31939 }
31940
31941 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31942 return SWIG_Python_InitShadowInstance(args);
31943 }
31944
31945 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31946 PyObject *resultobj = 0;
31947 wxDataFormat *arg1 = 0 ;
31948 wxCustomDataObject *result = 0 ;
31949 void *argp1 = 0 ;
31950 int res1 = 0 ;
31951
31952 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31954 if (!SWIG_IsOK(res1)) {
31955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31956 }
31957 if (!argp1) {
31958 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31959 }
31960 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31961 {
31962 PyThreadState* __tstate = wxPyBeginAllowThreads();
31963 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
31964 wxPyEndAllowThreads(__tstate);
31965 if (PyErr_Occurred()) SWIG_fail;
31966 }
31967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31968 return resultobj;
31969 fail:
31970 return NULL;
31971 }
31972
31973
31974 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31975 PyObject *resultobj = 0;
31976 wxString *arg1 = 0 ;
31977 wxCustomDataObject *result = 0 ;
31978 bool temp1 = false ;
31979
31980 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31981 {
31982 arg1 = wxString_in_helper(swig_obj[0]);
31983 if (arg1 == NULL) SWIG_fail;
31984 temp1 = true;
31985 }
31986 {
31987 PyThreadState* __tstate = wxPyBeginAllowThreads();
31988 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
31989 wxPyEndAllowThreads(__tstate);
31990 if (PyErr_Occurred()) SWIG_fail;
31991 }
31992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31993 {
31994 if (temp1)
31995 delete arg1;
31996 }
31997 return resultobj;
31998 fail:
31999 {
32000 if (temp1)
32001 delete arg1;
32002 }
32003 return NULL;
32004 }
32005
32006
32007 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
32008 PyObject *resultobj = 0;
32009 wxCustomDataObject *result = 0 ;
32010
32011 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
32012 {
32013 PyThreadState* __tstate = wxPyBeginAllowThreads();
32014 result = (wxCustomDataObject *)new wxCustomDataObject();
32015 wxPyEndAllowThreads(__tstate);
32016 if (PyErr_Occurred()) SWIG_fail;
32017 }
32018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32019 return resultobj;
32020 fail:
32021 return NULL;
32022 }
32023
32024
32025 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
32026 int argc;
32027 PyObject *argv[2];
32028
32029 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
32030 --argc;
32031 if (argc == 0) {
32032 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
32033 }
32034 if (argc == 1) {
32035 int _v = 0;
32036 {
32037 {
32038 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
32039 }
32040 }
32041 if (!_v) goto check_2;
32042 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
32043 }
32044 check_2:
32045
32046 if (argc == 1) {
32047 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
32048 }
32049
32050 fail:
32051 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
32052 return NULL;
32053 }
32054
32055
32056 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32057 PyObject *resultobj = 0;
32058 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32059 PyObject *arg2 = (PyObject *) 0 ;
32060 bool result;
32061 void *argp1 = 0 ;
32062 int res1 = 0 ;
32063 PyObject * obj0 = 0 ;
32064 PyObject * obj1 = 0 ;
32065 char * kwnames[] = {
32066 (char *) "self",(char *) "data", NULL
32067 };
32068
32069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32071 if (!SWIG_IsOK(res1)) {
32072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32073 }
32074 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32075 arg2 = obj1;
32076 {
32077 PyThreadState* __tstate = wxPyBeginAllowThreads();
32078 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
32079 wxPyEndAllowThreads(__tstate);
32080 if (PyErr_Occurred()) SWIG_fail;
32081 }
32082 {
32083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32084 }
32085 return resultobj;
32086 fail:
32087 return NULL;
32088 }
32089
32090
32091 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32092 PyObject *resultobj = 0;
32093 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32094 size_t result;
32095 void *argp1 = 0 ;
32096 int res1 = 0 ;
32097 PyObject *swig_obj[1] ;
32098
32099 if (!args) SWIG_fail;
32100 swig_obj[0] = args;
32101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32102 if (!SWIG_IsOK(res1)) {
32103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32104 }
32105 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32106 {
32107 PyThreadState* __tstate = wxPyBeginAllowThreads();
32108 result = (size_t)(arg1)->GetSize();
32109 wxPyEndAllowThreads(__tstate);
32110 if (PyErr_Occurred()) SWIG_fail;
32111 }
32112 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32113 return resultobj;
32114 fail:
32115 return NULL;
32116 }
32117
32118
32119 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32120 PyObject *resultobj = 0;
32121 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32122 PyObject *result = 0 ;
32123 void *argp1 = 0 ;
32124 int res1 = 0 ;
32125 PyObject *swig_obj[1] ;
32126
32127 if (!args) SWIG_fail;
32128 swig_obj[0] = args;
32129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32130 if (!SWIG_IsOK(res1)) {
32131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32132 }
32133 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32134 {
32135 PyThreadState* __tstate = wxPyBeginAllowThreads();
32136 result = (PyObject *)wxCustomDataObject_GetData(arg1);
32137 wxPyEndAllowThreads(__tstate);
32138 if (PyErr_Occurred()) SWIG_fail;
32139 }
32140 resultobj = result;
32141 return resultobj;
32142 fail:
32143 return NULL;
32144 }
32145
32146
32147 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32148 PyObject *obj;
32149 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32150 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
32151 return SWIG_Py_Void();
32152 }
32153
32154 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32155 return SWIG_Python_InitShadowInstance(args);
32156 }
32157
32158 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32159 PyObject *resultobj = 0;
32160 wxURLDataObject *result = 0 ;
32161
32162 if (!SWIG_Python_UnpackTuple(args,"new_URLDataObject",0,0,0)) SWIG_fail;
32163 {
32164 PyThreadState* __tstate = wxPyBeginAllowThreads();
32165 result = (wxURLDataObject *)new wxURLDataObject();
32166 wxPyEndAllowThreads(__tstate);
32167 if (PyErr_Occurred()) SWIG_fail;
32168 }
32169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
32170 return resultobj;
32171 fail:
32172 return NULL;
32173 }
32174
32175
32176 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32177 PyObject *resultobj = 0;
32178 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32179 wxString result;
32180 void *argp1 = 0 ;
32181 int res1 = 0 ;
32182 PyObject *swig_obj[1] ;
32183
32184 if (!args) SWIG_fail;
32185 swig_obj[0] = args;
32186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32187 if (!SWIG_IsOK(res1)) {
32188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32189 }
32190 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32191 {
32192 PyThreadState* __tstate = wxPyBeginAllowThreads();
32193 result = (arg1)->GetURL();
32194 wxPyEndAllowThreads(__tstate);
32195 if (PyErr_Occurred()) SWIG_fail;
32196 }
32197 {
32198 #if wxUSE_UNICODE
32199 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32200 #else
32201 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32202 #endif
32203 }
32204 return resultobj;
32205 fail:
32206 return NULL;
32207 }
32208
32209
32210 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32211 PyObject *resultobj = 0;
32212 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32213 wxString *arg2 = 0 ;
32214 void *argp1 = 0 ;
32215 int res1 = 0 ;
32216 bool temp2 = false ;
32217 PyObject * obj0 = 0 ;
32218 PyObject * obj1 = 0 ;
32219 char * kwnames[] = {
32220 (char *) "self",(char *) "url", NULL
32221 };
32222
32223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
32224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32225 if (!SWIG_IsOK(res1)) {
32226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32227 }
32228 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32229 {
32230 arg2 = wxString_in_helper(obj1);
32231 if (arg2 == NULL) SWIG_fail;
32232 temp2 = true;
32233 }
32234 {
32235 PyThreadState* __tstate = wxPyBeginAllowThreads();
32236 (arg1)->SetURL((wxString const &)*arg2);
32237 wxPyEndAllowThreads(__tstate);
32238 if (PyErr_Occurred()) SWIG_fail;
32239 }
32240 resultobj = SWIG_Py_Void();
32241 {
32242 if (temp2)
32243 delete arg2;
32244 }
32245 return resultobj;
32246 fail:
32247 {
32248 if (temp2)
32249 delete arg2;
32250 }
32251 return NULL;
32252 }
32253
32254
32255 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32256 PyObject *obj;
32257 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32258 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
32259 return SWIG_Py_Void();
32260 }
32261
32262 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32263 return SWIG_Python_InitShadowInstance(args);
32264 }
32265
32266 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32267 PyObject *resultobj = 0;
32268 wxMetafileDataObject *result = 0 ;
32269
32270 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
32271 {
32272 PyThreadState* __tstate = wxPyBeginAllowThreads();
32273 result = (wxMetafileDataObject *)new wxMetafileDataObject();
32274 wxPyEndAllowThreads(__tstate);
32275 if (PyErr_Occurred()) SWIG_fail;
32276 }
32277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
32278 return resultobj;
32279 fail:
32280 return NULL;
32281 }
32282
32283
32284 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32285 PyObject *resultobj = 0;
32286 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32287 wxMetafile *arg2 = 0 ;
32288 void *argp1 = 0 ;
32289 int res1 = 0 ;
32290 void *argp2 = 0 ;
32291 int res2 = 0 ;
32292 PyObject * obj0 = 0 ;
32293 PyObject * obj1 = 0 ;
32294 char * kwnames[] = {
32295 (char *) "self",(char *) "metafile", NULL
32296 };
32297
32298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
32299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32300 if (!SWIG_IsOK(res1)) {
32301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
32302 }
32303 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32304 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
32305 if (!SWIG_IsOK(res2)) {
32306 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32307 }
32308 if (!argp2) {
32309 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32310 }
32311 arg2 = reinterpret_cast< wxMetafile * >(argp2);
32312 {
32313 PyThreadState* __tstate = wxPyBeginAllowThreads();
32314 (arg1)->SetMetafile((wxMetafile const &)*arg2);
32315 wxPyEndAllowThreads(__tstate);
32316 if (PyErr_Occurred()) SWIG_fail;
32317 }
32318 resultobj = SWIG_Py_Void();
32319 return resultobj;
32320 fail:
32321 return NULL;
32322 }
32323
32324
32325 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32326 PyObject *resultobj = 0;
32327 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32328 wxMetafile result;
32329 void *argp1 = 0 ;
32330 int res1 = 0 ;
32331 PyObject *swig_obj[1] ;
32332
32333 if (!args) SWIG_fail;
32334 swig_obj[0] = args;
32335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32336 if (!SWIG_IsOK(res1)) {
32337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
32338 }
32339 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32340 {
32341 PyThreadState* __tstate = wxPyBeginAllowThreads();
32342 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
32343 wxPyEndAllowThreads(__tstate);
32344 if (PyErr_Occurred()) SWIG_fail;
32345 }
32346 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
32347 return resultobj;
32348 fail:
32349 return NULL;
32350 }
32351
32352
32353 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32354 PyObject *obj;
32355 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32356 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
32357 return SWIG_Py_Void();
32358 }
32359
32360 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32361 return SWIG_Python_InitShadowInstance(args);
32362 }
32363
32364 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32365 PyObject *resultobj = 0;
32366 wxDragResult arg1 ;
32367 bool result;
32368 int val1 ;
32369 int ecode1 = 0 ;
32370 PyObject * obj0 = 0 ;
32371 char * kwnames[] = {
32372 (char *) "res", NULL
32373 };
32374
32375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
32376 ecode1 = SWIG_AsVal_int(obj0, &val1);
32377 if (!SWIG_IsOK(ecode1)) {
32378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
32379 }
32380 arg1 = static_cast< wxDragResult >(val1);
32381 {
32382 PyThreadState* __tstate = wxPyBeginAllowThreads();
32383 result = (bool)wxIsDragResultOk(arg1);
32384 wxPyEndAllowThreads(__tstate);
32385 if (PyErr_Occurred()) SWIG_fail;
32386 }
32387 {
32388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32389 }
32390 return resultobj;
32391 fail:
32392 return NULL;
32393 }
32394
32395
32396 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32397 PyObject *resultobj = 0;
32398 wxWindow *arg1 = (wxWindow *) 0 ;
32399 wxCursor const &arg2_defvalue = wxNullCursor ;
32400 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
32401 wxCursor const &arg3_defvalue = wxNullCursor ;
32402 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
32403 wxCursor const &arg4_defvalue = wxNullCursor ;
32404 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
32405 wxPyDropSource *result = 0 ;
32406 void *argp1 = 0 ;
32407 int res1 = 0 ;
32408 void *argp2 = 0 ;
32409 int res2 = 0 ;
32410 void *argp3 = 0 ;
32411 int res3 = 0 ;
32412 void *argp4 = 0 ;
32413 int res4 = 0 ;
32414 PyObject * obj0 = 0 ;
32415 PyObject * obj1 = 0 ;
32416 PyObject * obj2 = 0 ;
32417 PyObject * obj3 = 0 ;
32418 char * kwnames[] = {
32419 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
32420 };
32421
32422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32424 if (!SWIG_IsOK(res1)) {
32425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
32426 }
32427 arg1 = reinterpret_cast< wxWindow * >(argp1);
32428 if (obj1) {
32429 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
32430 if (!SWIG_IsOK(res2)) {
32431 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32432 }
32433 if (!argp2) {
32434 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32435 }
32436 arg2 = reinterpret_cast< wxCursor * >(argp2);
32437 }
32438 if (obj2) {
32439 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32440 if (!SWIG_IsOK(res3)) {
32441 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32442 }
32443 if (!argp3) {
32444 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32445 }
32446 arg3 = reinterpret_cast< wxCursor * >(argp3);
32447 }
32448 if (obj3) {
32449 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
32450 if (!SWIG_IsOK(res4)) {
32451 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32452 }
32453 if (!argp4) {
32454 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32455 }
32456 arg4 = reinterpret_cast< wxCursor * >(argp4);
32457 }
32458 {
32459 PyThreadState* __tstate = wxPyBeginAllowThreads();
32460 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
32461 wxPyEndAllowThreads(__tstate);
32462 if (PyErr_Occurred()) SWIG_fail;
32463 }
32464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
32465 return resultobj;
32466 fail:
32467 return NULL;
32468 }
32469
32470
32471 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32472 PyObject *resultobj = 0;
32473 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32474 PyObject *arg2 = (PyObject *) 0 ;
32475 PyObject *arg3 = (PyObject *) 0 ;
32476 int arg4 ;
32477 void *argp1 = 0 ;
32478 int res1 = 0 ;
32479 int val4 ;
32480 int ecode4 = 0 ;
32481 PyObject * obj0 = 0 ;
32482 PyObject * obj1 = 0 ;
32483 PyObject * obj2 = 0 ;
32484 PyObject * obj3 = 0 ;
32485 char * kwnames[] = {
32486 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32487 };
32488
32489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32491 if (!SWIG_IsOK(res1)) {
32492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32493 }
32494 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32495 arg2 = obj1;
32496 arg3 = obj2;
32497 ecode4 = SWIG_AsVal_int(obj3, &val4);
32498 if (!SWIG_IsOK(ecode4)) {
32499 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
32500 }
32501 arg4 = static_cast< int >(val4);
32502 {
32503 PyThreadState* __tstate = wxPyBeginAllowThreads();
32504 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32505 wxPyEndAllowThreads(__tstate);
32506 if (PyErr_Occurred()) SWIG_fail;
32507 }
32508 resultobj = SWIG_Py_Void();
32509 return resultobj;
32510 fail:
32511 return NULL;
32512 }
32513
32514
32515 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32516 PyObject *resultobj = 0;
32517 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32518 void *argp1 = 0 ;
32519 int res1 = 0 ;
32520 PyObject *swig_obj[1] ;
32521
32522 if (!args) SWIG_fail;
32523 swig_obj[0] = args;
32524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
32525 if (!SWIG_IsOK(res1)) {
32526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32527 }
32528 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32529 {
32530 PyThreadState* __tstate = wxPyBeginAllowThreads();
32531 delete arg1;
32532
32533 wxPyEndAllowThreads(__tstate);
32534 if (PyErr_Occurred()) SWIG_fail;
32535 }
32536 resultobj = SWIG_Py_Void();
32537 return resultobj;
32538 fail:
32539 return NULL;
32540 }
32541
32542
32543 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32544 PyObject *resultobj = 0;
32545 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32546 wxDataObject *arg2 = 0 ;
32547 void *argp1 = 0 ;
32548 int res1 = 0 ;
32549 void *argp2 = 0 ;
32550 int res2 = 0 ;
32551 PyObject * obj0 = 0 ;
32552 PyObject * obj1 = 0 ;
32553 char * kwnames[] = {
32554 (char *) "self",(char *) "data", NULL
32555 };
32556
32557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32559 if (!SWIG_IsOK(res1)) {
32560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32561 }
32562 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32563 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
32564 if (!SWIG_IsOK(res2)) {
32565 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32566 }
32567 if (!argp2) {
32568 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32569 }
32570 arg2 = reinterpret_cast< wxDataObject * >(argp2);
32571 {
32572 PyThreadState* __tstate = wxPyBeginAllowThreads();
32573 (arg1)->SetData(*arg2);
32574 wxPyEndAllowThreads(__tstate);
32575 if (PyErr_Occurred()) SWIG_fail;
32576 }
32577 resultobj = SWIG_Py_Void();
32578 return resultobj;
32579 fail:
32580 return NULL;
32581 }
32582
32583
32584 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32585 PyObject *resultobj = 0;
32586 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32587 wxDataObject *result = 0 ;
32588 void *argp1 = 0 ;
32589 int res1 = 0 ;
32590 PyObject *swig_obj[1] ;
32591
32592 if (!args) SWIG_fail;
32593 swig_obj[0] = args;
32594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32595 if (!SWIG_IsOK(res1)) {
32596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32597 }
32598 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32599 {
32600 PyThreadState* __tstate = wxPyBeginAllowThreads();
32601 result = (wxDataObject *)(arg1)->GetDataObject();
32602 wxPyEndAllowThreads(__tstate);
32603 if (PyErr_Occurred()) SWIG_fail;
32604 }
32605 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32606 return resultobj;
32607 fail:
32608 return NULL;
32609 }
32610
32611
32612 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32613 PyObject *resultobj = 0;
32614 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32615 wxDragResult arg2 ;
32616 wxCursor *arg3 = 0 ;
32617 void *argp1 = 0 ;
32618 int res1 = 0 ;
32619 int val2 ;
32620 int ecode2 = 0 ;
32621 void *argp3 = 0 ;
32622 int res3 = 0 ;
32623 PyObject * obj0 = 0 ;
32624 PyObject * obj1 = 0 ;
32625 PyObject * obj2 = 0 ;
32626 char * kwnames[] = {
32627 (char *) "self",(char *) "res",(char *) "cursor", NULL
32628 };
32629
32630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32632 if (!SWIG_IsOK(res1)) {
32633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32634 }
32635 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32636 ecode2 = SWIG_AsVal_int(obj1, &val2);
32637 if (!SWIG_IsOK(ecode2)) {
32638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
32639 }
32640 arg2 = static_cast< wxDragResult >(val2);
32641 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32642 if (!SWIG_IsOK(res3)) {
32643 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32644 }
32645 if (!argp3) {
32646 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32647 }
32648 arg3 = reinterpret_cast< wxCursor * >(argp3);
32649 {
32650 PyThreadState* __tstate = wxPyBeginAllowThreads();
32651 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
32652 wxPyEndAllowThreads(__tstate);
32653 if (PyErr_Occurred()) SWIG_fail;
32654 }
32655 resultobj = SWIG_Py_Void();
32656 return resultobj;
32657 fail:
32658 return NULL;
32659 }
32660
32661
32662 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32663 PyObject *resultobj = 0;
32664 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32665 int arg2 = (int) wxDrag_CopyOnly ;
32666 wxDragResult result;
32667 void *argp1 = 0 ;
32668 int res1 = 0 ;
32669 int val2 ;
32670 int ecode2 = 0 ;
32671 PyObject * obj0 = 0 ;
32672 PyObject * obj1 = 0 ;
32673 char * kwnames[] = {
32674 (char *) "self",(char *) "flags", NULL
32675 };
32676
32677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
32678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32679 if (!SWIG_IsOK(res1)) {
32680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32681 }
32682 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32683 if (obj1) {
32684 ecode2 = SWIG_AsVal_int(obj1, &val2);
32685 if (!SWIG_IsOK(ecode2)) {
32686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
32687 }
32688 arg2 = static_cast< int >(val2);
32689 }
32690 {
32691 PyThreadState* __tstate = wxPyBeginAllowThreads();
32692 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
32693 wxPyEndAllowThreads(__tstate);
32694 if (PyErr_Occurred()) SWIG_fail;
32695 }
32696 resultobj = SWIG_From_int(static_cast< int >(result));
32697 return resultobj;
32698 fail:
32699 return NULL;
32700 }
32701
32702
32703 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32704 PyObject *resultobj = 0;
32705 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32706 wxDragResult arg2 ;
32707 bool result;
32708 void *argp1 = 0 ;
32709 int res1 = 0 ;
32710 int val2 ;
32711 int ecode2 = 0 ;
32712 PyObject * obj0 = 0 ;
32713 PyObject * obj1 = 0 ;
32714 char * kwnames[] = {
32715 (char *) "self",(char *) "effect", NULL
32716 };
32717
32718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
32719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32720 if (!SWIG_IsOK(res1)) {
32721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32722 }
32723 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32724 ecode2 = SWIG_AsVal_int(obj1, &val2);
32725 if (!SWIG_IsOK(ecode2)) {
32726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
32727 }
32728 arg2 = static_cast< wxDragResult >(val2);
32729 {
32730 PyThreadState* __tstate = wxPyBeginAllowThreads();
32731 result = (bool)(arg1)->GiveFeedback(arg2);
32732 wxPyEndAllowThreads(__tstate);
32733 if (PyErr_Occurred()) SWIG_fail;
32734 }
32735 {
32736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32737 }
32738 return resultobj;
32739 fail:
32740 return NULL;
32741 }
32742
32743
32744 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32745 PyObject *obj;
32746 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32747 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
32748 return SWIG_Py_Void();
32749 }
32750
32751 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32752 return SWIG_Python_InitShadowInstance(args);
32753 }
32754
32755 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32756 PyObject *resultobj = 0;
32757 wxDataObject *arg1 = (wxDataObject *) NULL ;
32758 wxPyDropTarget *result = 0 ;
32759 int res1 = 0 ;
32760 PyObject * obj0 = 0 ;
32761 char * kwnames[] = {
32762 (char *) "dataObject", NULL
32763 };
32764
32765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
32766 if (obj0) {
32767 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32768 if (!SWIG_IsOK(res1)) {
32769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
32770 }
32771 }
32772 {
32773 PyThreadState* __tstate = wxPyBeginAllowThreads();
32774 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
32775 wxPyEndAllowThreads(__tstate);
32776 if (PyErr_Occurred()) SWIG_fail;
32777 }
32778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
32779 return resultobj;
32780 fail:
32781 return NULL;
32782 }
32783
32784
32785 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32786 PyObject *resultobj = 0;
32787 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32788 PyObject *arg2 = (PyObject *) 0 ;
32789 PyObject *arg3 = (PyObject *) 0 ;
32790 void *argp1 = 0 ;
32791 int res1 = 0 ;
32792 PyObject * obj0 = 0 ;
32793 PyObject * obj1 = 0 ;
32794 PyObject * obj2 = 0 ;
32795 char * kwnames[] = {
32796 (char *) "self",(char *) "self",(char *) "_class", NULL
32797 };
32798
32799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32801 if (!SWIG_IsOK(res1)) {
32802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32803 }
32804 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32805 arg2 = obj1;
32806 arg3 = obj2;
32807 {
32808 PyThreadState* __tstate = wxPyBeginAllowThreads();
32809 (arg1)->_setCallbackInfo(arg2,arg3);
32810 wxPyEndAllowThreads(__tstate);
32811 if (PyErr_Occurred()) SWIG_fail;
32812 }
32813 resultobj = SWIG_Py_Void();
32814 return resultobj;
32815 fail:
32816 return NULL;
32817 }
32818
32819
32820 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32821 PyObject *resultobj = 0;
32822 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32823 void *argp1 = 0 ;
32824 int res1 = 0 ;
32825 PyObject *swig_obj[1] ;
32826
32827 if (!args) SWIG_fail;
32828 swig_obj[0] = args;
32829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
32830 if (!SWIG_IsOK(res1)) {
32831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32832 }
32833 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32834 {
32835 PyThreadState* __tstate = wxPyBeginAllowThreads();
32836 delete arg1;
32837
32838 wxPyEndAllowThreads(__tstate);
32839 if (PyErr_Occurred()) SWIG_fail;
32840 }
32841 resultobj = SWIG_Py_Void();
32842 return resultobj;
32843 fail:
32844 return NULL;
32845 }
32846
32847
32848 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32849 PyObject *resultobj = 0;
32850 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32851 wxDataObject *result = 0 ;
32852 void *argp1 = 0 ;
32853 int res1 = 0 ;
32854 PyObject *swig_obj[1] ;
32855
32856 if (!args) SWIG_fail;
32857 swig_obj[0] = args;
32858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32859 if (!SWIG_IsOK(res1)) {
32860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32861 }
32862 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32863 {
32864 PyThreadState* __tstate = wxPyBeginAllowThreads();
32865 result = (wxDataObject *)(arg1)->GetDataObject();
32866 wxPyEndAllowThreads(__tstate);
32867 if (PyErr_Occurred()) SWIG_fail;
32868 }
32869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32870 return resultobj;
32871 fail:
32872 return NULL;
32873 }
32874
32875
32876 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32877 PyObject *resultobj = 0;
32878 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32879 wxDataObject *arg2 = (wxDataObject *) 0 ;
32880 void *argp1 = 0 ;
32881 int res1 = 0 ;
32882 int res2 = 0 ;
32883 PyObject * obj0 = 0 ;
32884 PyObject * obj1 = 0 ;
32885 char * kwnames[] = {
32886 (char *) "self",(char *) "dataObject", NULL
32887 };
32888
32889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
32890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32891 if (!SWIG_IsOK(res1)) {
32892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32893 }
32894 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32895 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32896 if (!SWIG_IsOK(res2)) {
32897 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
32898 }
32899 {
32900 PyThreadState* __tstate = wxPyBeginAllowThreads();
32901 (arg1)->SetDataObject(arg2);
32902 wxPyEndAllowThreads(__tstate);
32903 if (PyErr_Occurred()) SWIG_fail;
32904 }
32905 resultobj = SWIG_Py_Void();
32906 return resultobj;
32907 fail:
32908 return NULL;
32909 }
32910
32911
32912 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32913 PyObject *resultobj = 0;
32914 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32915 int arg2 ;
32916 int arg3 ;
32917 wxDragResult arg4 ;
32918 wxDragResult result;
32919 void *argp1 = 0 ;
32920 int res1 = 0 ;
32921 int val2 ;
32922 int ecode2 = 0 ;
32923 int val3 ;
32924 int ecode3 = 0 ;
32925 int val4 ;
32926 int ecode4 = 0 ;
32927 PyObject * obj0 = 0 ;
32928 PyObject * obj1 = 0 ;
32929 PyObject * obj2 = 0 ;
32930 PyObject * obj3 = 0 ;
32931 char * kwnames[] = {
32932 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
32933 };
32934
32935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32937 if (!SWIG_IsOK(res1)) {
32938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32939 }
32940 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32941 ecode2 = SWIG_AsVal_int(obj1, &val2);
32942 if (!SWIG_IsOK(ecode2)) {
32943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
32944 }
32945 arg2 = static_cast< int >(val2);
32946 ecode3 = SWIG_AsVal_int(obj2, &val3);
32947 if (!SWIG_IsOK(ecode3)) {
32948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
32949 }
32950 arg3 = static_cast< int >(val3);
32951 ecode4 = SWIG_AsVal_int(obj3, &val4);
32952 if (!SWIG_IsOK(ecode4)) {
32953 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
32954 }
32955 arg4 = static_cast< wxDragResult >(val4);
32956 {
32957 PyThreadState* __tstate = wxPyBeginAllowThreads();
32958 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
32959 wxPyEndAllowThreads(__tstate);
32960 if (PyErr_Occurred()) SWIG_fail;
32961 }
32962 resultobj = SWIG_From_int(static_cast< int >(result));
32963 return resultobj;
32964 fail:
32965 return NULL;
32966 }
32967
32968
32969 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32970 PyObject *resultobj = 0;
32971 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32972 int arg2 ;
32973 int arg3 ;
32974 wxDragResult arg4 ;
32975 wxDragResult result;
32976 void *argp1 = 0 ;
32977 int res1 = 0 ;
32978 int val2 ;
32979 int ecode2 = 0 ;
32980 int val3 ;
32981 int ecode3 = 0 ;
32982 int val4 ;
32983 int ecode4 = 0 ;
32984 PyObject * obj0 = 0 ;
32985 PyObject * obj1 = 0 ;
32986 PyObject * obj2 = 0 ;
32987 PyObject * obj3 = 0 ;
32988 char * kwnames[] = {
32989 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
32990 };
32991
32992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32994 if (!SWIG_IsOK(res1)) {
32995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32996 }
32997 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32998 ecode2 = SWIG_AsVal_int(obj1, &val2);
32999 if (!SWIG_IsOK(ecode2)) {
33000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33001 }
33002 arg2 = static_cast< int >(val2);
33003 ecode3 = SWIG_AsVal_int(obj2, &val3);
33004 if (!SWIG_IsOK(ecode3)) {
33005 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33006 }
33007 arg3 = static_cast< int >(val3);
33008 ecode4 = SWIG_AsVal_int(obj3, &val4);
33009 if (!SWIG_IsOK(ecode4)) {
33010 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33011 }
33012 arg4 = static_cast< wxDragResult >(val4);
33013 {
33014 PyThreadState* __tstate = wxPyBeginAllowThreads();
33015 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33016 wxPyEndAllowThreads(__tstate);
33017 if (PyErr_Occurred()) SWIG_fail;
33018 }
33019 resultobj = SWIG_From_int(static_cast< int >(result));
33020 return resultobj;
33021 fail:
33022 return NULL;
33023 }
33024
33025
33026 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33027 PyObject *resultobj = 0;
33028 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33029 void *argp1 = 0 ;
33030 int res1 = 0 ;
33031 PyObject *swig_obj[1] ;
33032
33033 if (!args) SWIG_fail;
33034 swig_obj[0] = args;
33035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33036 if (!SWIG_IsOK(res1)) {
33037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33038 }
33039 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33040 {
33041 PyThreadState* __tstate = wxPyBeginAllowThreads();
33042 (arg1)->OnLeave();
33043 wxPyEndAllowThreads(__tstate);
33044 if (PyErr_Occurred()) SWIG_fail;
33045 }
33046 resultobj = SWIG_Py_Void();
33047 return resultobj;
33048 fail:
33049 return NULL;
33050 }
33051
33052
33053 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33054 PyObject *resultobj = 0;
33055 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33056 int arg2 ;
33057 int arg3 ;
33058 bool result;
33059 void *argp1 = 0 ;
33060 int res1 = 0 ;
33061 int val2 ;
33062 int ecode2 = 0 ;
33063 int val3 ;
33064 int ecode3 = 0 ;
33065 PyObject * obj0 = 0 ;
33066 PyObject * obj1 = 0 ;
33067 PyObject * obj2 = 0 ;
33068 char * kwnames[] = {
33069 (char *) "self",(char *) "x",(char *) "y", NULL
33070 };
33071
33072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33074 if (!SWIG_IsOK(res1)) {
33075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33076 }
33077 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33078 ecode2 = SWIG_AsVal_int(obj1, &val2);
33079 if (!SWIG_IsOK(ecode2)) {
33080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33081 }
33082 arg2 = static_cast< int >(val2);
33083 ecode3 = SWIG_AsVal_int(obj2, &val3);
33084 if (!SWIG_IsOK(ecode3)) {
33085 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33086 }
33087 arg3 = static_cast< int >(val3);
33088 {
33089 PyThreadState* __tstate = wxPyBeginAllowThreads();
33090 result = (bool)(arg1)->OnDrop(arg2,arg3);
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_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33104 PyObject *resultobj = 0;
33105 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33106 bool result;
33107 void *argp1 = 0 ;
33108 int res1 = 0 ;
33109 PyObject *swig_obj[1] ;
33110
33111 if (!args) SWIG_fail;
33112 swig_obj[0] = args;
33113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33114 if (!SWIG_IsOK(res1)) {
33115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33116 }
33117 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33118 {
33119 PyThreadState* __tstate = wxPyBeginAllowThreads();
33120 result = (bool)(arg1)->GetData();
33121 wxPyEndAllowThreads(__tstate);
33122 if (PyErr_Occurred()) SWIG_fail;
33123 }
33124 {
33125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33126 }
33127 return resultobj;
33128 fail:
33129 return NULL;
33130 }
33131
33132
33133 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33134 PyObject *resultobj = 0;
33135 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33136 wxDragResult arg2 ;
33137 void *argp1 = 0 ;
33138 int res1 = 0 ;
33139 int val2 ;
33140 int ecode2 = 0 ;
33141 PyObject * obj0 = 0 ;
33142 PyObject * obj1 = 0 ;
33143 char * kwnames[] = {
33144 (char *) "self",(char *) "action", NULL
33145 };
33146
33147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
33148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33149 if (!SWIG_IsOK(res1)) {
33150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33151 }
33152 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33153 ecode2 = SWIG_AsVal_int(obj1, &val2);
33154 if (!SWIG_IsOK(ecode2)) {
33155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
33156 }
33157 arg2 = static_cast< wxDragResult >(val2);
33158 {
33159 PyThreadState* __tstate = wxPyBeginAllowThreads();
33160 (arg1)->SetDefaultAction(arg2);
33161 wxPyEndAllowThreads(__tstate);
33162 if (PyErr_Occurred()) SWIG_fail;
33163 }
33164 resultobj = SWIG_Py_Void();
33165 return resultobj;
33166 fail:
33167 return NULL;
33168 }
33169
33170
33171 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33172 PyObject *resultobj = 0;
33173 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33174 wxDragResult result;
33175 void *argp1 = 0 ;
33176 int res1 = 0 ;
33177 PyObject *swig_obj[1] ;
33178
33179 if (!args) SWIG_fail;
33180 swig_obj[0] = args;
33181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33182 if (!SWIG_IsOK(res1)) {
33183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33184 }
33185 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33186 {
33187 PyThreadState* __tstate = wxPyBeginAllowThreads();
33188 result = (wxDragResult)(arg1)->GetDefaultAction();
33189 wxPyEndAllowThreads(__tstate);
33190 if (PyErr_Occurred()) SWIG_fail;
33191 }
33192 resultobj = SWIG_From_int(static_cast< int >(result));
33193 return resultobj;
33194 fail:
33195 return NULL;
33196 }
33197
33198
33199 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33200 PyObject *obj;
33201 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33202 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
33203 return SWIG_Py_Void();
33204 }
33205
33206 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33207 return SWIG_Python_InitShadowInstance(args);
33208 }
33209
33210 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33211 PyObject *resultobj = 0;
33212 wxPyTextDropTarget *result = 0 ;
33213
33214 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
33215 {
33216 PyThreadState* __tstate = wxPyBeginAllowThreads();
33217 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
33218 wxPyEndAllowThreads(__tstate);
33219 if (PyErr_Occurred()) SWIG_fail;
33220 }
33221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
33222 return resultobj;
33223 fail:
33224 return NULL;
33225 }
33226
33227
33228 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33229 PyObject *resultobj = 0;
33230 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33231 PyObject *arg2 = (PyObject *) 0 ;
33232 PyObject *arg3 = (PyObject *) 0 ;
33233 void *argp1 = 0 ;
33234 int res1 = 0 ;
33235 PyObject * obj0 = 0 ;
33236 PyObject * obj1 = 0 ;
33237 PyObject * obj2 = 0 ;
33238 char * kwnames[] = {
33239 (char *) "self",(char *) "self",(char *) "_class", NULL
33240 };
33241
33242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33244 if (!SWIG_IsOK(res1)) {
33245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33246 }
33247 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33248 arg2 = obj1;
33249 arg3 = obj2;
33250 {
33251 PyThreadState* __tstate = wxPyBeginAllowThreads();
33252 (arg1)->_setCallbackInfo(arg2,arg3);
33253 wxPyEndAllowThreads(__tstate);
33254 if (PyErr_Occurred()) SWIG_fail;
33255 }
33256 resultobj = SWIG_Py_Void();
33257 return resultobj;
33258 fail:
33259 return NULL;
33260 }
33261
33262
33263 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33264 PyObject *resultobj = 0;
33265 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33266 int arg2 ;
33267 int arg3 ;
33268 wxString *arg4 = 0 ;
33269 bool result;
33270 void *argp1 = 0 ;
33271 int res1 = 0 ;
33272 int val2 ;
33273 int ecode2 = 0 ;
33274 int val3 ;
33275 int ecode3 = 0 ;
33276 bool temp4 = false ;
33277 PyObject * obj0 = 0 ;
33278 PyObject * obj1 = 0 ;
33279 PyObject * obj2 = 0 ;
33280 PyObject * obj3 = 0 ;
33281 char * kwnames[] = {
33282 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
33283 };
33284
33285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33287 if (!SWIG_IsOK(res1)) {
33288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33289 }
33290 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33291 ecode2 = SWIG_AsVal_int(obj1, &val2);
33292 if (!SWIG_IsOK(ecode2)) {
33293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
33294 }
33295 arg2 = static_cast< int >(val2);
33296 ecode3 = SWIG_AsVal_int(obj2, &val3);
33297 if (!SWIG_IsOK(ecode3)) {
33298 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
33299 }
33300 arg3 = static_cast< int >(val3);
33301 {
33302 arg4 = wxString_in_helper(obj3);
33303 if (arg4 == NULL) SWIG_fail;
33304 temp4 = true;
33305 }
33306 {
33307 PyThreadState* __tstate = wxPyBeginAllowThreads();
33308 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
33309 wxPyEndAllowThreads(__tstate);
33310 if (PyErr_Occurred()) SWIG_fail;
33311 }
33312 {
33313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33314 }
33315 {
33316 if (temp4)
33317 delete arg4;
33318 }
33319 return resultobj;
33320 fail:
33321 {
33322 if (temp4)
33323 delete arg4;
33324 }
33325 return NULL;
33326 }
33327
33328
33329 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33330 PyObject *resultobj = 0;
33331 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33332 int arg2 ;
33333 int arg3 ;
33334 wxDragResult arg4 ;
33335 wxDragResult result;
33336 void *argp1 = 0 ;
33337 int res1 = 0 ;
33338 int val2 ;
33339 int ecode2 = 0 ;
33340 int val3 ;
33341 int ecode3 = 0 ;
33342 int val4 ;
33343 int ecode4 = 0 ;
33344 PyObject * obj0 = 0 ;
33345 PyObject * obj1 = 0 ;
33346 PyObject * obj2 = 0 ;
33347 PyObject * obj3 = 0 ;
33348 char * kwnames[] = {
33349 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33350 };
33351
33352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33354 if (!SWIG_IsOK(res1)) {
33355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33356 }
33357 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33358 ecode2 = SWIG_AsVal_int(obj1, &val2);
33359 if (!SWIG_IsOK(ecode2)) {
33360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33361 }
33362 arg2 = static_cast< int >(val2);
33363 ecode3 = SWIG_AsVal_int(obj2, &val3);
33364 if (!SWIG_IsOK(ecode3)) {
33365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33366 }
33367 arg3 = static_cast< int >(val3);
33368 ecode4 = SWIG_AsVal_int(obj3, &val4);
33369 if (!SWIG_IsOK(ecode4)) {
33370 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33371 }
33372 arg4 = static_cast< wxDragResult >(val4);
33373 {
33374 PyThreadState* __tstate = wxPyBeginAllowThreads();
33375 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33376 wxPyEndAllowThreads(__tstate);
33377 if (PyErr_Occurred()) SWIG_fail;
33378 }
33379 resultobj = SWIG_From_int(static_cast< int >(result));
33380 return resultobj;
33381 fail:
33382 return NULL;
33383 }
33384
33385
33386 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33387 PyObject *resultobj = 0;
33388 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33389 int arg2 ;
33390 int arg3 ;
33391 wxDragResult arg4 ;
33392 wxDragResult result;
33393 void *argp1 = 0 ;
33394 int res1 = 0 ;
33395 int val2 ;
33396 int ecode2 = 0 ;
33397 int val3 ;
33398 int ecode3 = 0 ;
33399 int val4 ;
33400 int ecode4 = 0 ;
33401 PyObject * obj0 = 0 ;
33402 PyObject * obj1 = 0 ;
33403 PyObject * obj2 = 0 ;
33404 PyObject * obj3 = 0 ;
33405 char * kwnames[] = {
33406 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33407 };
33408
33409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33411 if (!SWIG_IsOK(res1)) {
33412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33413 }
33414 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33415 ecode2 = SWIG_AsVal_int(obj1, &val2);
33416 if (!SWIG_IsOK(ecode2)) {
33417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33418 }
33419 arg2 = static_cast< int >(val2);
33420 ecode3 = SWIG_AsVal_int(obj2, &val3);
33421 if (!SWIG_IsOK(ecode3)) {
33422 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33423 }
33424 arg3 = static_cast< int >(val3);
33425 ecode4 = SWIG_AsVal_int(obj3, &val4);
33426 if (!SWIG_IsOK(ecode4)) {
33427 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33428 }
33429 arg4 = static_cast< wxDragResult >(val4);
33430 {
33431 PyThreadState* __tstate = wxPyBeginAllowThreads();
33432 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33433 wxPyEndAllowThreads(__tstate);
33434 if (PyErr_Occurred()) SWIG_fail;
33435 }
33436 resultobj = SWIG_From_int(static_cast< int >(result));
33437 return resultobj;
33438 fail:
33439 return NULL;
33440 }
33441
33442
33443 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33444 PyObject *resultobj = 0;
33445 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33446 void *argp1 = 0 ;
33447 int res1 = 0 ;
33448 PyObject *swig_obj[1] ;
33449
33450 if (!args) SWIG_fail;
33451 swig_obj[0] = args;
33452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33453 if (!SWIG_IsOK(res1)) {
33454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33455 }
33456 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33457 {
33458 PyThreadState* __tstate = wxPyBeginAllowThreads();
33459 (arg1)->OnLeave();
33460 wxPyEndAllowThreads(__tstate);
33461 if (PyErr_Occurred()) SWIG_fail;
33462 }
33463 resultobj = SWIG_Py_Void();
33464 return resultobj;
33465 fail:
33466 return NULL;
33467 }
33468
33469
33470 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33471 PyObject *resultobj = 0;
33472 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33473 int arg2 ;
33474 int arg3 ;
33475 bool result;
33476 void *argp1 = 0 ;
33477 int res1 = 0 ;
33478 int val2 ;
33479 int ecode2 = 0 ;
33480 int val3 ;
33481 int ecode3 = 0 ;
33482 PyObject * obj0 = 0 ;
33483 PyObject * obj1 = 0 ;
33484 PyObject * obj2 = 0 ;
33485 char * kwnames[] = {
33486 (char *) "self",(char *) "x",(char *) "y", NULL
33487 };
33488
33489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33491 if (!SWIG_IsOK(res1)) {
33492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33493 }
33494 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33495 ecode2 = SWIG_AsVal_int(obj1, &val2);
33496 if (!SWIG_IsOK(ecode2)) {
33497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33498 }
33499 arg2 = static_cast< int >(val2);
33500 ecode3 = SWIG_AsVal_int(obj2, &val3);
33501 if (!SWIG_IsOK(ecode3)) {
33502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33503 }
33504 arg3 = static_cast< int >(val3);
33505 {
33506 PyThreadState* __tstate = wxPyBeginAllowThreads();
33507 result = (bool)(arg1)->OnDrop(arg2,arg3);
33508 wxPyEndAllowThreads(__tstate);
33509 if (PyErr_Occurred()) SWIG_fail;
33510 }
33511 {
33512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33513 }
33514 return resultobj;
33515 fail:
33516 return NULL;
33517 }
33518
33519
33520 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33521 PyObject *resultobj = 0;
33522 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33523 int arg2 ;
33524 int arg3 ;
33525 wxDragResult arg4 ;
33526 wxDragResult result;
33527 void *argp1 = 0 ;
33528 int res1 = 0 ;
33529 int val2 ;
33530 int ecode2 = 0 ;
33531 int val3 ;
33532 int ecode3 = 0 ;
33533 int val4 ;
33534 int ecode4 = 0 ;
33535 PyObject * obj0 = 0 ;
33536 PyObject * obj1 = 0 ;
33537 PyObject * obj2 = 0 ;
33538 PyObject * obj3 = 0 ;
33539 char * kwnames[] = {
33540 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33541 };
33542
33543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33545 if (!SWIG_IsOK(res1)) {
33546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33547 }
33548 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33549 ecode2 = SWIG_AsVal_int(obj1, &val2);
33550 if (!SWIG_IsOK(ecode2)) {
33551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33552 }
33553 arg2 = static_cast< int >(val2);
33554 ecode3 = SWIG_AsVal_int(obj2, &val3);
33555 if (!SWIG_IsOK(ecode3)) {
33556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33557 }
33558 arg3 = static_cast< int >(val3);
33559 ecode4 = SWIG_AsVal_int(obj3, &val4);
33560 if (!SWIG_IsOK(ecode4)) {
33561 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33562 }
33563 arg4 = static_cast< wxDragResult >(val4);
33564 {
33565 PyThreadState* __tstate = wxPyBeginAllowThreads();
33566 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33567 wxPyEndAllowThreads(__tstate);
33568 if (PyErr_Occurred()) SWIG_fail;
33569 }
33570 resultobj = SWIG_From_int(static_cast< int >(result));
33571 return resultobj;
33572 fail:
33573 return NULL;
33574 }
33575
33576
33577 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33578 PyObject *obj;
33579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33580 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
33581 return SWIG_Py_Void();
33582 }
33583
33584 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33585 return SWIG_Python_InitShadowInstance(args);
33586 }
33587
33588 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33589 PyObject *resultobj = 0;
33590 wxPyFileDropTarget *result = 0 ;
33591
33592 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
33593 {
33594 PyThreadState* __tstate = wxPyBeginAllowThreads();
33595 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
33596 wxPyEndAllowThreads(__tstate);
33597 if (PyErr_Occurred()) SWIG_fail;
33598 }
33599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
33600 return resultobj;
33601 fail:
33602 return NULL;
33603 }
33604
33605
33606 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33607 PyObject *resultobj = 0;
33608 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33609 PyObject *arg2 = (PyObject *) 0 ;
33610 PyObject *arg3 = (PyObject *) 0 ;
33611 void *argp1 = 0 ;
33612 int res1 = 0 ;
33613 PyObject * obj0 = 0 ;
33614 PyObject * obj1 = 0 ;
33615 PyObject * obj2 = 0 ;
33616 char * kwnames[] = {
33617 (char *) "self",(char *) "self",(char *) "_class", NULL
33618 };
33619
33620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33622 if (!SWIG_IsOK(res1)) {
33623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33624 }
33625 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33626 arg2 = obj1;
33627 arg3 = obj2;
33628 {
33629 PyThreadState* __tstate = wxPyBeginAllowThreads();
33630 (arg1)->_setCallbackInfo(arg2,arg3);
33631 wxPyEndAllowThreads(__tstate);
33632 if (PyErr_Occurred()) SWIG_fail;
33633 }
33634 resultobj = SWIG_Py_Void();
33635 return resultobj;
33636 fail:
33637 return NULL;
33638 }
33639
33640
33641 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33642 PyObject *resultobj = 0;
33643 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33644 int arg2 ;
33645 int arg3 ;
33646 wxArrayString *arg4 = 0 ;
33647 bool result;
33648 void *argp1 = 0 ;
33649 int res1 = 0 ;
33650 int val2 ;
33651 int ecode2 = 0 ;
33652 int val3 ;
33653 int ecode3 = 0 ;
33654 bool temp4 = false ;
33655 PyObject * obj0 = 0 ;
33656 PyObject * obj1 = 0 ;
33657 PyObject * obj2 = 0 ;
33658 PyObject * obj3 = 0 ;
33659 char * kwnames[] = {
33660 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
33661 };
33662
33663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33665 if (!SWIG_IsOK(res1)) {
33666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33667 }
33668 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33669 ecode2 = SWIG_AsVal_int(obj1, &val2);
33670 if (!SWIG_IsOK(ecode2)) {
33671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
33672 }
33673 arg2 = static_cast< int >(val2);
33674 ecode3 = SWIG_AsVal_int(obj2, &val3);
33675 if (!SWIG_IsOK(ecode3)) {
33676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
33677 }
33678 arg3 = static_cast< int >(val3);
33679 {
33680 if (! PySequence_Check(obj3)) {
33681 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
33682 SWIG_fail;
33683 }
33684 arg4 = new wxArrayString;
33685 temp4 = true;
33686 int i, len=PySequence_Length(obj3);
33687 for (i=0; i<len; i++) {
33688 PyObject* item = PySequence_GetItem(obj3, i);
33689 wxString* s = wxString_in_helper(item);
33690 if (PyErr_Occurred()) SWIG_fail;
33691 arg4->Add(*s);
33692 delete s;
33693 Py_DECREF(item);
33694 }
33695 }
33696 {
33697 PyThreadState* __tstate = wxPyBeginAllowThreads();
33698 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
33699 wxPyEndAllowThreads(__tstate);
33700 if (PyErr_Occurred()) SWIG_fail;
33701 }
33702 {
33703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33704 }
33705 {
33706 if (temp4) delete arg4;
33707 }
33708 return resultobj;
33709 fail:
33710 {
33711 if (temp4) delete arg4;
33712 }
33713 return NULL;
33714 }
33715
33716
33717 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33718 PyObject *resultobj = 0;
33719 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33720 int arg2 ;
33721 int arg3 ;
33722 wxDragResult arg4 ;
33723 wxDragResult result;
33724 void *argp1 = 0 ;
33725 int res1 = 0 ;
33726 int val2 ;
33727 int ecode2 = 0 ;
33728 int val3 ;
33729 int ecode3 = 0 ;
33730 int val4 ;
33731 int ecode4 = 0 ;
33732 PyObject * obj0 = 0 ;
33733 PyObject * obj1 = 0 ;
33734 PyObject * obj2 = 0 ;
33735 PyObject * obj3 = 0 ;
33736 char * kwnames[] = {
33737 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33738 };
33739
33740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33742 if (!SWIG_IsOK(res1)) {
33743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33744 }
33745 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33746 ecode2 = SWIG_AsVal_int(obj1, &val2);
33747 if (!SWIG_IsOK(ecode2)) {
33748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33749 }
33750 arg2 = static_cast< int >(val2);
33751 ecode3 = SWIG_AsVal_int(obj2, &val3);
33752 if (!SWIG_IsOK(ecode3)) {
33753 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33754 }
33755 arg3 = static_cast< int >(val3);
33756 ecode4 = SWIG_AsVal_int(obj3, &val4);
33757 if (!SWIG_IsOK(ecode4)) {
33758 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33759 }
33760 arg4 = static_cast< wxDragResult >(val4);
33761 {
33762 PyThreadState* __tstate = wxPyBeginAllowThreads();
33763 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33764 wxPyEndAllowThreads(__tstate);
33765 if (PyErr_Occurred()) SWIG_fail;
33766 }
33767 resultobj = SWIG_From_int(static_cast< int >(result));
33768 return resultobj;
33769 fail:
33770 return NULL;
33771 }
33772
33773
33774 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33775 PyObject *resultobj = 0;
33776 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33777 int arg2 ;
33778 int arg3 ;
33779 wxDragResult arg4 ;
33780 wxDragResult result;
33781 void *argp1 = 0 ;
33782 int res1 = 0 ;
33783 int val2 ;
33784 int ecode2 = 0 ;
33785 int val3 ;
33786 int ecode3 = 0 ;
33787 int val4 ;
33788 int ecode4 = 0 ;
33789 PyObject * obj0 = 0 ;
33790 PyObject * obj1 = 0 ;
33791 PyObject * obj2 = 0 ;
33792 PyObject * obj3 = 0 ;
33793 char * kwnames[] = {
33794 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33795 };
33796
33797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33799 if (!SWIG_IsOK(res1)) {
33800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33801 }
33802 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33803 ecode2 = SWIG_AsVal_int(obj1, &val2);
33804 if (!SWIG_IsOK(ecode2)) {
33805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33806 }
33807 arg2 = static_cast< int >(val2);
33808 ecode3 = SWIG_AsVal_int(obj2, &val3);
33809 if (!SWIG_IsOK(ecode3)) {
33810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33811 }
33812 arg3 = static_cast< int >(val3);
33813 ecode4 = SWIG_AsVal_int(obj3, &val4);
33814 if (!SWIG_IsOK(ecode4)) {
33815 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33816 }
33817 arg4 = static_cast< wxDragResult >(val4);
33818 {
33819 PyThreadState* __tstate = wxPyBeginAllowThreads();
33820 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33821 wxPyEndAllowThreads(__tstate);
33822 if (PyErr_Occurred()) SWIG_fail;
33823 }
33824 resultobj = SWIG_From_int(static_cast< int >(result));
33825 return resultobj;
33826 fail:
33827 return NULL;
33828 }
33829
33830
33831 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33832 PyObject *resultobj = 0;
33833 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33834 void *argp1 = 0 ;
33835 int res1 = 0 ;
33836 PyObject *swig_obj[1] ;
33837
33838 if (!args) SWIG_fail;
33839 swig_obj[0] = args;
33840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33841 if (!SWIG_IsOK(res1)) {
33842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33843 }
33844 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33845 {
33846 PyThreadState* __tstate = wxPyBeginAllowThreads();
33847 (arg1)->OnLeave();
33848 wxPyEndAllowThreads(__tstate);
33849 if (PyErr_Occurred()) SWIG_fail;
33850 }
33851 resultobj = SWIG_Py_Void();
33852 return resultobj;
33853 fail:
33854 return NULL;
33855 }
33856
33857
33858 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33859 PyObject *resultobj = 0;
33860 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33861 int arg2 ;
33862 int arg3 ;
33863 bool result;
33864 void *argp1 = 0 ;
33865 int res1 = 0 ;
33866 int val2 ;
33867 int ecode2 = 0 ;
33868 int val3 ;
33869 int ecode3 = 0 ;
33870 PyObject * obj0 = 0 ;
33871 PyObject * obj1 = 0 ;
33872 PyObject * obj2 = 0 ;
33873 char * kwnames[] = {
33874 (char *) "self",(char *) "x",(char *) "y", NULL
33875 };
33876
33877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33879 if (!SWIG_IsOK(res1)) {
33880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33881 }
33882 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33883 ecode2 = SWIG_AsVal_int(obj1, &val2);
33884 if (!SWIG_IsOK(ecode2)) {
33885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33886 }
33887 arg2 = static_cast< int >(val2);
33888 ecode3 = SWIG_AsVal_int(obj2, &val3);
33889 if (!SWIG_IsOK(ecode3)) {
33890 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33891 }
33892 arg3 = static_cast< int >(val3);
33893 {
33894 PyThreadState* __tstate = wxPyBeginAllowThreads();
33895 result = (bool)(arg1)->OnDrop(arg2,arg3);
33896 wxPyEndAllowThreads(__tstate);
33897 if (PyErr_Occurred()) SWIG_fail;
33898 }
33899 {
33900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33901 }
33902 return resultobj;
33903 fail:
33904 return NULL;
33905 }
33906
33907
33908 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33909 PyObject *resultobj = 0;
33910 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33911 int arg2 ;
33912 int arg3 ;
33913 wxDragResult arg4 ;
33914 wxDragResult result;
33915 void *argp1 = 0 ;
33916 int res1 = 0 ;
33917 int val2 ;
33918 int ecode2 = 0 ;
33919 int val3 ;
33920 int ecode3 = 0 ;
33921 int val4 ;
33922 int ecode4 = 0 ;
33923 PyObject * obj0 = 0 ;
33924 PyObject * obj1 = 0 ;
33925 PyObject * obj2 = 0 ;
33926 PyObject * obj3 = 0 ;
33927 char * kwnames[] = {
33928 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33929 };
33930
33931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33933 if (!SWIG_IsOK(res1)) {
33934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33935 }
33936 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33937 ecode2 = SWIG_AsVal_int(obj1, &val2);
33938 if (!SWIG_IsOK(ecode2)) {
33939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33940 }
33941 arg2 = static_cast< int >(val2);
33942 ecode3 = SWIG_AsVal_int(obj2, &val3);
33943 if (!SWIG_IsOK(ecode3)) {
33944 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33945 }
33946 arg3 = static_cast< int >(val3);
33947 ecode4 = SWIG_AsVal_int(obj3, &val4);
33948 if (!SWIG_IsOK(ecode4)) {
33949 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33950 }
33951 arg4 = static_cast< wxDragResult >(val4);
33952 {
33953 PyThreadState* __tstate = wxPyBeginAllowThreads();
33954 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33955 wxPyEndAllowThreads(__tstate);
33956 if (PyErr_Occurred()) SWIG_fail;
33957 }
33958 resultobj = SWIG_From_int(static_cast< int >(result));
33959 return resultobj;
33960 fail:
33961 return NULL;
33962 }
33963
33964
33965 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33966 PyObject *obj;
33967 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33968 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
33969 return SWIG_Py_Void();
33970 }
33971
33972 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33973 return SWIG_Python_InitShadowInstance(args);
33974 }
33975
33976 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33977 PyObject *resultobj = 0;
33978 wxClipboard *result = 0 ;
33979
33980 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
33981 {
33982 PyThreadState* __tstate = wxPyBeginAllowThreads();
33983 result = (wxClipboard *)new wxClipboard();
33984 wxPyEndAllowThreads(__tstate);
33985 if (PyErr_Occurred()) SWIG_fail;
33986 }
33987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
33988 return resultobj;
33989 fail:
33990 return NULL;
33991 }
33992
33993
33994 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33995 PyObject *resultobj = 0;
33996 wxClipboard *arg1 = (wxClipboard *) 0 ;
33997 void *argp1 = 0 ;
33998 int res1 = 0 ;
33999 PyObject *swig_obj[1] ;
34000
34001 if (!args) SWIG_fail;
34002 swig_obj[0] = args;
34003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
34004 if (!SWIG_IsOK(res1)) {
34005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
34006 }
34007 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34008 {
34009 PyThreadState* __tstate = wxPyBeginAllowThreads();
34010 delete arg1;
34011
34012 wxPyEndAllowThreads(__tstate);
34013 if (PyErr_Occurred()) SWIG_fail;
34014 }
34015 resultobj = SWIG_Py_Void();
34016 return resultobj;
34017 fail:
34018 return NULL;
34019 }
34020
34021
34022 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34023 PyObject *resultobj = 0;
34024 wxClipboard *arg1 = (wxClipboard *) 0 ;
34025 bool result;
34026 void *argp1 = 0 ;
34027 int res1 = 0 ;
34028 PyObject *swig_obj[1] ;
34029
34030 if (!args) SWIG_fail;
34031 swig_obj[0] = args;
34032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34033 if (!SWIG_IsOK(res1)) {
34034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
34035 }
34036 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34037 {
34038 PyThreadState* __tstate = wxPyBeginAllowThreads();
34039 result = (bool)(arg1)->Open();
34040 wxPyEndAllowThreads(__tstate);
34041 if (PyErr_Occurred()) SWIG_fail;
34042 }
34043 {
34044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34045 }
34046 return resultobj;
34047 fail:
34048 return NULL;
34049 }
34050
34051
34052 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34053 PyObject *resultobj = 0;
34054 wxClipboard *arg1 = (wxClipboard *) 0 ;
34055 void *argp1 = 0 ;
34056 int res1 = 0 ;
34057 PyObject *swig_obj[1] ;
34058
34059 if (!args) SWIG_fail;
34060 swig_obj[0] = args;
34061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34062 if (!SWIG_IsOK(res1)) {
34063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
34064 }
34065 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34066 {
34067 PyThreadState* __tstate = wxPyBeginAllowThreads();
34068 (arg1)->Close();
34069 wxPyEndAllowThreads(__tstate);
34070 if (PyErr_Occurred()) SWIG_fail;
34071 }
34072 resultobj = SWIG_Py_Void();
34073 return resultobj;
34074 fail:
34075 return NULL;
34076 }
34077
34078
34079 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34080 PyObject *resultobj = 0;
34081 wxClipboard *arg1 = (wxClipboard *) 0 ;
34082 bool result;
34083 void *argp1 = 0 ;
34084 int res1 = 0 ;
34085 PyObject *swig_obj[1] ;
34086
34087 if (!args) SWIG_fail;
34088 swig_obj[0] = args;
34089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34090 if (!SWIG_IsOK(res1)) {
34091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
34092 }
34093 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34094 {
34095 PyThreadState* __tstate = wxPyBeginAllowThreads();
34096 result = (bool)((wxClipboard const *)arg1)->IsOpened();
34097 wxPyEndAllowThreads(__tstate);
34098 if (PyErr_Occurred()) SWIG_fail;
34099 }
34100 {
34101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34102 }
34103 return resultobj;
34104 fail:
34105 return NULL;
34106 }
34107
34108
34109 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34110 PyObject *resultobj = 0;
34111 wxClipboard *arg1 = (wxClipboard *) 0 ;
34112 wxDataObject *arg2 = (wxDataObject *) 0 ;
34113 bool result;
34114 void *argp1 = 0 ;
34115 int res1 = 0 ;
34116 int res2 = 0 ;
34117 PyObject * obj0 = 0 ;
34118 PyObject * obj1 = 0 ;
34119 char * kwnames[] = {
34120 (char *) "self",(char *) "data", NULL
34121 };
34122
34123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
34124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34125 if (!SWIG_IsOK(res1)) {
34126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34127 }
34128 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34129 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34130 if (!SWIG_IsOK(res2)) {
34131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34132 }
34133 {
34134 PyThreadState* __tstate = wxPyBeginAllowThreads();
34135 result = (bool)(arg1)->AddData(arg2);
34136 wxPyEndAllowThreads(__tstate);
34137 if (PyErr_Occurred()) SWIG_fail;
34138 }
34139 {
34140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34141 }
34142 return resultobj;
34143 fail:
34144 return NULL;
34145 }
34146
34147
34148 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34149 PyObject *resultobj = 0;
34150 wxClipboard *arg1 = (wxClipboard *) 0 ;
34151 wxDataObject *arg2 = (wxDataObject *) 0 ;
34152 bool result;
34153 void *argp1 = 0 ;
34154 int res1 = 0 ;
34155 int res2 = 0 ;
34156 PyObject * obj0 = 0 ;
34157 PyObject * obj1 = 0 ;
34158 char * kwnames[] = {
34159 (char *) "self",(char *) "data", NULL
34160 };
34161
34162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
34163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34164 if (!SWIG_IsOK(res1)) {
34165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34166 }
34167 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34168 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34169 if (!SWIG_IsOK(res2)) {
34170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34171 }
34172 {
34173 PyThreadState* __tstate = wxPyBeginAllowThreads();
34174 result = (bool)(arg1)->SetData(arg2);
34175 wxPyEndAllowThreads(__tstate);
34176 if (PyErr_Occurred()) SWIG_fail;
34177 }
34178 {
34179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34180 }
34181 return resultobj;
34182 fail:
34183 return NULL;
34184 }
34185
34186
34187 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34188 PyObject *resultobj = 0;
34189 wxClipboard *arg1 = (wxClipboard *) 0 ;
34190 wxDataFormat *arg2 = 0 ;
34191 bool result;
34192 void *argp1 = 0 ;
34193 int res1 = 0 ;
34194 void *argp2 = 0 ;
34195 int res2 = 0 ;
34196 PyObject * obj0 = 0 ;
34197 PyObject * obj1 = 0 ;
34198 char * kwnames[] = {
34199 (char *) "self",(char *) "format", NULL
34200 };
34201
34202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
34203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34204 if (!SWIG_IsOK(res1)) {
34205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
34206 }
34207 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34208 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
34209 if (!SWIG_IsOK(res2)) {
34210 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34211 }
34212 if (!argp2) {
34213 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34214 }
34215 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
34216 {
34217 PyThreadState* __tstate = wxPyBeginAllowThreads();
34218 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
34219 wxPyEndAllowThreads(__tstate);
34220 if (PyErr_Occurred()) SWIG_fail;
34221 }
34222 {
34223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34224 }
34225 return resultobj;
34226 fail:
34227 return NULL;
34228 }
34229
34230
34231 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34232 PyObject *resultobj = 0;
34233 wxClipboard *arg1 = (wxClipboard *) 0 ;
34234 wxDataObject *arg2 = 0 ;
34235 bool result;
34236 void *argp1 = 0 ;
34237 int res1 = 0 ;
34238 void *argp2 = 0 ;
34239 int res2 = 0 ;
34240 PyObject * obj0 = 0 ;
34241 PyObject * obj1 = 0 ;
34242 char * kwnames[] = {
34243 (char *) "self",(char *) "data", NULL
34244 };
34245
34246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
34247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34248 if (!SWIG_IsOK(res1)) {
34249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34250 }
34251 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34252 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34253 if (!SWIG_IsOK(res2)) {
34254 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34255 }
34256 if (!argp2) {
34257 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34258 }
34259 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34260 {
34261 PyThreadState* __tstate = wxPyBeginAllowThreads();
34262 result = (bool)(arg1)->GetData(*arg2);
34263 wxPyEndAllowThreads(__tstate);
34264 if (PyErr_Occurred()) SWIG_fail;
34265 }
34266 {
34267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34268 }
34269 return resultobj;
34270 fail:
34271 return NULL;
34272 }
34273
34274
34275 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34276 PyObject *resultobj = 0;
34277 wxClipboard *arg1 = (wxClipboard *) 0 ;
34278 void *argp1 = 0 ;
34279 int res1 = 0 ;
34280 PyObject *swig_obj[1] ;
34281
34282 if (!args) SWIG_fail;
34283 swig_obj[0] = args;
34284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34285 if (!SWIG_IsOK(res1)) {
34286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
34287 }
34288 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34289 {
34290 PyThreadState* __tstate = wxPyBeginAllowThreads();
34291 (arg1)->Clear();
34292 wxPyEndAllowThreads(__tstate);
34293 if (PyErr_Occurred()) SWIG_fail;
34294 }
34295 resultobj = SWIG_Py_Void();
34296 return resultobj;
34297 fail:
34298 return NULL;
34299 }
34300
34301
34302 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34303 PyObject *resultobj = 0;
34304 wxClipboard *arg1 = (wxClipboard *) 0 ;
34305 bool result;
34306 void *argp1 = 0 ;
34307 int res1 = 0 ;
34308 PyObject *swig_obj[1] ;
34309
34310 if (!args) SWIG_fail;
34311 swig_obj[0] = args;
34312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34313 if (!SWIG_IsOK(res1)) {
34314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
34315 }
34316 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34317 {
34318 PyThreadState* __tstate = wxPyBeginAllowThreads();
34319 result = (bool)(arg1)->Flush();
34320 wxPyEndAllowThreads(__tstate);
34321 if (PyErr_Occurred()) SWIG_fail;
34322 }
34323 {
34324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34325 }
34326 return resultobj;
34327 fail:
34328 return NULL;
34329 }
34330
34331
34332 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34333 PyObject *resultobj = 0;
34334 wxClipboard *arg1 = (wxClipboard *) 0 ;
34335 bool arg2 = (bool) true ;
34336 void *argp1 = 0 ;
34337 int res1 = 0 ;
34338 bool val2 ;
34339 int ecode2 = 0 ;
34340 PyObject * obj0 = 0 ;
34341 PyObject * obj1 = 0 ;
34342 char * kwnames[] = {
34343 (char *) "self",(char *) "primary", NULL
34344 };
34345
34346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
34347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34348 if (!SWIG_IsOK(res1)) {
34349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
34350 }
34351 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34352 if (obj1) {
34353 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34354 if (!SWIG_IsOK(ecode2)) {
34355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
34356 }
34357 arg2 = static_cast< bool >(val2);
34358 }
34359 {
34360 PyThreadState* __tstate = wxPyBeginAllowThreads();
34361 (arg1)->UsePrimarySelection(arg2);
34362 wxPyEndAllowThreads(__tstate);
34363 if (PyErr_Occurred()) SWIG_fail;
34364 }
34365 resultobj = SWIG_Py_Void();
34366 return resultobj;
34367 fail:
34368 return NULL;
34369 }
34370
34371
34372 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34373 PyObject *resultobj = 0;
34374 wxClipboard *result = 0 ;
34375
34376 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
34377 {
34378 PyThreadState* __tstate = wxPyBeginAllowThreads();
34379 result = (wxClipboard *)wxClipboard::Get();
34380 wxPyEndAllowThreads(__tstate);
34381 if (PyErr_Occurred()) SWIG_fail;
34382 }
34383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
34384 return resultobj;
34385 fail:
34386 return NULL;
34387 }
34388
34389
34390 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34391 PyObject *obj;
34392 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34393 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
34394 return SWIG_Py_Void();
34395 }
34396
34397 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34398 return SWIG_Python_InitShadowInstance(args);
34399 }
34400
34401 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34402 PyObject *resultobj = 0;
34403 wxClipboard *arg1 = (wxClipboard *) NULL ;
34404 wxClipboardLocker *result = 0 ;
34405 void *argp1 = 0 ;
34406 int res1 = 0 ;
34407 PyObject * obj0 = 0 ;
34408 char * kwnames[] = {
34409 (char *) "clipboard", NULL
34410 };
34411
34412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
34413 if (obj0) {
34414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34415 if (!SWIG_IsOK(res1)) {
34416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
34417 }
34418 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34419 }
34420 {
34421 PyThreadState* __tstate = wxPyBeginAllowThreads();
34422 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
34423 wxPyEndAllowThreads(__tstate);
34424 if (PyErr_Occurred()) SWIG_fail;
34425 }
34426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
34427 return resultobj;
34428 fail:
34429 return NULL;
34430 }
34431
34432
34433 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34434 PyObject *resultobj = 0;
34435 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34436 void *argp1 = 0 ;
34437 int res1 = 0 ;
34438 PyObject *swig_obj[1] ;
34439
34440 if (!args) SWIG_fail;
34441 swig_obj[0] = args;
34442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
34443 if (!SWIG_IsOK(res1)) {
34444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34445 }
34446 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34447 {
34448 PyThreadState* __tstate = wxPyBeginAllowThreads();
34449 delete arg1;
34450
34451 wxPyEndAllowThreads(__tstate);
34452 if (PyErr_Occurred()) SWIG_fail;
34453 }
34454 resultobj = SWIG_Py_Void();
34455 return resultobj;
34456 fail:
34457 return NULL;
34458 }
34459
34460
34461 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34462 PyObject *resultobj = 0;
34463 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34464 bool result;
34465 void *argp1 = 0 ;
34466 int res1 = 0 ;
34467 PyObject *swig_obj[1] ;
34468
34469 if (!args) SWIG_fail;
34470 swig_obj[0] = args;
34471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
34472 if (!SWIG_IsOK(res1)) {
34473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34474 }
34475 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34476 {
34477 PyThreadState* __tstate = wxPyBeginAllowThreads();
34478 result = (bool)wxClipboardLocker___nonzero__(arg1);
34479 wxPyEndAllowThreads(__tstate);
34480 if (PyErr_Occurred()) SWIG_fail;
34481 }
34482 {
34483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34484 }
34485 return resultobj;
34486 fail:
34487 return NULL;
34488 }
34489
34490
34491 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34492 PyObject *obj;
34493 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34494 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
34495 return SWIG_Py_Void();
34496 }
34497
34498 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34499 return SWIG_Python_InitShadowInstance(args);
34500 }
34501
34502 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34503 PyObject *resultobj = 0;
34504 int arg1 = (int) 0 ;
34505 int arg2 = (int) 0 ;
34506 int arg3 = (int) 0 ;
34507 int arg4 = (int) 0 ;
34508 wxVideoMode *result = 0 ;
34509 int val1 ;
34510 int ecode1 = 0 ;
34511 int val2 ;
34512 int ecode2 = 0 ;
34513 int val3 ;
34514 int ecode3 = 0 ;
34515 int val4 ;
34516 int ecode4 = 0 ;
34517 PyObject * obj0 = 0 ;
34518 PyObject * obj1 = 0 ;
34519 PyObject * obj2 = 0 ;
34520 PyObject * obj3 = 0 ;
34521 char * kwnames[] = {
34522 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
34523 };
34524
34525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34526 if (obj0) {
34527 ecode1 = SWIG_AsVal_int(obj0, &val1);
34528 if (!SWIG_IsOK(ecode1)) {
34529 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
34530 }
34531 arg1 = static_cast< int >(val1);
34532 }
34533 if (obj1) {
34534 ecode2 = SWIG_AsVal_int(obj1, &val2);
34535 if (!SWIG_IsOK(ecode2)) {
34536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
34537 }
34538 arg2 = static_cast< int >(val2);
34539 }
34540 if (obj2) {
34541 ecode3 = SWIG_AsVal_int(obj2, &val3);
34542 if (!SWIG_IsOK(ecode3)) {
34543 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
34544 }
34545 arg3 = static_cast< int >(val3);
34546 }
34547 if (obj3) {
34548 ecode4 = SWIG_AsVal_int(obj3, &val4);
34549 if (!SWIG_IsOK(ecode4)) {
34550 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
34551 }
34552 arg4 = static_cast< int >(val4);
34553 }
34554 {
34555 PyThreadState* __tstate = wxPyBeginAllowThreads();
34556 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
34557 wxPyEndAllowThreads(__tstate);
34558 if (PyErr_Occurred()) SWIG_fail;
34559 }
34560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
34561 return resultobj;
34562 fail:
34563 return NULL;
34564 }
34565
34566
34567 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34568 PyObject *resultobj = 0;
34569 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34570 void *argp1 = 0 ;
34571 int res1 = 0 ;
34572 PyObject *swig_obj[1] ;
34573
34574 if (!args) SWIG_fail;
34575 swig_obj[0] = args;
34576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
34577 if (!SWIG_IsOK(res1)) {
34578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34579 }
34580 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34581 {
34582 PyThreadState* __tstate = wxPyBeginAllowThreads();
34583 delete arg1;
34584
34585 wxPyEndAllowThreads(__tstate);
34586 if (PyErr_Occurred()) SWIG_fail;
34587 }
34588 resultobj = SWIG_Py_Void();
34589 return resultobj;
34590 fail:
34591 return NULL;
34592 }
34593
34594
34595 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34596 PyObject *resultobj = 0;
34597 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34598 wxVideoMode *arg2 = 0 ;
34599 bool result;
34600 void *argp1 = 0 ;
34601 int res1 = 0 ;
34602 void *argp2 = 0 ;
34603 int res2 = 0 ;
34604 PyObject * obj0 = 0 ;
34605 PyObject * obj1 = 0 ;
34606 char * kwnames[] = {
34607 (char *) "self",(char *) "other", NULL
34608 };
34609
34610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
34611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34612 if (!SWIG_IsOK(res1)) {
34613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34614 }
34615 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34616 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
34617 if (!SWIG_IsOK(res2)) {
34618 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34619 }
34620 if (!argp2) {
34621 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34622 }
34623 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34624 {
34625 PyThreadState* __tstate = wxPyBeginAllowThreads();
34626 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
34627 wxPyEndAllowThreads(__tstate);
34628 if (PyErr_Occurred()) SWIG_fail;
34629 }
34630 {
34631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34632 }
34633 return resultobj;
34634 fail:
34635 return NULL;
34636 }
34637
34638
34639 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34640 PyObject *resultobj = 0;
34641 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34642 int result;
34643 void *argp1 = 0 ;
34644 int res1 = 0 ;
34645 PyObject *swig_obj[1] ;
34646
34647 if (!args) SWIG_fail;
34648 swig_obj[0] = args;
34649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34650 if (!SWIG_IsOK(res1)) {
34651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34652 }
34653 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34654 {
34655 PyThreadState* __tstate = wxPyBeginAllowThreads();
34656 result = (int)((wxVideoMode const *)arg1)->GetWidth();
34657 wxPyEndAllowThreads(__tstate);
34658 if (PyErr_Occurred()) SWIG_fail;
34659 }
34660 resultobj = SWIG_From_int(static_cast< int >(result));
34661 return resultobj;
34662 fail:
34663 return NULL;
34664 }
34665
34666
34667 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34668 PyObject *resultobj = 0;
34669 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34670 int result;
34671 void *argp1 = 0 ;
34672 int res1 = 0 ;
34673 PyObject *swig_obj[1] ;
34674
34675 if (!args) SWIG_fail;
34676 swig_obj[0] = args;
34677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34678 if (!SWIG_IsOK(res1)) {
34679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34680 }
34681 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34682 {
34683 PyThreadState* __tstate = wxPyBeginAllowThreads();
34684 result = (int)((wxVideoMode const *)arg1)->GetHeight();
34685 wxPyEndAllowThreads(__tstate);
34686 if (PyErr_Occurred()) SWIG_fail;
34687 }
34688 resultobj = SWIG_From_int(static_cast< int >(result));
34689 return resultobj;
34690 fail:
34691 return NULL;
34692 }
34693
34694
34695 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34696 PyObject *resultobj = 0;
34697 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34698 int result;
34699 void *argp1 = 0 ;
34700 int res1 = 0 ;
34701 PyObject *swig_obj[1] ;
34702
34703 if (!args) SWIG_fail;
34704 swig_obj[0] = args;
34705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34706 if (!SWIG_IsOK(res1)) {
34707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34708 }
34709 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34710 {
34711 PyThreadState* __tstate = wxPyBeginAllowThreads();
34712 result = (int)((wxVideoMode const *)arg1)->GetDepth();
34713 wxPyEndAllowThreads(__tstate);
34714 if (PyErr_Occurred()) SWIG_fail;
34715 }
34716 resultobj = SWIG_From_int(static_cast< int >(result));
34717 return resultobj;
34718 fail:
34719 return NULL;
34720 }
34721
34722
34723 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34724 PyObject *resultobj = 0;
34725 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34726 bool result;
34727 void *argp1 = 0 ;
34728 int res1 = 0 ;
34729 PyObject *swig_obj[1] ;
34730
34731 if (!args) SWIG_fail;
34732 swig_obj[0] = args;
34733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34734 if (!SWIG_IsOK(res1)) {
34735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34736 }
34737 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34738 {
34739 PyThreadState* __tstate = wxPyBeginAllowThreads();
34740 result = (bool)((wxVideoMode const *)arg1)->IsOk();
34741 wxPyEndAllowThreads(__tstate);
34742 if (PyErr_Occurred()) SWIG_fail;
34743 }
34744 {
34745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34746 }
34747 return resultobj;
34748 fail:
34749 return NULL;
34750 }
34751
34752
34753 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34754 PyObject *resultobj = 0;
34755 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34756 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34757 bool result;
34758 void *argp1 = 0 ;
34759 int res1 = 0 ;
34760 void *argp2 = 0 ;
34761 int res2 = 0 ;
34762 PyObject * obj0 = 0 ;
34763 PyObject * obj1 = 0 ;
34764 char * kwnames[] = {
34765 (char *) "self",(char *) "other", NULL
34766 };
34767
34768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
34769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34770 if (!SWIG_IsOK(res1)) {
34771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34772 }
34773 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34774 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34775 if (!SWIG_IsOK(res2)) {
34776 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34777 }
34778 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34779 {
34780 PyThreadState* __tstate = wxPyBeginAllowThreads();
34781 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
34782 wxPyEndAllowThreads(__tstate);
34783 if (PyErr_Occurred()) SWIG_fail;
34784 }
34785 {
34786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34787 }
34788 return resultobj;
34789 fail:
34790 return NULL;
34791 }
34792
34793
34794 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34795 PyObject *resultobj = 0;
34796 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34797 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34798 bool result;
34799 void *argp1 = 0 ;
34800 int res1 = 0 ;
34801 void *argp2 = 0 ;
34802 int res2 = 0 ;
34803 PyObject * obj0 = 0 ;
34804 PyObject * obj1 = 0 ;
34805 char * kwnames[] = {
34806 (char *) "self",(char *) "other", NULL
34807 };
34808
34809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
34810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34811 if (!SWIG_IsOK(res1)) {
34812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34813 }
34814 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34815 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34816 if (!SWIG_IsOK(res2)) {
34817 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34818 }
34819 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34820 {
34821 PyThreadState* __tstate = wxPyBeginAllowThreads();
34822 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
34823 wxPyEndAllowThreads(__tstate);
34824 if (PyErr_Occurred()) SWIG_fail;
34825 }
34826 {
34827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34828 }
34829 return resultobj;
34830 fail:
34831 return NULL;
34832 }
34833
34834
34835 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34836 PyObject *resultobj = 0;
34837 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34838 int arg2 ;
34839 void *argp1 = 0 ;
34840 int res1 = 0 ;
34841 int val2 ;
34842 int ecode2 = 0 ;
34843 PyObject *swig_obj[2] ;
34844
34845 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
34846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34847 if (!SWIG_IsOK(res1)) {
34848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34849 }
34850 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34851 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34852 if (!SWIG_IsOK(ecode2)) {
34853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
34854 }
34855 arg2 = static_cast< int >(val2);
34856 if (arg1) (arg1)->w = arg2;
34857
34858 resultobj = SWIG_Py_Void();
34859 return resultobj;
34860 fail:
34861 return NULL;
34862 }
34863
34864
34865 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34866 PyObject *resultobj = 0;
34867 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34868 int result;
34869 void *argp1 = 0 ;
34870 int res1 = 0 ;
34871 PyObject *swig_obj[1] ;
34872
34873 if (!args) SWIG_fail;
34874 swig_obj[0] = args;
34875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34876 if (!SWIG_IsOK(res1)) {
34877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34878 }
34879 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34880 result = (int) ((arg1)->w);
34881 resultobj = SWIG_From_int(static_cast< int >(result));
34882 return resultobj;
34883 fail:
34884 return NULL;
34885 }
34886
34887
34888 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34889 PyObject *resultobj = 0;
34890 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34891 int arg2 ;
34892 void *argp1 = 0 ;
34893 int res1 = 0 ;
34894 int val2 ;
34895 int ecode2 = 0 ;
34896 PyObject *swig_obj[2] ;
34897
34898 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
34899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34900 if (!SWIG_IsOK(res1)) {
34901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34902 }
34903 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34904 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34905 if (!SWIG_IsOK(ecode2)) {
34906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
34907 }
34908 arg2 = static_cast< int >(val2);
34909 if (arg1) (arg1)->h = arg2;
34910
34911 resultobj = SWIG_Py_Void();
34912 return resultobj;
34913 fail:
34914 return NULL;
34915 }
34916
34917
34918 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34919 PyObject *resultobj = 0;
34920 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34921 int result;
34922 void *argp1 = 0 ;
34923 int res1 = 0 ;
34924 PyObject *swig_obj[1] ;
34925
34926 if (!args) SWIG_fail;
34927 swig_obj[0] = args;
34928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34929 if (!SWIG_IsOK(res1)) {
34930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34931 }
34932 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34933 result = (int) ((arg1)->h);
34934 resultobj = SWIG_From_int(static_cast< int >(result));
34935 return resultobj;
34936 fail:
34937 return NULL;
34938 }
34939
34940
34941 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34942 PyObject *resultobj = 0;
34943 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34944 int arg2 ;
34945 void *argp1 = 0 ;
34946 int res1 = 0 ;
34947 int val2 ;
34948 int ecode2 = 0 ;
34949 PyObject *swig_obj[2] ;
34950
34951 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
34952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34953 if (!SWIG_IsOK(res1)) {
34954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34955 }
34956 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34957 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34958 if (!SWIG_IsOK(ecode2)) {
34959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
34960 }
34961 arg2 = static_cast< int >(val2);
34962 if (arg1) (arg1)->bpp = arg2;
34963
34964 resultobj = SWIG_Py_Void();
34965 return resultobj;
34966 fail:
34967 return NULL;
34968 }
34969
34970
34971 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34972 PyObject *resultobj = 0;
34973 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34974 int result;
34975 void *argp1 = 0 ;
34976 int res1 = 0 ;
34977 PyObject *swig_obj[1] ;
34978
34979 if (!args) SWIG_fail;
34980 swig_obj[0] = args;
34981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34982 if (!SWIG_IsOK(res1)) {
34983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34984 }
34985 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34986 result = (int) ((arg1)->bpp);
34987 resultobj = SWIG_From_int(static_cast< int >(result));
34988 return resultobj;
34989 fail:
34990 return NULL;
34991 }
34992
34993
34994 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34995 PyObject *resultobj = 0;
34996 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34997 int arg2 ;
34998 void *argp1 = 0 ;
34999 int res1 = 0 ;
35000 int val2 ;
35001 int ecode2 = 0 ;
35002 PyObject *swig_obj[2] ;
35003
35004 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
35005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35006 if (!SWIG_IsOK(res1)) {
35007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35008 }
35009 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35010 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35011 if (!SWIG_IsOK(ecode2)) {
35012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
35013 }
35014 arg2 = static_cast< int >(val2);
35015 if (arg1) (arg1)->refresh = arg2;
35016
35017 resultobj = SWIG_Py_Void();
35018 return resultobj;
35019 fail:
35020 return NULL;
35021 }
35022
35023
35024 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35025 PyObject *resultobj = 0;
35026 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35027 int result;
35028 void *argp1 = 0 ;
35029 int res1 = 0 ;
35030 PyObject *swig_obj[1] ;
35031
35032 if (!args) SWIG_fail;
35033 swig_obj[0] = args;
35034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35035 if (!SWIG_IsOK(res1)) {
35036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35037 }
35038 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35039 result = (int) ((arg1)->refresh);
35040 resultobj = SWIG_From_int(static_cast< int >(result));
35041 return resultobj;
35042 fail:
35043 return NULL;
35044 }
35045
35046
35047 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35048 PyObject *obj;
35049 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35050 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
35051 return SWIG_Py_Void();
35052 }
35053
35054 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35055 return SWIG_Python_InitShadowInstance(args);
35056 }
35057
35058 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
35059 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
35060 return 1;
35061 }
35062
35063
35064 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
35065 PyObject *pyobj = 0;
35066
35067 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
35068 return pyobj;
35069 }
35070
35071
35072 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35073 PyObject *resultobj = 0;
35074 size_t arg1 = (size_t) 0 ;
35075 wxDisplay *result = 0 ;
35076 size_t val1 ;
35077 int ecode1 = 0 ;
35078 PyObject * obj0 = 0 ;
35079 char * kwnames[] = {
35080 (char *) "index", NULL
35081 };
35082
35083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
35084 if (obj0) {
35085 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
35086 if (!SWIG_IsOK(ecode1)) {
35087 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
35088 }
35089 arg1 = static_cast< size_t >(val1);
35090 }
35091 {
35092 PyThreadState* __tstate = wxPyBeginAllowThreads();
35093 result = (wxDisplay *)new wxDisplay(arg1);
35094 wxPyEndAllowThreads(__tstate);
35095 if (PyErr_Occurred()) SWIG_fail;
35096 }
35097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
35098 return resultobj;
35099 fail:
35100 return NULL;
35101 }
35102
35103
35104 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35105 PyObject *resultobj = 0;
35106 wxDisplay *arg1 = (wxDisplay *) 0 ;
35107 void *argp1 = 0 ;
35108 int res1 = 0 ;
35109 PyObject *swig_obj[1] ;
35110
35111 if (!args) SWIG_fail;
35112 swig_obj[0] = args;
35113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
35114 if (!SWIG_IsOK(res1)) {
35115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
35116 }
35117 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35118 {
35119 PyThreadState* __tstate = wxPyBeginAllowThreads();
35120 delete arg1;
35121
35122 wxPyEndAllowThreads(__tstate);
35123 if (PyErr_Occurred()) SWIG_fail;
35124 }
35125 resultobj = SWIG_Py_Void();
35126 return resultobj;
35127 fail:
35128 return NULL;
35129 }
35130
35131
35132 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35133 PyObject *resultobj = 0;
35134 size_t result;
35135
35136 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
35137 {
35138 PyThreadState* __tstate = wxPyBeginAllowThreads();
35139 result = (size_t)wxDisplay::GetCount();
35140 wxPyEndAllowThreads(__tstate);
35141 if (PyErr_Occurred()) SWIG_fail;
35142 }
35143 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
35144 return resultobj;
35145 fail:
35146 return NULL;
35147 }
35148
35149
35150 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35151 PyObject *resultobj = 0;
35152 wxPoint *arg1 = 0 ;
35153 int result;
35154 wxPoint temp1 ;
35155 PyObject * obj0 = 0 ;
35156 char * kwnames[] = {
35157 (char *) "pt", NULL
35158 };
35159
35160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
35161 {
35162 arg1 = &temp1;
35163 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
35164 }
35165 {
35166 PyThreadState* __tstate = wxPyBeginAllowThreads();
35167 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*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_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35179 PyObject *resultobj = 0;
35180 wxWindow *arg1 = (wxWindow *) 0 ;
35181 int result;
35182 void *argp1 = 0 ;
35183 int res1 = 0 ;
35184 PyObject * obj0 = 0 ;
35185 char * kwnames[] = {
35186 (char *) "window", NULL
35187 };
35188
35189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
35190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35191 if (!SWIG_IsOK(res1)) {
35192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
35193 }
35194 arg1 = reinterpret_cast< wxWindow * >(argp1);
35195 {
35196 PyThreadState* __tstate = wxPyBeginAllowThreads();
35197 result = (int)wxDisplay::GetFromWindow(arg1);
35198 wxPyEndAllowThreads(__tstate);
35199 if (PyErr_Occurred()) SWIG_fail;
35200 }
35201 resultobj = SWIG_From_int(static_cast< int >(result));
35202 return resultobj;
35203 fail:
35204 return NULL;
35205 }
35206
35207
35208 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35209 PyObject *resultobj = 0;
35210 wxDisplay *arg1 = (wxDisplay *) 0 ;
35211 bool 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_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35221 }
35222 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35223 {
35224 PyThreadState* __tstate = wxPyBeginAllowThreads();
35225 result = (bool)((wxDisplay const *)arg1)->IsOk();
35226 wxPyEndAllowThreads(__tstate);
35227 if (PyErr_Occurred()) SWIG_fail;
35228 }
35229 {
35230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35231 }
35232 return resultobj;
35233 fail:
35234 return NULL;
35235 }
35236
35237
35238 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35239 PyObject *resultobj = 0;
35240 wxDisplay *arg1 = (wxDisplay *) 0 ;
35241 wxRect result;
35242 void *argp1 = 0 ;
35243 int res1 = 0 ;
35244 PyObject *swig_obj[1] ;
35245
35246 if (!args) SWIG_fail;
35247 swig_obj[0] = args;
35248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35249 if (!SWIG_IsOK(res1)) {
35250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35251 }
35252 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35253 {
35254 PyThreadState* __tstate = wxPyBeginAllowThreads();
35255 result = ((wxDisplay const *)arg1)->GetGeometry();
35256 wxPyEndAllowThreads(__tstate);
35257 if (PyErr_Occurred()) SWIG_fail;
35258 }
35259 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35260 return resultobj;
35261 fail:
35262 return NULL;
35263 }
35264
35265
35266 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35267 PyObject *resultobj = 0;
35268 wxDisplay *arg1 = (wxDisplay *) 0 ;
35269 wxRect result;
35270 void *argp1 = 0 ;
35271 int res1 = 0 ;
35272 PyObject *swig_obj[1] ;
35273
35274 if (!args) SWIG_fail;
35275 swig_obj[0] = args;
35276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35277 if (!SWIG_IsOK(res1)) {
35278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35279 }
35280 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35281 {
35282 PyThreadState* __tstate = wxPyBeginAllowThreads();
35283 result = ((wxDisplay const *)arg1)->GetClientArea();
35284 wxPyEndAllowThreads(__tstate);
35285 if (PyErr_Occurred()) SWIG_fail;
35286 }
35287 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35288 return resultobj;
35289 fail:
35290 return NULL;
35291 }
35292
35293
35294 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35295 PyObject *resultobj = 0;
35296 wxDisplay *arg1 = (wxDisplay *) 0 ;
35297 wxString result;
35298 void *argp1 = 0 ;
35299 int res1 = 0 ;
35300 PyObject *swig_obj[1] ;
35301
35302 if (!args) SWIG_fail;
35303 swig_obj[0] = args;
35304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35305 if (!SWIG_IsOK(res1)) {
35306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35307 }
35308 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35309 {
35310 PyThreadState* __tstate = wxPyBeginAllowThreads();
35311 result = ((wxDisplay const *)arg1)->GetName();
35312 wxPyEndAllowThreads(__tstate);
35313 if (PyErr_Occurred()) SWIG_fail;
35314 }
35315 {
35316 #if wxUSE_UNICODE
35317 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35318 #else
35319 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35320 #endif
35321 }
35322 return resultobj;
35323 fail:
35324 return NULL;
35325 }
35326
35327
35328 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35329 PyObject *resultobj = 0;
35330 wxDisplay *arg1 = (wxDisplay *) 0 ;
35331 bool result;
35332 void *argp1 = 0 ;
35333 int res1 = 0 ;
35334 PyObject *swig_obj[1] ;
35335
35336 if (!args) SWIG_fail;
35337 swig_obj[0] = args;
35338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35339 if (!SWIG_IsOK(res1)) {
35340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35341 }
35342 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35343 {
35344 PyThreadState* __tstate = wxPyBeginAllowThreads();
35345 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
35346 wxPyEndAllowThreads(__tstate);
35347 if (PyErr_Occurred()) SWIG_fail;
35348 }
35349 {
35350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35351 }
35352 return resultobj;
35353 fail:
35354 return NULL;
35355 }
35356
35357
35358 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35359 PyObject *resultobj = 0;
35360 wxDisplay *arg1 = (wxDisplay *) 0 ;
35361 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35362 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35363 PyObject *result = 0 ;
35364 void *argp1 = 0 ;
35365 int res1 = 0 ;
35366 void *argp2 = 0 ;
35367 int res2 = 0 ;
35368 PyObject * obj0 = 0 ;
35369 PyObject * obj1 = 0 ;
35370 char * kwnames[] = {
35371 (char *) "self",(char *) "mode", NULL
35372 };
35373
35374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
35375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35376 if (!SWIG_IsOK(res1)) {
35377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
35378 }
35379 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35380 if (obj1) {
35381 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35382 if (!SWIG_IsOK(res2)) {
35383 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35384 }
35385 if (!argp2) {
35386 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35387 }
35388 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35389 }
35390 {
35391 PyThreadState* __tstate = wxPyBeginAllowThreads();
35392 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
35393 wxPyEndAllowThreads(__tstate);
35394 if (PyErr_Occurred()) SWIG_fail;
35395 }
35396 resultobj = result;
35397 return resultobj;
35398 fail:
35399 return NULL;
35400 }
35401
35402
35403 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35404 PyObject *resultobj = 0;
35405 wxDisplay *arg1 = (wxDisplay *) 0 ;
35406 wxVideoMode result;
35407 void *argp1 = 0 ;
35408 int res1 = 0 ;
35409 PyObject *swig_obj[1] ;
35410
35411 if (!args) SWIG_fail;
35412 swig_obj[0] = args;
35413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35414 if (!SWIG_IsOK(res1)) {
35415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35416 }
35417 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35418 {
35419 PyThreadState* __tstate = wxPyBeginAllowThreads();
35420 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
35421 wxPyEndAllowThreads(__tstate);
35422 if (PyErr_Occurred()) SWIG_fail;
35423 }
35424 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
35425 return resultobj;
35426 fail:
35427 return NULL;
35428 }
35429
35430
35431 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35432 PyObject *resultobj = 0;
35433 wxDisplay *arg1 = (wxDisplay *) 0 ;
35434 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35435 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35436 bool result;
35437 void *argp1 = 0 ;
35438 int res1 = 0 ;
35439 void *argp2 = 0 ;
35440 int res2 = 0 ;
35441 PyObject * obj0 = 0 ;
35442 PyObject * obj1 = 0 ;
35443 char * kwnames[] = {
35444 (char *) "self",(char *) "mode", NULL
35445 };
35446
35447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
35448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35449 if (!SWIG_IsOK(res1)) {
35450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35451 }
35452 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35453 if (obj1) {
35454 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35455 if (!SWIG_IsOK(res2)) {
35456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35457 }
35458 if (!argp2) {
35459 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35460 }
35461 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35462 }
35463 {
35464 PyThreadState* __tstate = wxPyBeginAllowThreads();
35465 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
35466 wxPyEndAllowThreads(__tstate);
35467 if (PyErr_Occurred()) SWIG_fail;
35468 }
35469 {
35470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35471 }
35472 return resultobj;
35473 fail:
35474 return NULL;
35475 }
35476
35477
35478 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35479 PyObject *resultobj = 0;
35480 wxDisplay *arg1 = (wxDisplay *) 0 ;
35481 void *argp1 = 0 ;
35482 int res1 = 0 ;
35483 PyObject *swig_obj[1] ;
35484
35485 if (!args) SWIG_fail;
35486 swig_obj[0] = args;
35487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35488 if (!SWIG_IsOK(res1)) {
35489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35490 }
35491 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35492 {
35493 PyThreadState* __tstate = wxPyBeginAllowThreads();
35494 wxDisplay_ResetMode(arg1);
35495 wxPyEndAllowThreads(__tstate);
35496 if (PyErr_Occurred()) SWIG_fail;
35497 }
35498 resultobj = SWIG_Py_Void();
35499 return resultobj;
35500 fail:
35501 return NULL;
35502 }
35503
35504
35505 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35506 PyObject *obj;
35507 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35508 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
35509 return SWIG_Py_Void();
35510 }
35511
35512 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35513 return SWIG_Python_InitShadowInstance(args);
35514 }
35515
35516 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35517 PyObject *resultobj = 0;
35518 wxStandardPaths *result = 0 ;
35519
35520 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
35521 {
35522 PyThreadState* __tstate = wxPyBeginAllowThreads();
35523 result = (wxStandardPaths *)wxStandardPaths_Get();
35524 wxPyEndAllowThreads(__tstate);
35525 if (PyErr_Occurred()) SWIG_fail;
35526 }
35527 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35528 return resultobj;
35529 fail:
35530 return NULL;
35531 }
35532
35533
35534 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35535 PyObject *resultobj = 0;
35536 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35537 wxString result;
35538 void *argp1 = 0 ;
35539 int res1 = 0 ;
35540 PyObject *swig_obj[1] ;
35541
35542 if (!args) SWIG_fail;
35543 swig_obj[0] = args;
35544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35545 if (!SWIG_IsOK(res1)) {
35546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35547 }
35548 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35549 {
35550 PyThreadState* __tstate = wxPyBeginAllowThreads();
35551 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
35552 wxPyEndAllowThreads(__tstate);
35553 if (PyErr_Occurred()) SWIG_fail;
35554 }
35555 {
35556 #if wxUSE_UNICODE
35557 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35558 #else
35559 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35560 #endif
35561 }
35562 return resultobj;
35563 fail:
35564 return NULL;
35565 }
35566
35567
35568 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35569 PyObject *resultobj = 0;
35570 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35571 wxString result;
35572 void *argp1 = 0 ;
35573 int res1 = 0 ;
35574 PyObject *swig_obj[1] ;
35575
35576 if (!args) SWIG_fail;
35577 swig_obj[0] = args;
35578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35579 if (!SWIG_IsOK(res1)) {
35580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35581 }
35582 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35583 {
35584 PyThreadState* __tstate = wxPyBeginAllowThreads();
35585 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
35586 wxPyEndAllowThreads(__tstate);
35587 if (PyErr_Occurred()) SWIG_fail;
35588 }
35589 {
35590 #if wxUSE_UNICODE
35591 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35592 #else
35593 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35594 #endif
35595 }
35596 return resultobj;
35597 fail:
35598 return NULL;
35599 }
35600
35601
35602 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35603 PyObject *resultobj = 0;
35604 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35605 wxString result;
35606 void *argp1 = 0 ;
35607 int res1 = 0 ;
35608 PyObject *swig_obj[1] ;
35609
35610 if (!args) SWIG_fail;
35611 swig_obj[0] = args;
35612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35613 if (!SWIG_IsOK(res1)) {
35614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35615 }
35616 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35617 {
35618 PyThreadState* __tstate = wxPyBeginAllowThreads();
35619 result = ((wxStandardPaths const *)arg1)->GetDataDir();
35620 wxPyEndAllowThreads(__tstate);
35621 if (PyErr_Occurred()) SWIG_fail;
35622 }
35623 {
35624 #if wxUSE_UNICODE
35625 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35626 #else
35627 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35628 #endif
35629 }
35630 return resultobj;
35631 fail:
35632 return NULL;
35633 }
35634
35635
35636 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35637 PyObject *resultobj = 0;
35638 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35639 wxString result;
35640 void *argp1 = 0 ;
35641 int res1 = 0 ;
35642 PyObject *swig_obj[1] ;
35643
35644 if (!args) SWIG_fail;
35645 swig_obj[0] = args;
35646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35647 if (!SWIG_IsOK(res1)) {
35648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35649 }
35650 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35651 {
35652 PyThreadState* __tstate = wxPyBeginAllowThreads();
35653 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
35654 wxPyEndAllowThreads(__tstate);
35655 if (PyErr_Occurred()) SWIG_fail;
35656 }
35657 {
35658 #if wxUSE_UNICODE
35659 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35660 #else
35661 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35662 #endif
35663 }
35664 return resultobj;
35665 fail:
35666 return NULL;
35667 }
35668
35669
35670 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35671 PyObject *resultobj = 0;
35672 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35673 wxString result;
35674 void *argp1 = 0 ;
35675 int res1 = 0 ;
35676 PyObject *swig_obj[1] ;
35677
35678 if (!args) SWIG_fail;
35679 swig_obj[0] = args;
35680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35681 if (!SWIG_IsOK(res1)) {
35682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35683 }
35684 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35685 {
35686 PyThreadState* __tstate = wxPyBeginAllowThreads();
35687 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
35688 wxPyEndAllowThreads(__tstate);
35689 if (PyErr_Occurred()) SWIG_fail;
35690 }
35691 {
35692 #if wxUSE_UNICODE
35693 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35694 #else
35695 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35696 #endif
35697 }
35698 return resultobj;
35699 fail:
35700 return NULL;
35701 }
35702
35703
35704 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35705 PyObject *resultobj = 0;
35706 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35707 wxString result;
35708 void *argp1 = 0 ;
35709 int res1 = 0 ;
35710 PyObject *swig_obj[1] ;
35711
35712 if (!args) SWIG_fail;
35713 swig_obj[0] = args;
35714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35715 if (!SWIG_IsOK(res1)) {
35716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35717 }
35718 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35719 {
35720 PyThreadState* __tstate = wxPyBeginAllowThreads();
35721 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
35722 wxPyEndAllowThreads(__tstate);
35723 if (PyErr_Occurred()) SWIG_fail;
35724 }
35725 {
35726 #if wxUSE_UNICODE
35727 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35728 #else
35729 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35730 #endif
35731 }
35732 return resultobj;
35733 fail:
35734 return NULL;
35735 }
35736
35737
35738 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35739 PyObject *resultobj = 0;
35740 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35741 wxString result;
35742 void *argp1 = 0 ;
35743 int res1 = 0 ;
35744 PyObject *swig_obj[1] ;
35745
35746 if (!args) SWIG_fail;
35747 swig_obj[0] = args;
35748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35749 if (!SWIG_IsOK(res1)) {
35750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35751 }
35752 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35753 {
35754 PyThreadState* __tstate = wxPyBeginAllowThreads();
35755 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
35756 wxPyEndAllowThreads(__tstate);
35757 if (PyErr_Occurred()) SWIG_fail;
35758 }
35759 {
35760 #if wxUSE_UNICODE
35761 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35762 #else
35763 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35764 #endif
35765 }
35766 return resultobj;
35767 fail:
35768 return NULL;
35769 }
35770
35771
35772 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35773 PyObject *resultobj = 0;
35774 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35775 wxString result;
35776 void *argp1 = 0 ;
35777 int res1 = 0 ;
35778 PyObject *swig_obj[1] ;
35779
35780 if (!args) SWIG_fail;
35781 swig_obj[0] = args;
35782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35783 if (!SWIG_IsOK(res1)) {
35784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35785 }
35786 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35787 {
35788 PyThreadState* __tstate = wxPyBeginAllowThreads();
35789 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
35790 wxPyEndAllowThreads(__tstate);
35791 if (PyErr_Occurred()) SWIG_fail;
35792 }
35793 {
35794 #if wxUSE_UNICODE
35795 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35796 #else
35797 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35798 #endif
35799 }
35800 return resultobj;
35801 fail:
35802 return NULL;
35803 }
35804
35805
35806 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35807 PyObject *resultobj = 0;
35808 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35809 wxString *arg2 = 0 ;
35810 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
35811 wxString result;
35812 void *argp1 = 0 ;
35813 int res1 = 0 ;
35814 bool temp2 = false ;
35815 int val3 ;
35816 int ecode3 = 0 ;
35817 PyObject * obj0 = 0 ;
35818 PyObject * obj1 = 0 ;
35819 PyObject * obj2 = 0 ;
35820 char * kwnames[] = {
35821 (char *) "self",(char *) "lang",(char *) "category", NULL
35822 };
35823
35824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35826 if (!SWIG_IsOK(res1)) {
35827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35828 }
35829 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35830 {
35831 arg2 = wxString_in_helper(obj1);
35832 if (arg2 == NULL) SWIG_fail;
35833 temp2 = true;
35834 }
35835 if (obj2) {
35836 ecode3 = SWIG_AsVal_int(obj2, &val3);
35837 if (!SWIG_IsOK(ecode3)) {
35838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
35839 }
35840 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
35841 }
35842 {
35843 PyThreadState* __tstate = wxPyBeginAllowThreads();
35844 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
35845 wxPyEndAllowThreads(__tstate);
35846 if (PyErr_Occurred()) SWIG_fail;
35847 }
35848 {
35849 #if wxUSE_UNICODE
35850 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35851 #else
35852 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35853 #endif
35854 }
35855 {
35856 if (temp2)
35857 delete arg2;
35858 }
35859 return resultobj;
35860 fail:
35861 {
35862 if (temp2)
35863 delete arg2;
35864 }
35865 return NULL;
35866 }
35867
35868
35869 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35870 PyObject *resultobj = 0;
35871 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35872 wxString result;
35873 void *argp1 = 0 ;
35874 int res1 = 0 ;
35875 PyObject *swig_obj[1] ;
35876
35877 if (!args) SWIG_fail;
35878 swig_obj[0] = args;
35879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35880 if (!SWIG_IsOK(res1)) {
35881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35882 }
35883 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35884 {
35885 PyThreadState* __tstate = wxPyBeginAllowThreads();
35886 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
35887 wxPyEndAllowThreads(__tstate);
35888 if (PyErr_Occurred()) SWIG_fail;
35889 }
35890 {
35891 #if wxUSE_UNICODE
35892 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35893 #else
35894 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35895 #endif
35896 }
35897 return resultobj;
35898 fail:
35899 return NULL;
35900 }
35901
35902
35903 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35904 PyObject *resultobj = 0;
35905 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35906 wxString *arg2 = 0 ;
35907 void *argp1 = 0 ;
35908 int res1 = 0 ;
35909 bool temp2 = false ;
35910 PyObject * obj0 = 0 ;
35911 PyObject * obj1 = 0 ;
35912 char * kwnames[] = {
35913 (char *) "self",(char *) "prefix", NULL
35914 };
35915
35916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
35917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35918 if (!SWIG_IsOK(res1)) {
35919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
35920 }
35921 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35922 {
35923 arg2 = wxString_in_helper(obj1);
35924 if (arg2 == NULL) SWIG_fail;
35925 temp2 = true;
35926 }
35927 {
35928 PyThreadState* __tstate = wxPyBeginAllowThreads();
35929 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
35930 wxPyEndAllowThreads(__tstate);
35931 if (PyErr_Occurred()) SWIG_fail;
35932 }
35933 resultobj = SWIG_Py_Void();
35934 {
35935 if (temp2)
35936 delete arg2;
35937 }
35938 return resultobj;
35939 fail:
35940 {
35941 if (temp2)
35942 delete arg2;
35943 }
35944 return NULL;
35945 }
35946
35947
35948 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35949 PyObject *resultobj = 0;
35950 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35951 wxString result;
35952 void *argp1 = 0 ;
35953 int res1 = 0 ;
35954 PyObject *swig_obj[1] ;
35955
35956 if (!args) SWIG_fail;
35957 swig_obj[0] = args;
35958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35959 if (!SWIG_IsOK(res1)) {
35960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
35961 }
35962 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35963 {
35964 PyThreadState* __tstate = wxPyBeginAllowThreads();
35965 result = wxStandardPaths_GetInstallPrefix(arg1);
35966 wxPyEndAllowThreads(__tstate);
35967 if (PyErr_Occurred()) SWIG_fail;
35968 }
35969 {
35970 #if wxUSE_UNICODE
35971 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35972 #else
35973 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35974 #endif
35975 }
35976 return resultobj;
35977 fail:
35978 return NULL;
35979 }
35980
35981
35982 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35983 PyObject *obj;
35984 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35985 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
35986 return SWIG_Py_Void();
35987 }
35988
35989 static PyMethodDef SwigMethods[] = {
35990 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
35991 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
35992 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
35993 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
35994 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
35995 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
35996 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
35997 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
35998 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
35999 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36000 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36001 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36002 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
36003 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
36004 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
36005 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
36006 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
36007 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
36008 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
36009 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
36010 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36011 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36012 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
36013 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
36014 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
36015 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
36016 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
36017 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
36018 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
36019 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
36020 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
36021 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
36022 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
36023 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
36024 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36025 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36026 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
36027 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
36028 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
36029 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
36030 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
36031 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
36032 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
36033 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
36034 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
36035 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
36036 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
36037 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36038 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36039 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36040 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36041 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36042 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36043 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
36044 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
36045 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
36046 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
36047 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
36048 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
36049 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
36050 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
36051 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
36052 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
36053 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
36054 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
36055 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36056 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
36057 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36058 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
36059 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
36060 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
36061 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36062 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36063 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
36064 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
36065 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
36066 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
36067 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
36068 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
36069 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
36070 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
36071 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
36072 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
36073 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
36074 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
36075 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
36076 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
36077 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
36078 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
36079 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
36080 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36081 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
36082 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
36083 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
36084 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36085 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
36086 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
36087 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
36088 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
36089 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
36090 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
36091 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
36092 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
36093 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
36094 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
36095 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
36096 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
36097 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
36098 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
36099 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
36100 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
36101 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
36102 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
36103 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
36104 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
36105 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
36106 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
36107 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
36108 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
36109 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
36110 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
36111 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
36112 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
36113 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
36114 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
36115 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
36116 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
36117 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
36118 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
36119 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
36120 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
36121 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36122 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
36123 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
36124 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
36125 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
36126 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
36127 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36128 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
36129 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
36130 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
36131 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
36132 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
36133 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
36134 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
36135 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36136 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
36137 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
36138 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
36139 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
36140 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36141 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
36142 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
36143 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
36144 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
36145 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
36146 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36147 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
36148 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36149 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36150 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
36151 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36152 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36153 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
36154 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
36155 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
36156 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36157 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
36158 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
36159 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
36160 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
36161 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
36162 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
36163 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
36164 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36165 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
36166 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
36167 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
36168 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
36169 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
36170 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
36171 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
36172 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
36173 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
36174 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36175 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36176 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
36177 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
36178 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
36179 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36180 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
36181 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
36182 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36183 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
36184 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
36185 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36186 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
36187 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
36188 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
36189 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
36190 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
36191 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
36192 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
36193 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
36194 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36195 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
36196 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
36197 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
36198 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
36199 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
36200 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36201 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
36202 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
36203 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
36204 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
36205 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
36206 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
36207 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
36208 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
36209 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
36210 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
36211 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36212 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
36213 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
36214 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36215 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
36216 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
36217 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36218 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36219 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36220 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
36221 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
36222 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
36223 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
36224 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
36225 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36226 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
36227 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
36228 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
36229 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
36230 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
36231 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
36232 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
36233 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
36234 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
36235 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
36236 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
36237 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
36238 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
36239 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
36240 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
36241 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36242 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36243 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
36244 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
36245 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
36246 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36247 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
36248 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
36249 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
36250 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
36251 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36252 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
36253 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
36254 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
36255 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
36256 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
36257 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
36258 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
36259 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
36260 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
36261 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
36262 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
36263 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
36264 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
36265 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36266 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36267 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
36268 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36269 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
36270 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
36271 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
36272 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
36273 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
36274 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36275 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
36276 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
36277 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
36278 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
36279 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
36280 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36281 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
36282 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
36283 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36284 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36285 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
36286 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
36287 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36288 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
36289 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
36290 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
36291 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
36292 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
36293 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
36294 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
36295 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
36296 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
36297 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
36298 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
36299 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
36300 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
36301 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36302 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
36303 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
36304 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
36305 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
36306 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
36307 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
36308 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
36309 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
36310 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
36311 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36312 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
36313 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
36314 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
36315 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
36316 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
36317 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
36318 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
36319 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
36320 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
36321 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
36322 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
36323 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
36324 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
36325 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
36326 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
36327 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
36328 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
36329 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
36330 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
36331 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
36332 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
36333 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
36334 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
36335 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
36336 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
36337 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
36338 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
36339 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
36340 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
36341 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
36342 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
36343 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
36344 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
36345 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
36346 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
36347 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
36348 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
36349 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
36350 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
36351 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
36352 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
36353 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
36354 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
36355 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
36356 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
36357 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
36358 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36359 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
36360 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
36361 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
36362 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
36363 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
36364 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
36365 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
36366 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
36367 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36368 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36369 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
36370 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
36371 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
36372 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
36373 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
36374 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
36375 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
36376 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
36377 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
36378 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36379 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
36380 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36381 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36382 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
36383 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
36384 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
36385 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
36386 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
36387 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
36388 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36389 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
36390 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
36391 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
36392 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36393 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
36394 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
36395 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
36396 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
36397 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
36398 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
36399 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
36400 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
36401 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
36402 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
36403 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
36404 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
36405 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
36406 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
36407 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
36408 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
36409 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
36410 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
36411 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
36412 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
36413 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36414 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36415 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
36416 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36417 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36418 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
36419 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36420 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
36421 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
36422 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
36423 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
36424 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
36425 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
36426 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
36427 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
36428 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
36429 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
36430 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
36431 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
36432 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
36433 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
36434 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
36435 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
36436 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
36437 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
36438 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
36439 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36440 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36441 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
36442 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36443 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36444 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36445 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
36446 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
36447 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
36448 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
36449 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
36450 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36451 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
36452 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
36453 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
36454 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
36455 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
36456 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
36457 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36458 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
36459 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36460 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
36461 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
36462 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36463 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36464 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36465 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
36466 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
36467 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
36468 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36469 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
36470 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
36471 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
36472 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36473 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
36474 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
36475 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36476 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36477 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36478 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36479 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
36480 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36481 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
36482 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
36483 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
36484 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36485 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
36486 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
36487 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
36488 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
36489 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
36490 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
36491 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
36492 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
36493 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
36494 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
36495 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
36496 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
36497 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
36498 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
36499 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
36500 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
36501 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
36502 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
36503 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
36504 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
36505 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36506 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36507 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
36508 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36509 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
36510 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
36511 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36512 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
36513 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
36514 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
36515 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36516 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
36517 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
36518 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
36519 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
36520 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
36521 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
36522 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
36523 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
36524 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
36525 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
36526 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36527 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36528 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36529 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
36530 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36531 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
36532 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
36533 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36534 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36535 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36536 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36537 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
36538 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36539 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36540 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36541 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36542 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36543 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36544 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36545 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36546 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36547 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36548 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36549 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36550 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36551 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36552 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36553 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36554 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36555 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36556 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36557 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36558 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36559 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36560 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36561 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
36562 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
36563 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
36564 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
36565 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
36566 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36567 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36568 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36569 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36570 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36571 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36572 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36573 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36574 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36575 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36576 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
36577 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
36578 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
36579 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36580 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36581 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36582 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36583 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36584 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36585 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36586 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36587 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36588 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36589 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36590 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
36591 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36592 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
36593 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36594 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36595 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36596 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
36597 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
36598 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
36599 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
36600 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
36601 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
36602 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
36603 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36604 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
36605 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
36606 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
36607 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
36608 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36609 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36610 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36611 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36612 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36613 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36614 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
36615 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36616 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36617 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
36618 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
36619 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36620 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
36621 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
36622 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
36623 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
36624 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
36625 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
36626 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
36627 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
36628 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
36629 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
36630 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
36631 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
36632 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
36633 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
36634 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36635 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
36636 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36637 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
36638 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36639 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
36640 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36641 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36642 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36643 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
36644 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
36645 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36646 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36647 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36648 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
36649 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36650 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36651 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36652 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36653 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36654 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36655 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36656 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36657 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36658 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36659 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
36660 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
36661 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
36662 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36663 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
36664 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36665 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
36666 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
36667 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
36668 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
36669 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
36670 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
36671 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36672 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
36673 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
36674 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36675 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
36676 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36677 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
36678 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36679 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
36680 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
36681 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
36682 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
36683 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
36684 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
36685 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
36686 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
36687 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
36688 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
36689 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
36690 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
36691 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
36692 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
36693 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36694 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36695 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
36696 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36697 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36698 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36699 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
36700 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36701 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36702 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36703 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36704 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36705 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36706 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36707 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
36708 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
36709 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
36710 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
36711 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
36712 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
36713 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36714 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36715 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
36716 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
36717 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
36718 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
36719 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
36720 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
36721 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
36722 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
36723 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
36724 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
36725 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36726 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
36727 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36728 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
36729 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
36730 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
36731 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36732 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
36733 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36734 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
36735 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36736 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
36737 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
36738 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36739 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
36740 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
36741 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36742 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36743 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
36744 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
36745 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
36746 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36747 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
36748 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
36749 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
36750 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36751 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
36752 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
36753 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
36754 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
36755 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
36756 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36757 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36758 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
36759 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
36760 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36761 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
36762 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36763 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
36764 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
36765 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36766 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36767 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
36768 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
36769 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
36770 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
36771 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
36772 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
36773 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
36774 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
36775 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36776 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
36777 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
36778 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
36779 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
36780 { (char *)"new_URLDataObject", (PyCFunction)_wrap_new_URLDataObject, METH_NOARGS, NULL},
36781 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
36782 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
36783 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
36784 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
36785 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
36786 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
36787 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
36788 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
36789 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
36790 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
36791 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
36792 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36793 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
36794 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36795 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
36796 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36797 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36798 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
36799 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
36800 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
36801 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36802 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36803 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
36804 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
36805 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36806 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36807 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36808 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
36809 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36810 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
36811 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
36812 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
36813 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
36814 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
36815 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
36816 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36817 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
36818 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36819 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36820 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
36821 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36822 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36823 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
36824 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
36825 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
36826 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36827 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
36828 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36829 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36830 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
36831 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36832 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36833 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
36834 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
36835 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
36836 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
36837 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
36838 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
36839 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
36840 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
36841 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36842 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36843 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
36844 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
36845 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
36846 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
36847 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
36848 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
36849 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
36850 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
36851 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
36852 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
36853 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
36854 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
36855 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
36856 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
36857 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
36858 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
36859 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
36860 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
36861 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
36862 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36863 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36864 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
36865 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
36866 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
36867 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
36868 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
36869 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
36870 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
36871 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
36872 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
36873 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
36874 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
36875 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
36876 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
36877 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36878 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36879 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
36880 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
36881 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
36882 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
36883 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
36884 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
36885 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
36886 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
36887 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
36888 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
36889 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
36890 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
36891 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
36892 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
36893 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
36894 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
36895 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
36896 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
36897 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
36898 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
36899 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
36900 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
36901 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
36902 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
36903 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
36904 { NULL, NULL, 0, NULL }
36905 };
36906
36907
36908 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
36909
36910 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
36911 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
36912 }
36913 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
36914 return (void *)((wxEvent *) ((wxMenuEvent *) x));
36915 }
36916 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
36917 return (void *)((wxEvent *) ((wxCloseEvent *) x));
36918 }
36919 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
36920 return (void *)((wxEvent *) ((wxMouseEvent *) x));
36921 }
36922 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
36923 return (void *)((wxEvent *) ((wxEraseEvent *) x));
36924 }
36925 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
36926 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
36927 }
36928 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
36929 return (void *)((wxEvent *) ((wxTimerEvent *) x));
36930 }
36931 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
36932 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
36933 }
36934 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
36935 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
36936 }
36937 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
36938 return (void *)((wxEvent *) ((wxPyEvent *) x));
36939 }
36940 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
36941 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
36942 }
36943 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
36944 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
36945 }
36946 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
36947 return (void *)((wxEvent *) ((wxIdleEvent *) x));
36948 }
36949 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
36950 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
36951 }
36952 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
36953 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
36954 }
36955 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
36956 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
36957 }
36958 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
36959 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
36960 }
36961 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
36962 return (void *)((wxEvent *) ((wxActivateEvent *) x));
36963 }
36964 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
36965 return (void *)((wxEvent *) ((wxSizeEvent *) x));
36966 }
36967 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
36968 return (void *)((wxEvent *) ((wxMoveEvent *) x));
36969 }
36970 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
36971 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
36972 }
36973 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
36974 return (void *)((wxEvent *) ((wxPaintEvent *) x));
36975 }
36976 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
36977 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
36978 }
36979 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
36980 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
36981 }
36982 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
36983 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
36984 }
36985 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
36986 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
36987 }
36988 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
36989 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
36990 }
36991 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
36992 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
36993 }
36994 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
36995 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
36996 }
36997 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
36998 return (void *)((wxEvent *) ((wxFocusEvent *) x));
36999 }
37000 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
37001 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
37002 }
37003 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
37004 return (void *)((wxEvent *) ((wxProcessEvent *) x));
37005 }
37006 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
37007 return (void *)((wxEvent *) ((wxShowEvent *) x));
37008 }
37009 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
37010 return (void *)((wxEvent *) ((wxCommandEvent *) x));
37011 }
37012 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
37013 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
37014 }
37015 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
37016 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37017 }
37018 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
37019 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
37020 }
37021 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
37022 return (void *)((wxEvent *) ((wxKeyEvent *) x));
37023 }
37024 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
37025 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
37026 }
37027 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
37028 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
37029 }
37030 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
37031 return (void *)((wxConfigBase *) ((wxConfig *) x));
37032 }
37033 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
37034 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37035 }
37036 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
37037 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
37038 }
37039 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
37040 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
37041 }
37042 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
37043 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37044 }
37045 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
37046 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
37047 }
37048 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
37049 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
37050 }
37051 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
37052 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
37053 }
37054 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
37055 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37056 }
37057 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
37058 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37059 }
37060 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
37061 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
37062 }
37063 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
37064 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
37065 }
37066 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
37067 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
37068 }
37069 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
37070 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37071 }
37072 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
37073 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37074 }
37075 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37076 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
37077 }
37078 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37079 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
37080 }
37081 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37082 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37083 }
37084 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37085 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37086 }
37087 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
37088 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
37089 }
37090 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
37091 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
37092 }
37093 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
37094 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37095 }
37096 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
37097 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
37098 }
37099 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
37100 return (void *)((wxEvtHandler *) ((wxWindow *) x));
37101 }
37102 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
37103 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37104 }
37105 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
37106 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
37107 }
37108 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
37109 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
37110 }
37111 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
37112 return (void *)((wxEvtHandler *) ((wxValidator *) x));
37113 }
37114 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
37115 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
37116 }
37117 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
37118 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
37119 }
37120 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
37121 return (void *)((wxEvtHandler *) ((wxMenu *) x));
37122 }
37123 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
37124 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
37125 }
37126 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
37127 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
37128 }
37129 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
37130 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
37131 }
37132 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
37133 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
37134 }
37135 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
37136 return (void *)((wxObject *) ((wxSizerItem *) x));
37137 }
37138 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
37139 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
37140 }
37141 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
37142 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
37143 }
37144 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
37145 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
37146 }
37147 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
37148 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
37149 }
37150 static void *_p_wxSizerTo_p_wxObject(void *x) {
37151 return (void *)((wxObject *) ((wxSizer *) x));
37152 }
37153 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
37154 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
37155 }
37156 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
37157 return (void *)((wxObject *) ((wxFileHistory *) x));
37158 }
37159 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
37160 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
37161 }
37162 static void *_p_wxEventTo_p_wxObject(void *x) {
37163 return (void *)((wxObject *) ((wxEvent *) x));
37164 }
37165 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
37166 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
37167 }
37168 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
37169 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
37170 }
37171 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
37172 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
37173 }
37174 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
37175 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
37176 }
37177 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
37178 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
37179 }
37180 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
37181 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
37182 }
37183 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
37184 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
37185 }
37186 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
37187 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37188 }
37189 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
37190 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
37191 }
37192 static void *_p_wxControlTo_p_wxObject(void *x) {
37193 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
37194 }
37195 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
37196 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
37197 }
37198 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
37199 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
37200 }
37201 static void *_p_wxFSFileTo_p_wxObject(void *x) {
37202 return (void *)((wxObject *) ((wxFSFile *) x));
37203 }
37204 static void *_p_wxClipboardTo_p_wxObject(void *x) {
37205 return (void *)((wxObject *) ((wxClipboard *) x));
37206 }
37207 static void *_p_wxPySizerTo_p_wxObject(void *x) {
37208 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
37209 }
37210 static void *_p_wxPyEventTo_p_wxObject(void *x) {
37211 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
37212 }
37213 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
37214 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
37215 }
37216 static void *_p_wxShowEventTo_p_wxObject(void *x) {
37217 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
37218 }
37219 static void *_p_wxToolTipTo_p_wxObject(void *x) {
37220 return (void *)((wxObject *) ((wxToolTip *) x));
37221 }
37222 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
37223 return (void *)((wxObject *) ((wxMenuItem *) x));
37224 }
37225 static void *_p_wxDateEventTo_p_wxObject(void *x) {
37226 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
37227 }
37228 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
37229 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
37230 }
37231 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
37232 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
37233 }
37234 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
37235 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
37236 }
37237 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
37238 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
37239 }
37240 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
37241 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
37242 }
37243 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
37244 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
37245 }
37246 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
37247 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
37248 }
37249 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
37250 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
37251 }
37252 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
37253 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
37254 }
37255 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
37256 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
37257 }
37258 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
37259 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
37260 }
37261 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
37262 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
37263 }
37264 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
37265 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
37266 }
37267 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
37268 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
37269 }
37270 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
37271 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
37272 }
37273 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
37274 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
37275 }
37276 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
37277 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
37278 }
37279 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
37280 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
37281 }
37282 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
37283 return (void *)((wxObject *) ((wxImageHandler *) x));
37284 }
37285 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
37286 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
37287 }
37288 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
37289 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
37290 }
37291 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
37292 return (void *)((wxObject *) ((wxEvtHandler *) x));
37293 }
37294 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
37295 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
37296 }
37297 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
37298 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
37299 }
37300 static void *_p_wxImageTo_p_wxObject(void *x) {
37301 return (void *)((wxObject *) ((wxImage *) x));
37302 }
37303 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
37304 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
37305 }
37306 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
37307 return (void *)((wxObject *) ((wxSystemOptions *) x));
37308 }
37309 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
37310 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
37311 }
37312 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
37313 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37314 }
37315 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
37316 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
37317 }
37318 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
37319 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
37320 }
37321 static void *_p_wxWindowTo_p_wxObject(void *x) {
37322 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
37323 }
37324 static void *_p_wxMenuTo_p_wxObject(void *x) {
37325 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
37326 }
37327 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
37328 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
37329 }
37330 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
37331 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
37332 }
37333 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
37334 return (void *)((wxObject *) ((wxFileSystem *) x));
37335 }
37336 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
37337 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
37338 }
37339 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
37340 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
37341 }
37342 static void *_p_wxPyAppTo_p_wxObject(void *x) {
37343 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
37344 }
37345 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
37346 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
37347 }
37348 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
37349 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
37350 }
37351 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
37352 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
37353 }
37354 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
37355 return (void *)((wxObject *) ((wxBusyInfo *) x));
37356 }
37357 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
37358 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
37359 }
37360 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
37361 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
37362 }
37363 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
37364 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
37365 }
37366 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
37367 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
37368 }
37369 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
37370 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
37371 }
37372 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
37373 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
37374 }
37375 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
37376 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37377 }
37378 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
37379 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
37380 }
37381 static void *_p_wxValidatorTo_p_wxObject(void *x) {
37382 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
37383 }
37384 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
37385 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
37386 }
37387 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
37388 return (void *)((wxLog *) ((wxLogBuffer *) x));
37389 }
37390 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
37391 return (void *)((wxLog *) ((wxLogStderr *) x));
37392 }
37393 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
37394 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
37395 }
37396 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
37397 return (void *)((wxLog *) ((wxLogWindow *) x));
37398 }
37399 static void *_p_wxLogChainTo_p_wxLog(void *x) {
37400 return (void *)((wxLog *) ((wxLogChain *) x));
37401 }
37402 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
37403 return (void *)((wxLog *) ((wxLogGui *) x));
37404 }
37405 static void *_p_wxPyLogTo_p_wxLog(void *x) {
37406 return (void *)((wxLog *) ((wxPyLog *) x));
37407 }
37408 static void *_p_wxControlTo_p_wxWindow(void *x) {
37409 return (void *)((wxWindow *) ((wxControl *) x));
37410 }
37411 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
37412 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
37413 }
37414 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
37415 return (void *)((wxWindow *) ((wxMenuBar *) x));
37416 }
37417 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
37418 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
37419 }
37420 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
37421 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
37422 }
37423 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
37424 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};
37425 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
37426 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
37427 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
37428 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
37429 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
37430 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
37431 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
37432 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
37433 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
37434 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
37435 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
37436 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
37437 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
37438 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
37439 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
37440 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
37441 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
37442 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
37443 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
37444 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
37445 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
37446 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
37447 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
37448 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
37449 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
37450 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
37451 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
37452 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
37453 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
37454 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
37455 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
37456 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
37457 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
37458 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
37459 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
37460 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
37461 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
37462 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
37463 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
37464 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
37465 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
37466 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
37467 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
37468 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
37469 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
37470 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
37471 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
37472 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
37473 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
37474 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
37475 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
37476 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
37477 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
37478 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
37479 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
37480 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
37481 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
37482 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
37483 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
37484 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
37485 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
37486 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
37487 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
37488 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
37489 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
37490 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
37491 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
37492 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
37493 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
37494 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
37495 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
37496 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
37497 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
37498 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
37499 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
37500 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
37501 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
37502 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
37503 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
37504 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
37505 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
37506 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
37507 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
37508 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
37509 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
37510 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
37511 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
37512 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
37513 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
37514 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
37515 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
37516 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
37517 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
37518 static swig_type_info _swigt__p_wxMemorySize = {"_p_wxMemorySize", "wxMemorySize *", 0, 0, (void*)0, 0};
37519 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
37520 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
37521 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
37522 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
37523 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
37524 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
37525 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
37526 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
37527 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
37528 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
37529 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
37530 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
37531 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
37532 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
37533 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
37534 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
37535 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
37536 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
37537 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
37538 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
37539 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
37540 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
37541 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
37542 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
37543 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
37544 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
37545 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
37546 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
37547 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
37548 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
37549 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
37550 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
37551 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
37552 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
37553 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
37554 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
37555 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
37556 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
37557 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
37558 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
37559 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
37560 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
37561 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
37562 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
37563 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
37564 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
37565 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
37566 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
37567 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
37568 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
37569 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
37570 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
37571 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
37572 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
37573 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
37574 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
37575 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
37576 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
37577 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
37578 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
37579 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
37580 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
37581 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
37582 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
37583 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
37584 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
37585 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
37586 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
37587 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
37588 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
37589 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
37590 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
37591 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
37592 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
37593
37594 static swig_type_info *swig_type_initial[] = {
37595 &_swigt__p_char,
37596 &_swigt__p_form_ops_t,
37597 &_swigt__p_int,
37598 &_swigt__p_unsigned_char,
37599 &_swigt__p_unsigned_int,
37600 &_swigt__p_unsigned_long,
37601 &_swigt__p_void,
37602 &_swigt__p_wxANIHandler,
37603 &_swigt__p_wxAcceleratorTable,
37604 &_swigt__p_wxActivateEvent,
37605 &_swigt__p_wxArrayString,
37606 &_swigt__p_wxBMPHandler,
37607 &_swigt__p_wxBitmap,
37608 &_swigt__p_wxBitmapDataObject,
37609 &_swigt__p_wxBoxSizer,
37610 &_swigt__p_wxBusyCursor,
37611 &_swigt__p_wxBusyInfo,
37612 &_swigt__p_wxCURHandler,
37613 &_swigt__p_wxCaret,
37614 &_swigt__p_wxChar,
37615 &_swigt__p_wxChildFocusEvent,
37616 &_swigt__p_wxClipboard,
37617 &_swigt__p_wxClipboardLocker,
37618 &_swigt__p_wxCloseEvent,
37619 &_swigt__p_wxColour,
37620 &_swigt__p_wxCommandEvent,
37621 &_swigt__p_wxConfig,
37622 &_swigt__p_wxConfigBase,
37623 &_swigt__p_wxConfigPathChanger,
37624 &_swigt__p_wxContextMenuEvent,
37625 &_swigt__p_wxControl,
37626 &_swigt__p_wxControlWithItems,
37627 &_swigt__p_wxCursor,
37628 &_swigt__p_wxCustomDataObject,
37629 &_swigt__p_wxDC,
37630 &_swigt__p_wxDataFormat,
37631 &_swigt__p_wxDataObject,
37632 &_swigt__p_wxDataObjectComposite,
37633 &_swigt__p_wxDataObjectSimple,
37634 &_swigt__p_wxDateEvent,
37635 &_swigt__p_wxDateSpan,
37636 &_swigt__p_wxDateTime,
37637 &_swigt__p_wxDateTime__TimeZone,
37638 &_swigt__p_wxDisplay,
37639 &_swigt__p_wxDisplayChangedEvent,
37640 &_swigt__p_wxDropFilesEvent,
37641 &_swigt__p_wxDuplexMode,
37642 &_swigt__p_wxEraseEvent,
37643 &_swigt__p_wxEvent,
37644 &_swigt__p_wxEvtHandler,
37645 &_swigt__p_wxFSFile,
37646 &_swigt__p_wxFileConfig,
37647 &_swigt__p_wxFileDataObject,
37648 &_swigt__p_wxFileHistory,
37649 &_swigt__p_wxFileSystem,
37650 &_swigt__p_wxFileType,
37651 &_swigt__p_wxFileTypeInfo,
37652 &_swigt__p_wxFlexGridSizer,
37653 &_swigt__p_wxFocusEvent,
37654 &_swigt__p_wxFont,
37655 &_swigt__p_wxFrame,
37656 &_swigt__p_wxGBSizerItem,
37657 &_swigt__p_wxGIFHandler,
37658 &_swigt__p_wxGridBagSizer,
37659 &_swigt__p_wxGridSizer,
37660 &_swigt__p_wxICOHandler,
37661 &_swigt__p_wxIcon,
37662 &_swigt__p_wxIconizeEvent,
37663 &_swigt__p_wxIdleEvent,
37664 &_swigt__p_wxImage,
37665 &_swigt__p_wxImageHandler,
37666 &_swigt__p_wxIndividualLayoutConstraint,
37667 &_swigt__p_wxInitDialogEvent,
37668 &_swigt__p_wxJPEGHandler,
37669 &_swigt__p_wxJoystick,
37670 &_swigt__p_wxJoystickEvent,
37671 &_swigt__p_wxKeyEvent,
37672 &_swigt__p_wxKillError,
37673 &_swigt__p_wxLayoutConstraints,
37674 &_swigt__p_wxLog,
37675 &_swigt__p_wxLogBuffer,
37676 &_swigt__p_wxLogChain,
37677 &_swigt__p_wxLogGui,
37678 &_swigt__p_wxLogNull,
37679 &_swigt__p_wxLogStderr,
37680 &_swigt__p_wxLogTextCtrl,
37681 &_swigt__p_wxLogWindow,
37682 &_swigt__p_wxMaximizeEvent,
37683 &_swigt__p_wxMemorySize,
37684 &_swigt__p_wxMenu,
37685 &_swigt__p_wxMenuBar,
37686 &_swigt__p_wxMenuEvent,
37687 &_swigt__p_wxMenuItem,
37688 &_swigt__p_wxMetafile,
37689 &_swigt__p_wxMetafileDataObject,
37690 &_swigt__p_wxMimeTypesManager,
37691 &_swigt__p_wxMouseCaptureChangedEvent,
37692 &_swigt__p_wxMouseEvent,
37693 &_swigt__p_wxMouseState,
37694 &_swigt__p_wxMoveEvent,
37695 &_swigt__p_wxMutexGuiLocker,
37696 &_swigt__p_wxNavigationKeyEvent,
37697 &_swigt__p_wxNcPaintEvent,
37698 &_swigt__p_wxNotifyEvent,
37699 &_swigt__p_wxObject,
37700 &_swigt__p_wxOutputStream,
37701 &_swigt__p_wxPCXHandler,
37702 &_swigt__p_wxPNGHandler,
37703 &_swigt__p_wxPNMHandler,
37704 &_swigt__p_wxPaintEvent,
37705 &_swigt__p_wxPaletteChangedEvent,
37706 &_swigt__p_wxPaperSize,
37707 &_swigt__p_wxPoint,
37708 &_swigt__p_wxProcessEvent,
37709 &_swigt__p_wxPyApp,
37710 &_swigt__p_wxPyArtProvider,
37711 &_swigt__p_wxPyBitmapDataObject,
37712 &_swigt__p_wxPyCommandEvent,
37713 &_swigt__p_wxPyDataObjectSimple,
37714 &_swigt__p_wxPyDropSource,
37715 &_swigt__p_wxPyDropTarget,
37716 &_swigt__p_wxPyEvent,
37717 &_swigt__p_wxPyFileDropTarget,
37718 &_swigt__p_wxPyImageHandler,
37719 &_swigt__p_wxPyLog,
37720 &_swigt__p_wxPyProcess,
37721 &_swigt__p_wxPySizer,
37722 &_swigt__p_wxPyTextDataObject,
37723 &_swigt__p_wxPyTextDropTarget,
37724 &_swigt__p_wxPyTimer,
37725 &_swigt__p_wxPyTipProvider,
37726 &_swigt__p_wxPyValidator,
37727 &_swigt__p_wxQueryNewPaletteEvent,
37728 &_swigt__p_wxRect,
37729 &_swigt__p_wxScrollEvent,
37730 &_swigt__p_wxScrollWinEvent,
37731 &_swigt__p_wxSetCursorEvent,
37732 &_swigt__p_wxShowEvent,
37733 &_swigt__p_wxSingleInstanceChecker,
37734 &_swigt__p_wxSize,
37735 &_swigt__p_wxSizeEvent,
37736 &_swigt__p_wxSizer,
37737 &_swigt__p_wxSizerItem,
37738 &_swigt__p_wxSound,
37739 &_swigt__p_wxStandardPaths,
37740 &_swigt__p_wxStaticBoxSizer,
37741 &_swigt__p_wxStdDialogButtonSizer,
37742 &_swigt__p_wxStopWatch,
37743 &_swigt__p_wxString,
37744 &_swigt__p_wxSysColourChangedEvent,
37745 &_swigt__p_wxSystemOptions,
37746 &_swigt__p_wxSystemSettings,
37747 &_swigt__p_wxTIFFHandler,
37748 &_swigt__p_wxTextCtrl,
37749 &_swigt__p_wxTextDataObject,
37750 &_swigt__p_wxTimeSpan,
37751 &_swigt__p_wxTimer,
37752 &_swigt__p_wxTimerEvent,
37753 &_swigt__p_wxTimerRunner,
37754 &_swigt__p_wxTipProvider,
37755 &_swigt__p_wxToolTip,
37756 &_swigt__p_wxURLDataObject,
37757 &_swigt__p_wxUpdateUIEvent,
37758 &_swigt__p_wxValidator,
37759 &_swigt__p_wxVideoMode,
37760 &_swigt__p_wxWindow,
37761 &_swigt__p_wxWindowCreateEvent,
37762 &_swigt__p_wxWindowDestroyEvent,
37763 &_swigt__p_wxWindowDisabler,
37764 &_swigt__p_wxXPMHandler,
37765 };
37766
37767 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
37768 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
37769 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
37770 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
37771 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
37772 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
37773 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
37774 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
37775 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
37776 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}};
37777 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
37778 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
37779 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
37780 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
37781 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
37782 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
37783 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
37784 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
37785 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}};
37786 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
37787 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
37788 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
37789 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
37790 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
37791 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}};
37792 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
37793 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}};
37794 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
37795 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
37796 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
37797 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
37798 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
37799 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37800 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37801 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
37802 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
37803 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
37804 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
37805 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
37806 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
37807 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
37808 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
37809 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
37810 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
37811 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
37812 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37813 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37814 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
37815 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37816 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
37817 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
37818 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37819 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37820 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
37821 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37822 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37823 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37824 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37825 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
37826 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37827 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37828 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
37829 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37830 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37831 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
37832 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37833 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37834 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
37835 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
37836 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
37837 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
37838 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
37839 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
37840 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
37841 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
37842 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}};
37843 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
37844 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37845 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
37846 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
37847 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
37848 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
37849 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
37850 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
37851 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
37852 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
37853 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
37854 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}};
37855 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
37856 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
37857 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
37858 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
37859 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
37860 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
37861 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
37862 static swig_cast_info _swigc__p_wxMemorySize[] = { {&_swigt__p_wxMemorySize, 0, 0, 0},{0, 0, 0, 0}};
37863 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
37864 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
37865 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37866 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
37867 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
37868 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
37869 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
37870 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37871 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37872 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
37873 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37874 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37875 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
37876 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
37877 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
37878 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
37879 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
37880 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
37881 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
37882 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
37883 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
37884 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
37885 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
37886 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
37887 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
37888 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
37889 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
37890 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
37891 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
37892 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
37893 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
37894 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
37895 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
37896 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
37897 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
37898 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
37899 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
37900 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
37901 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
37902 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
37903 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
37904 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
37905 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
37906 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
37907 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
37908 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}};
37909 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
37910 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
37911 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
37912 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
37913 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
37914 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
37915 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
37916 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
37917 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
37918 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
37919 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
37920 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
37921 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
37922 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
37923 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
37924 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
37925 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
37926 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}};
37927 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
37928 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
37929 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
37930 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
37931 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}};
37932 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
37933 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
37934 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
37935 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}};
37936 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
37937
37938 static swig_cast_info *swig_cast_initial[] = {
37939 _swigc__p_char,
37940 _swigc__p_form_ops_t,
37941 _swigc__p_int,
37942 _swigc__p_unsigned_char,
37943 _swigc__p_unsigned_int,
37944 _swigc__p_unsigned_long,
37945 _swigc__p_void,
37946 _swigc__p_wxANIHandler,
37947 _swigc__p_wxAcceleratorTable,
37948 _swigc__p_wxActivateEvent,
37949 _swigc__p_wxArrayString,
37950 _swigc__p_wxBMPHandler,
37951 _swigc__p_wxBitmap,
37952 _swigc__p_wxBitmapDataObject,
37953 _swigc__p_wxBoxSizer,
37954 _swigc__p_wxBusyCursor,
37955 _swigc__p_wxBusyInfo,
37956 _swigc__p_wxCURHandler,
37957 _swigc__p_wxCaret,
37958 _swigc__p_wxChar,
37959 _swigc__p_wxChildFocusEvent,
37960 _swigc__p_wxClipboard,
37961 _swigc__p_wxClipboardLocker,
37962 _swigc__p_wxCloseEvent,
37963 _swigc__p_wxColour,
37964 _swigc__p_wxCommandEvent,
37965 _swigc__p_wxConfig,
37966 _swigc__p_wxConfigBase,
37967 _swigc__p_wxConfigPathChanger,
37968 _swigc__p_wxContextMenuEvent,
37969 _swigc__p_wxControl,
37970 _swigc__p_wxControlWithItems,
37971 _swigc__p_wxCursor,
37972 _swigc__p_wxCustomDataObject,
37973 _swigc__p_wxDC,
37974 _swigc__p_wxDataFormat,
37975 _swigc__p_wxDataObject,
37976 _swigc__p_wxDataObjectComposite,
37977 _swigc__p_wxDataObjectSimple,
37978 _swigc__p_wxDateEvent,
37979 _swigc__p_wxDateSpan,
37980 _swigc__p_wxDateTime,
37981 _swigc__p_wxDateTime__TimeZone,
37982 _swigc__p_wxDisplay,
37983 _swigc__p_wxDisplayChangedEvent,
37984 _swigc__p_wxDropFilesEvent,
37985 _swigc__p_wxDuplexMode,
37986 _swigc__p_wxEraseEvent,
37987 _swigc__p_wxEvent,
37988 _swigc__p_wxEvtHandler,
37989 _swigc__p_wxFSFile,
37990 _swigc__p_wxFileConfig,
37991 _swigc__p_wxFileDataObject,
37992 _swigc__p_wxFileHistory,
37993 _swigc__p_wxFileSystem,
37994 _swigc__p_wxFileType,
37995 _swigc__p_wxFileTypeInfo,
37996 _swigc__p_wxFlexGridSizer,
37997 _swigc__p_wxFocusEvent,
37998 _swigc__p_wxFont,
37999 _swigc__p_wxFrame,
38000 _swigc__p_wxGBSizerItem,
38001 _swigc__p_wxGIFHandler,
38002 _swigc__p_wxGridBagSizer,
38003 _swigc__p_wxGridSizer,
38004 _swigc__p_wxICOHandler,
38005 _swigc__p_wxIcon,
38006 _swigc__p_wxIconizeEvent,
38007 _swigc__p_wxIdleEvent,
38008 _swigc__p_wxImage,
38009 _swigc__p_wxImageHandler,
38010 _swigc__p_wxIndividualLayoutConstraint,
38011 _swigc__p_wxInitDialogEvent,
38012 _swigc__p_wxJPEGHandler,
38013 _swigc__p_wxJoystick,
38014 _swigc__p_wxJoystickEvent,
38015 _swigc__p_wxKeyEvent,
38016 _swigc__p_wxKillError,
38017 _swigc__p_wxLayoutConstraints,
38018 _swigc__p_wxLog,
38019 _swigc__p_wxLogBuffer,
38020 _swigc__p_wxLogChain,
38021 _swigc__p_wxLogGui,
38022 _swigc__p_wxLogNull,
38023 _swigc__p_wxLogStderr,
38024 _swigc__p_wxLogTextCtrl,
38025 _swigc__p_wxLogWindow,
38026 _swigc__p_wxMaximizeEvent,
38027 _swigc__p_wxMemorySize,
38028 _swigc__p_wxMenu,
38029 _swigc__p_wxMenuBar,
38030 _swigc__p_wxMenuEvent,
38031 _swigc__p_wxMenuItem,
38032 _swigc__p_wxMetafile,
38033 _swigc__p_wxMetafileDataObject,
38034 _swigc__p_wxMimeTypesManager,
38035 _swigc__p_wxMouseCaptureChangedEvent,
38036 _swigc__p_wxMouseEvent,
38037 _swigc__p_wxMouseState,
38038 _swigc__p_wxMoveEvent,
38039 _swigc__p_wxMutexGuiLocker,
38040 _swigc__p_wxNavigationKeyEvent,
38041 _swigc__p_wxNcPaintEvent,
38042 _swigc__p_wxNotifyEvent,
38043 _swigc__p_wxObject,
38044 _swigc__p_wxOutputStream,
38045 _swigc__p_wxPCXHandler,
38046 _swigc__p_wxPNGHandler,
38047 _swigc__p_wxPNMHandler,
38048 _swigc__p_wxPaintEvent,
38049 _swigc__p_wxPaletteChangedEvent,
38050 _swigc__p_wxPaperSize,
38051 _swigc__p_wxPoint,
38052 _swigc__p_wxProcessEvent,
38053 _swigc__p_wxPyApp,
38054 _swigc__p_wxPyArtProvider,
38055 _swigc__p_wxPyBitmapDataObject,
38056 _swigc__p_wxPyCommandEvent,
38057 _swigc__p_wxPyDataObjectSimple,
38058 _swigc__p_wxPyDropSource,
38059 _swigc__p_wxPyDropTarget,
38060 _swigc__p_wxPyEvent,
38061 _swigc__p_wxPyFileDropTarget,
38062 _swigc__p_wxPyImageHandler,
38063 _swigc__p_wxPyLog,
38064 _swigc__p_wxPyProcess,
38065 _swigc__p_wxPySizer,
38066 _swigc__p_wxPyTextDataObject,
38067 _swigc__p_wxPyTextDropTarget,
38068 _swigc__p_wxPyTimer,
38069 _swigc__p_wxPyTipProvider,
38070 _swigc__p_wxPyValidator,
38071 _swigc__p_wxQueryNewPaletteEvent,
38072 _swigc__p_wxRect,
38073 _swigc__p_wxScrollEvent,
38074 _swigc__p_wxScrollWinEvent,
38075 _swigc__p_wxSetCursorEvent,
38076 _swigc__p_wxShowEvent,
38077 _swigc__p_wxSingleInstanceChecker,
38078 _swigc__p_wxSize,
38079 _swigc__p_wxSizeEvent,
38080 _swigc__p_wxSizer,
38081 _swigc__p_wxSizerItem,
38082 _swigc__p_wxSound,
38083 _swigc__p_wxStandardPaths,
38084 _swigc__p_wxStaticBoxSizer,
38085 _swigc__p_wxStdDialogButtonSizer,
38086 _swigc__p_wxStopWatch,
38087 _swigc__p_wxString,
38088 _swigc__p_wxSysColourChangedEvent,
38089 _swigc__p_wxSystemOptions,
38090 _swigc__p_wxSystemSettings,
38091 _swigc__p_wxTIFFHandler,
38092 _swigc__p_wxTextCtrl,
38093 _swigc__p_wxTextDataObject,
38094 _swigc__p_wxTimeSpan,
38095 _swigc__p_wxTimer,
38096 _swigc__p_wxTimerEvent,
38097 _swigc__p_wxTimerRunner,
38098 _swigc__p_wxTipProvider,
38099 _swigc__p_wxToolTip,
38100 _swigc__p_wxURLDataObject,
38101 _swigc__p_wxUpdateUIEvent,
38102 _swigc__p_wxValidator,
38103 _swigc__p_wxVideoMode,
38104 _swigc__p_wxWindow,
38105 _swigc__p_wxWindowCreateEvent,
38106 _swigc__p_wxWindowDestroyEvent,
38107 _swigc__p_wxWindowDisabler,
38108 _swigc__p_wxXPMHandler,
38109 };
38110
38111
38112 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
38113
38114 static swig_const_info swig_const_table[] = {
38115 {0, 0, 0, 0.0, 0, 0}};
38116
38117 #ifdef __cplusplus
38118 }
38119 #endif
38120 /* -----------------------------------------------------------------------------
38121 * Type initialization:
38122 * This problem is tough by the requirement that no dynamic
38123 * memory is used. Also, since swig_type_info structures store pointers to
38124 * swig_cast_info structures and swig_cast_info structures store pointers back
38125 * to swig_type_info structures, we need some lookup code at initialization.
38126 * The idea is that swig generates all the structures that are needed.
38127 * The runtime then collects these partially filled structures.
38128 * The SWIG_InitializeModule function takes these initial arrays out of
38129 * swig_module, and does all the lookup, filling in the swig_module.types
38130 * array with the correct data and linking the correct swig_cast_info
38131 * structures together.
38132 *
38133 * The generated swig_type_info structures are assigned staticly to an initial
38134 * array. We just loop though that array, and handle each type individually.
38135 * First we lookup if this type has been already loaded, and if so, use the
38136 * loaded structure instead of the generated one. Then we have to fill in the
38137 * cast linked list. The cast data is initially stored in something like a
38138 * two-dimensional array. Each row corresponds to a type (there are the same
38139 * number of rows as there are in the swig_type_initial array). Each entry in
38140 * a column is one of the swig_cast_info structures for that type.
38141 * The cast_initial array is actually an array of arrays, because each row has
38142 * a variable number of columns. So to actually build the cast linked list,
38143 * we find the array of casts associated with the type, and loop through it
38144 * adding the casts to the list. The one last trick we need to do is making
38145 * sure the type pointer in the swig_cast_info struct is correct.
38146 *
38147 * First off, we lookup the cast->type name to see if it is already loaded.
38148 * There are three cases to handle:
38149 * 1) If the cast->type has already been loaded AND the type we are adding
38150 * casting info to has not been loaded (it is in this module), THEN we
38151 * replace the cast->type pointer with the type pointer that has already
38152 * been loaded.
38153 * 2) If BOTH types (the one we are adding casting info to, and the
38154 * cast->type) are loaded, THEN the cast info has already been loaded by
38155 * the previous module so we just ignore it.
38156 * 3) Finally, if cast->type has not already been loaded, then we add that
38157 * swig_cast_info to the linked list (because the cast->type) pointer will
38158 * be correct.
38159 * ----------------------------------------------------------------------------- */
38160
38161 #ifdef __cplusplus
38162 extern "C" {
38163 #if 0
38164 } /* c-mode */
38165 #endif
38166 #endif
38167
38168 #if 0
38169 #define SWIGRUNTIME_DEBUG
38170 #endif
38171
38172 SWIGRUNTIME void
38173 SWIG_InitializeModule(void *clientdata) {
38174 size_t i;
38175 swig_module_info *module_head;
38176 static int init_run = 0;
38177
38178 clientdata = clientdata;
38179
38180 if (init_run) return;
38181 init_run = 1;
38182
38183 /* Initialize the swig_module */
38184 swig_module.type_initial = swig_type_initial;
38185 swig_module.cast_initial = swig_cast_initial;
38186
38187 /* Try and load any already created modules */
38188 module_head = SWIG_GetModule(clientdata);
38189 if (module_head) {
38190 swig_module.next = module_head->next;
38191 module_head->next = &swig_module;
38192 } else {
38193 /* This is the first module loaded */
38194 swig_module.next = &swig_module;
38195 SWIG_SetModule(clientdata, &swig_module);
38196 }
38197
38198 /* Now work on filling in swig_module.types */
38199 #ifdef SWIGRUNTIME_DEBUG
38200 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
38201 #endif
38202 for (i = 0; i < swig_module.size; ++i) {
38203 swig_type_info *type = 0;
38204 swig_type_info *ret;
38205 swig_cast_info *cast;
38206
38207 #ifdef SWIGRUNTIME_DEBUG
38208 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38209 #endif
38210
38211 /* if there is another module already loaded */
38212 if (swig_module.next != &swig_module) {
38213 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
38214 }
38215 if (type) {
38216 /* Overwrite clientdata field */
38217 #ifdef SWIGRUNTIME_DEBUG
38218 printf("SWIG_InitializeModule: found type %s\n", type->name);
38219 #endif
38220 if (swig_module.type_initial[i]->clientdata) {
38221 type->clientdata = swig_module.type_initial[i]->clientdata;
38222 #ifdef SWIGRUNTIME_DEBUG
38223 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
38224 #endif
38225 }
38226 } else {
38227 type = swig_module.type_initial[i];
38228 }
38229
38230 /* Insert casting types */
38231 cast = swig_module.cast_initial[i];
38232 while (cast->type) {
38233 /* Don't need to add information already in the list */
38234 ret = 0;
38235 #ifdef SWIGRUNTIME_DEBUG
38236 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
38237 #endif
38238 if (swig_module.next != &swig_module) {
38239 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
38240 #ifdef SWIGRUNTIME_DEBUG
38241 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
38242 #endif
38243 }
38244 if (ret) {
38245 if (type == swig_module.type_initial[i]) {
38246 #ifdef SWIGRUNTIME_DEBUG
38247 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
38248 #endif
38249 cast->type = ret;
38250 ret = 0;
38251 } else {
38252 /* Check for casting already in the list */
38253 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
38254 #ifdef SWIGRUNTIME_DEBUG
38255 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
38256 #endif
38257 if (!ocast) ret = 0;
38258 }
38259 }
38260
38261 if (!ret) {
38262 #ifdef SWIGRUNTIME_DEBUG
38263 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
38264 #endif
38265 if (type->cast) {
38266 type->cast->prev = cast;
38267 cast->next = type->cast;
38268 }
38269 type->cast = cast;
38270 }
38271 cast++;
38272 }
38273 /* Set entry in modules->types array equal to the type */
38274 swig_module.types[i] = type;
38275 }
38276 swig_module.types[i] = 0;
38277
38278 #ifdef SWIGRUNTIME_DEBUG
38279 printf("**** SWIG_InitializeModule: Cast List ******\n");
38280 for (i = 0; i < swig_module.size; ++i) {
38281 int j = 0;
38282 swig_cast_info *cast = swig_module.cast_initial[i];
38283 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38284 while (cast->type) {
38285 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
38286 cast++;
38287 ++j;
38288 }
38289 printf("---- Total casts: %d\n",j);
38290 }
38291 printf("**** SWIG_InitializeModule: Cast List ******\n");
38292 #endif
38293 }
38294
38295 /* This function will propagate the clientdata field of type to
38296 * any new swig_type_info structures that have been added into the list
38297 * of equivalent types. It is like calling
38298 * SWIG_TypeClientData(type, clientdata) a second time.
38299 */
38300 SWIGRUNTIME void
38301 SWIG_PropagateClientData(void) {
38302 size_t i;
38303 swig_cast_info *equiv;
38304 static int init_run = 0;
38305
38306 if (init_run) return;
38307 init_run = 1;
38308
38309 for (i = 0; i < swig_module.size; i++) {
38310 if (swig_module.types[i]->clientdata) {
38311 equiv = swig_module.types[i]->cast;
38312 while (equiv) {
38313 if (!equiv->converter) {
38314 if (equiv->type && !equiv->type->clientdata)
38315 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
38316 }
38317 equiv = equiv->next;
38318 }
38319 }
38320 }
38321 }
38322
38323 #ifdef __cplusplus
38324 #if 0
38325 {
38326 /* c-mode */
38327 #endif
38328 }
38329 #endif
38330
38331
38332
38333 #ifdef __cplusplus
38334 extern "C" {
38335 #endif
38336
38337 /* Python-specific SWIG API */
38338 #define SWIG_newvarlink() SWIG_Python_newvarlink()
38339 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
38340 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
38341
38342 /* -----------------------------------------------------------------------------
38343 * global variable support code.
38344 * ----------------------------------------------------------------------------- */
38345
38346 typedef struct swig_globalvar {
38347 char *name; /* Name of global variable */
38348 PyObject *(*get_attr)(void); /* Return the current value */
38349 int (*set_attr)(PyObject *); /* Set the value */
38350 struct swig_globalvar *next;
38351 } swig_globalvar;
38352
38353 typedef struct swig_varlinkobject {
38354 PyObject_HEAD
38355 swig_globalvar *vars;
38356 } swig_varlinkobject;
38357
38358 SWIGINTERN PyObject *
38359 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
38360 return PyString_FromString("<Swig global variables>");
38361 }
38362
38363 SWIGINTERN PyObject *
38364 swig_varlink_str(swig_varlinkobject *v) {
38365 PyObject *str = PyString_FromString("(");
38366 swig_globalvar *var;
38367 for (var = v->vars; var; var=var->next) {
38368 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
38369 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
38370 }
38371 PyString_ConcatAndDel(&str,PyString_FromString(")"));
38372 return str;
38373 }
38374
38375 SWIGINTERN int
38376 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
38377 PyObject *str = swig_varlink_str(v);
38378 fprintf(fp,"Swig global variables ");
38379 fprintf(fp,"%s\n", PyString_AsString(str));
38380 Py_DECREF(str);
38381 return 0;
38382 }
38383
38384 SWIGINTERN void
38385 swig_varlink_dealloc(swig_varlinkobject *v) {
38386 swig_globalvar *var = v->vars;
38387 while (var) {
38388 swig_globalvar *n = var->next;
38389 free(var->name);
38390 free(var);
38391 var = n;
38392 }
38393 }
38394
38395 SWIGINTERN PyObject *
38396 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
38397 PyObject *res = NULL;
38398 swig_globalvar *var = v->vars;
38399 while (var) {
38400 if (strcmp(var->name,n) == 0) {
38401 res = (*var->get_attr)();
38402 break;
38403 }
38404 var = var->next;
38405 }
38406 if (res == NULL && !PyErr_Occurred()) {
38407 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38408 }
38409 return res;
38410 }
38411
38412 SWIGINTERN int
38413 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
38414 int res = 1;
38415 swig_globalvar *var = v->vars;
38416 while (var) {
38417 if (strcmp(var->name,n) == 0) {
38418 res = (*var->set_attr)(p);
38419 break;
38420 }
38421 var = var->next;
38422 }
38423 if (res == 1 && !PyErr_Occurred()) {
38424 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38425 }
38426 return res;
38427 }
38428
38429 SWIGINTERN PyTypeObject*
38430 swig_varlink_type(void) {
38431 static char varlink__doc__[] = "Swig var link object";
38432 static PyTypeObject varlink_type;
38433 static int type_init = 0;
38434 if (!type_init) {
38435 const PyTypeObject tmp
38436 = {
38437 PyObject_HEAD_INIT(NULL)
38438 0, /* Number of items in variable part (ob_size) */
38439 (char *)"swigvarlink", /* Type name (tp_name) */
38440 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
38441 0, /* Itemsize (tp_itemsize) */
38442 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
38443 (printfunc) swig_varlink_print, /* Print (tp_print) */
38444 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
38445 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
38446 0, /* tp_compare */
38447 (reprfunc) swig_varlink_repr, /* tp_repr */
38448 0, /* tp_as_number */
38449 0, /* tp_as_sequence */
38450 0, /* tp_as_mapping */
38451 0, /* tp_hash */
38452 0, /* tp_call */
38453 (reprfunc)swig_varlink_str, /* tp_str */
38454 0, /* tp_getattro */
38455 0, /* tp_setattro */
38456 0, /* tp_as_buffer */
38457 0, /* tp_flags */
38458 varlink__doc__, /* tp_doc */
38459 0, /* tp_traverse */
38460 0, /* tp_clear */
38461 0, /* tp_richcompare */
38462 0, /* tp_weaklistoffset */
38463 #if PY_VERSION_HEX >= 0x02020000
38464 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
38465 #endif
38466 #if PY_VERSION_HEX >= 0x02030000
38467 0, /* tp_del */
38468 #endif
38469 #ifdef COUNT_ALLOCS
38470 0,0,0,0 /* tp_alloc -> tp_next */
38471 #endif
38472 };
38473 varlink_type = tmp;
38474 varlink_type.ob_type = &PyType_Type;
38475 type_init = 1;
38476 }
38477 return &varlink_type;
38478 }
38479
38480 /* Create a variable linking object for use later */
38481 SWIGINTERN PyObject *
38482 SWIG_Python_newvarlink(void) {
38483 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
38484 if (result) {
38485 result->vars = 0;
38486 }
38487 return ((PyObject*) result);
38488 }
38489
38490 SWIGINTERN void
38491 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
38492 swig_varlinkobject *v = (swig_varlinkobject *) p;
38493 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
38494 if (gv) {
38495 size_t size = strlen(name)+1;
38496 gv->name = (char *)malloc(size);
38497 if (gv->name) {
38498 strncpy(gv->name,name,size);
38499 gv->get_attr = get_attr;
38500 gv->set_attr = set_attr;
38501 gv->next = v->vars;
38502 }
38503 }
38504 v->vars = gv;
38505 }
38506
38507 SWIGINTERN PyObject *
38508 SWIG_globals() {
38509 static PyObject *_SWIG_globals = 0;
38510 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
38511 return _SWIG_globals;
38512 }
38513
38514 /* -----------------------------------------------------------------------------
38515 * constants/methods manipulation
38516 * ----------------------------------------------------------------------------- */
38517
38518 /* Install Constants */
38519 SWIGINTERN void
38520 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
38521 PyObject *obj = 0;
38522 size_t i;
38523 for (i = 0; constants[i].type; ++i) {
38524 switch(constants[i].type) {
38525 case SWIG_PY_POINTER:
38526 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
38527 break;
38528 case SWIG_PY_BINARY:
38529 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
38530 break;
38531 default:
38532 obj = 0;
38533 break;
38534 }
38535 if (obj) {
38536 PyDict_SetItemString(d, constants[i].name, obj);
38537 Py_DECREF(obj);
38538 }
38539 }
38540 }
38541
38542 /* -----------------------------------------------------------------------------*/
38543 /* Fix SwigMethods to carry the callback ptrs when needed */
38544 /* -----------------------------------------------------------------------------*/
38545
38546 SWIGINTERN void
38547 SWIG_Python_FixMethods(PyMethodDef *methods,
38548 swig_const_info *const_table,
38549 swig_type_info **types,
38550 swig_type_info **types_initial) {
38551 size_t i;
38552 for (i = 0; methods[i].ml_name; ++i) {
38553 char *c = methods[i].ml_doc;
38554 if (c && (c = strstr(c, "swig_ptr: "))) {
38555 int j;
38556 swig_const_info *ci = 0;
38557 char *name = c + 10;
38558 for (j = 0; const_table[j].type; ++j) {
38559 if (strncmp(const_table[j].name, name,
38560 strlen(const_table[j].name)) == 0) {
38561 ci = &(const_table[j]);
38562 break;
38563 }
38564 }
38565 if (ci) {
38566 size_t shift = (ci->ptype) - types;
38567 swig_type_info *ty = types_initial[shift];
38568 size_t ldoc = (c - methods[i].ml_doc);
38569 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
38570 char *ndoc = (char*)malloc(ldoc + lptr + 10);
38571 if (ndoc) {
38572 char *buff = ndoc;
38573 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
38574 if (ptr) {
38575 strncpy(buff, methods[i].ml_doc, ldoc);
38576 buff += ldoc;
38577 strncpy(buff, "swig_ptr: ", 10);
38578 buff += 10;
38579 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
38580 methods[i].ml_doc = ndoc;
38581 }
38582 }
38583 }
38584 }
38585 }
38586 }
38587
38588 #ifdef __cplusplus
38589 }
38590 #endif
38591
38592 /* -----------------------------------------------------------------------------*
38593 * Partial Init method
38594 * -----------------------------------------------------------------------------*/
38595
38596 #ifdef __cplusplus
38597 extern "C"
38598 #endif
38599 SWIGEXPORT void SWIG_init(void) {
38600 PyObject *m, *d;
38601
38602 /* Fix SwigMethods to carry the callback ptrs when needed */
38603 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
38604
38605 m = Py_InitModule((char *) SWIG_name, SwigMethods);
38606 d = PyModule_GetDict(m);
38607
38608 SWIG_InitializeModule(0);
38609 SWIG_InstallConstants(d,swig_const_table);
38610
38611
38612 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
38613 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
38614 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
38615 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
38616 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
38617 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
38618 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
38619 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
38620 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
38621 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
38622 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
38623 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
38624 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
38625 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
38626 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
38627 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
38628 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
38629 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
38630 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
38631 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
38632 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
38633 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
38634 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
38635 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
38636 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
38637 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
38638 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
38639 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
38640 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
38641 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
38642 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
38643 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
38644 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
38645 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
38646 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
38647 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
38648 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
38649 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
38650 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
38651 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
38652 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
38653 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
38654 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
38655 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
38656 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
38657 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
38658 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
38659 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
38660 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
38661 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
38662 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
38663 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
38664 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
38665 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
38666 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
38667 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
38668 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
38669 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
38670 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
38671 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
38672 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
38673 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
38674 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
38675 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
38676 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
38677 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
38678 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
38679 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
38680 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
38681 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
38682 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
38683 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
38684 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
38685 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
38686 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
38687 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
38688 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
38689 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
38690 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
38691 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
38692 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
38693 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
38694 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
38695 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
38696 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
38697 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
38698 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
38699 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
38700 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
38701 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
38702 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
38703 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
38704 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
38705 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
38706 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
38707 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
38708 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
38709 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
38710 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
38711 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
38712 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
38713 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
38714
38715 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
38716
38717 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
38718 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
38719 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
38720 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
38721 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
38722 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
38723 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
38724 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
38725 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
38726 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
38727 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
38728 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
38729 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
38730 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
38731 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
38732 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
38733 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
38734 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
38735 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
38736 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
38737 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
38738 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
38739 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
38740 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
38741 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
38742 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
38743 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
38744 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
38745 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
38746 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
38747 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
38748 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
38749 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
38750 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
38751 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
38752 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
38753 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
38754 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
38755 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
38756 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
38757 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
38758 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
38759 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
38760 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
38761 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
38762 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
38763 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
38764 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
38765 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
38766 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
38767 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
38768 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
38769 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
38770
38771 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
38772
38773 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
38774 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
38775 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
38776 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
38777 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
38778 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
38779 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
38780 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
38781 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
38782 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
38783 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
38784 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
38785 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
38786 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
38787 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
38788 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
38789 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
38790 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
38791 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
38792 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
38793 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
38794 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
38795 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
38796 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
38797 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
38798 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
38799 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
38800 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
38801 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
38802 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
38803 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
38804 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
38805 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
38806 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
38807 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
38808 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
38809 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
38810 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
38811 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
38812 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
38813 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
38814 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
38815 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
38816 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
38817 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
38818 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
38819 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
38820 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
38821 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
38822 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
38823 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
38824 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
38825 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
38826 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
38827 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
38828 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
38829 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
38830 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
38831 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
38832 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
38833 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
38834 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
38835 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
38836 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
38837 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
38838 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
38839 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
38840 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
38841 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
38842 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
38843 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
38844 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
38845 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
38846 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
38847 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
38848 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
38849
38850 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
38851
38852 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
38853 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
38854 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
38855 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
38856 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
38857 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
38858 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
38859 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
38860 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
38861 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
38862 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
38863 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
38864 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
38865 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
38866 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
38867 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
38868 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
38869 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
38870 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
38871 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
38872 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
38873 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
38874 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
38875 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
38876 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
38877 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
38878 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
38879 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
38880 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
38881 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
38882 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
38883 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
38884 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
38885 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
38886 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
38887 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
38888 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
38889 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
38890 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
38891 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
38892 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
38893 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
38894 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
38895 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
38896 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
38897 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
38898 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
38899 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
38900 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
38901 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
38902 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
38903 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
38904 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
38905 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
38906 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
38907 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
38908 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
38909 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
38910 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
38911 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
38912 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
38913 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
38914 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
38915 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
38916 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
38917 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
38918 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
38919 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
38920 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
38921 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
38922 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
38923 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
38924 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
38925 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
38926 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
38927 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
38928 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
38929 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
38930 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
38931 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
38932 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
38933 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
38934 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
38935 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
38936 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
38937 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
38938 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
38939 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
38940 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
38941 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
38942 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
38943 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
38944 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
38945 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
38946 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
38947 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
38948 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
38949 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
38950 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
38951 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
38952 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
38953 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
38954 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
38955 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
38956 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
38957 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
38958 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
38959 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
38960 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
38961 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
38962 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
38963 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
38964 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
38965 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
38966 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
38967 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
38968 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
38969 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
38970 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
38971 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
38972 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
38973 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
38974 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
38975 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
38976 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
38977 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
38978 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
38979 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
38980 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
38981 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
38982 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
38983 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
38984 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
38985 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
38986 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
38987 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
38988 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
38989 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
38990 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
38991 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
38992 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
38993 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
38994 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
38995 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
38996 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
38997 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
38998 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
38999 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
39000 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
39001 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
39002 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
39003 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
39004 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
39005 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
39006 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
39007 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
39008 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
39009 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
39010 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
39011 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
39012 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
39013 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
39014 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
39015 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
39016 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
39017 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
39018 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
39019 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
39020 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
39021 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
39022 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
39023 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
39024 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
39025 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
39026 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
39027 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
39028 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
39029 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
39030 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
39031 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
39032 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
39033 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
39034 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
39035 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
39036 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
39037 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
39038 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
39039 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
39040 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
39041 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
39042 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
39043 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
39044 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
39045 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
39046 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
39047 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
39048 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
39049 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
39050 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
39051 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
39052
39053 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
39054 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
39055 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
39056 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
39057
39058 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
39059 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
39060 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
39061 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
39062 }
39063
wxWidgets (Impactor)