]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
added wxArtProvider::InsertProvider to accompany PushProvider
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2475 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2476 #define SWIGTYPE_p_wxArrayString swig_types[10]
2477 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2478 #define SWIGTYPE_p_wxBitmap swig_types[12]
2479 #define SWIGTYPE_p_wxBitmapDataObject swig_types[13]
2480 #define SWIGTYPE_p_wxBoxSizer swig_types[14]
2481 #define SWIGTYPE_p_wxBusyCursor swig_types[15]
2482 #define SWIGTYPE_p_wxBusyInfo swig_types[16]
2483 #define SWIGTYPE_p_wxCURHandler swig_types[17]
2484 #define SWIGTYPE_p_wxCaret swig_types[18]
2485 #define SWIGTYPE_p_wxChar swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboard swig_types[21]
2488 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[23]
2490 #define SWIGTYPE_p_wxCloseEvent swig_types[24]
2491 #define SWIGTYPE_p_wxColour swig_types[25]
2492 #define SWIGTYPE_p_wxCommandEvent swig_types[26]
2493 #define SWIGTYPE_p_wxConfig swig_types[27]
2494 #define SWIGTYPE_p_wxConfigBase swig_types[28]
2495 #define SWIGTYPE_p_wxConfigPathChanger swig_types[29]
2496 #define SWIGTYPE_p_wxContextMenuEvent swig_types[30]
2497 #define SWIGTYPE_p_wxControl swig_types[31]
2498 #define SWIGTYPE_p_wxControlWithItems swig_types[32]
2499 #define SWIGTYPE_p_wxCursor swig_types[33]
2500 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
2501 #define SWIGTYPE_p_wxDC swig_types[35]
2502 #define SWIGTYPE_p_wxDataFormat swig_types[36]
2503 #define SWIGTYPE_p_wxDataObject swig_types[37]
2504 #define SWIGTYPE_p_wxDataObjectComposite swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectSimple swig_types[39]
2506 #define SWIGTYPE_p_wxDateEvent swig_types[40]
2507 #define SWIGTYPE_p_wxDateSpan swig_types[41]
2508 #define SWIGTYPE_p_wxDateTime swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[43]
2510 #define SWIGTYPE_p_wxDisplay swig_types[44]
2511 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[45]
2512 #define SWIGTYPE_p_wxDropFilesEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDuplexMode swig_types[47]
2514 #define SWIGTYPE_p_wxEraseEvent swig_types[48]
2515 #define SWIGTYPE_p_wxEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvtHandler swig_types[50]
2517 #define SWIGTYPE_p_wxFSFile swig_types[51]
2518 #define SWIGTYPE_p_wxFileConfig swig_types[52]
2519 #define SWIGTYPE_p_wxFileDataObject swig_types[53]
2520 #define SWIGTYPE_p_wxFileHistory swig_types[54]
2521 #define SWIGTYPE_p_wxFileSystem swig_types[55]
2522 #define SWIGTYPE_p_wxFileType swig_types[56]
2523 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
2524 #define SWIGTYPE_p_wxFlexGridSizer swig_types[58]
2525 #define SWIGTYPE_p_wxFocusEvent swig_types[59]
2526 #define SWIGTYPE_p_wxFont swig_types[60]
2527 #define SWIGTYPE_p_wxFrame swig_types[61]
2528 #define SWIGTYPE_p_wxGBSizerItem swig_types[62]
2529 #define SWIGTYPE_p_wxGIFHandler swig_types[63]
2530 #define SWIGTYPE_p_wxGridBagSizer swig_types[64]
2531 #define SWIGTYPE_p_wxGridSizer swig_types[65]
2532 #define SWIGTYPE_p_wxICOHandler swig_types[66]
2533 #define SWIGTYPE_p_wxIcon swig_types[67]
2534 #define SWIGTYPE_p_wxIconizeEvent swig_types[68]
2535 #define SWIGTYPE_p_wxIdleEvent swig_types[69]
2536 #define SWIGTYPE_p_wxImage swig_types[70]
2537 #define SWIGTYPE_p_wxImageHandler swig_types[71]
2538 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[72]
2539 #define SWIGTYPE_p_wxInitDialogEvent swig_types[73]
2540 #define SWIGTYPE_p_wxJPEGHandler swig_types[74]
2541 #define SWIGTYPE_p_wxJoystick swig_types[75]
2542 #define SWIGTYPE_p_wxJoystickEvent swig_types[76]
2543 #define SWIGTYPE_p_wxKeyEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKillError swig_types[78]
2545 #define SWIGTYPE_p_wxLayoutConstraints swig_types[79]
2546 #define SWIGTYPE_p_wxLog swig_types[80]
2547 #define SWIGTYPE_p_wxLogBuffer swig_types[81]
2548 #define SWIGTYPE_p_wxLogChain swig_types[82]
2549 #define SWIGTYPE_p_wxLogGui swig_types[83]
2550 #define SWIGTYPE_p_wxLogNull swig_types[84]
2551 #define SWIGTYPE_p_wxLogStderr swig_types[85]
2552 #define SWIGTYPE_p_wxLogTextCtrl swig_types[86]
2553 #define SWIGTYPE_p_wxLogWindow swig_types[87]
2554 #define SWIGTYPE_p_wxMaximizeEvent swig_types[88]
2555 #define SWIGTYPE_p_wxMenu swig_types[89]
2556 #define SWIGTYPE_p_wxMenuBar swig_types[90]
2557 #define SWIGTYPE_p_wxMenuEvent swig_types[91]
2558 #define SWIGTYPE_p_wxMenuItem swig_types[92]
2559 #define SWIGTYPE_p_wxMetafile swig_types[93]
2560 #define SWIGTYPE_p_wxMetafileDataObject swig_types[94]
2561 #define SWIGTYPE_p_wxMimeTypesManager swig_types[95]
2562 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseState swig_types[99]
2566 #define SWIGTYPE_p_wxMoveEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[101]
2568 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[102]
2569 #define SWIGTYPE_p_wxNcPaintEvent swig_types[103]
2570 #define SWIGTYPE_p_wxNotifyEvent swig_types[104]
2571 #define SWIGTYPE_p_wxObject swig_types[105]
2572 #define SWIGTYPE_p_wxOutputStream swig_types[106]
2573 #define SWIGTYPE_p_wxPCXHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPNGHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNMHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPaintEvent swig_types[110]
2577 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[111]
2578 #define SWIGTYPE_p_wxPaperSize swig_types[112]
2579 #define SWIGTYPE_p_wxPlatformInfo swig_types[113]
2580 #define SWIGTYPE_p_wxPoint swig_types[114]
2581 #define SWIGTYPE_p_wxPowerEvent swig_types[115]
2582 #define SWIGTYPE_p_wxProcessEvent swig_types[116]
2583 #define SWIGTYPE_p_wxPyApp swig_types[117]
2584 #define SWIGTYPE_p_wxPyArtProvider swig_types[118]
2585 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[119]
2586 #define SWIGTYPE_p_wxPyCommandEvent swig_types[120]
2587 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[121]
2588 #define SWIGTYPE_p_wxPyDropSource swig_types[122]
2589 #define SWIGTYPE_p_wxPyDropTarget swig_types[123]
2590 #define SWIGTYPE_p_wxPyEvent swig_types[124]
2591 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[125]
2592 #define SWIGTYPE_p_wxPyImageHandler swig_types[126]
2593 #define SWIGTYPE_p_wxPyLog swig_types[127]
2594 #define SWIGTYPE_p_wxPyProcess swig_types[128]
2595 #define SWIGTYPE_p_wxPySizer swig_types[129]
2596 #define SWIGTYPE_p_wxPyTextDataObject swig_types[130]
2597 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[131]
2598 #define SWIGTYPE_p_wxPyTimer swig_types[132]
2599 #define SWIGTYPE_p_wxPyTipProvider swig_types[133]
2600 #define SWIGTYPE_p_wxPyValidator swig_types[134]
2601 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[135]
2602 #define SWIGTYPE_p_wxRect swig_types[136]
2603 #define SWIGTYPE_p_wxScrollEvent swig_types[137]
2604 #define SWIGTYPE_p_wxScrollWinEvent swig_types[138]
2605 #define SWIGTYPE_p_wxSetCursorEvent swig_types[139]
2606 #define SWIGTYPE_p_wxShowEvent swig_types[140]
2607 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[141]
2608 #define SWIGTYPE_p_wxSize swig_types[142]
2609 #define SWIGTYPE_p_wxSizeEvent swig_types[143]
2610 #define SWIGTYPE_p_wxSizer swig_types[144]
2611 #define SWIGTYPE_p_wxSizerItem swig_types[145]
2612 #define SWIGTYPE_p_wxSound swig_types[146]
2613 #define SWIGTYPE_p_wxStandardPaths swig_types[147]
2614 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[148]
2615 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[149]
2616 #define SWIGTYPE_p_wxStopWatch swig_types[150]
2617 #define SWIGTYPE_p_wxString swig_types[151]
2618 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[152]
2619 #define SWIGTYPE_p_wxSystemOptions swig_types[153]
2620 #define SWIGTYPE_p_wxSystemSettings swig_types[154]
2621 #define SWIGTYPE_p_wxTIFFHandler swig_types[155]
2622 #define SWIGTYPE_p_wxTextCtrl swig_types[156]
2623 #define SWIGTYPE_p_wxTextDataObject swig_types[157]
2624 #define SWIGTYPE_p_wxTimeSpan swig_types[158]
2625 #define SWIGTYPE_p_wxTimer swig_types[159]
2626 #define SWIGTYPE_p_wxTimerEvent swig_types[160]
2627 #define SWIGTYPE_p_wxTimerRunner swig_types[161]
2628 #define SWIGTYPE_p_wxTipProvider swig_types[162]
2629 #define SWIGTYPE_p_wxToolTip swig_types[163]
2630 #define SWIGTYPE_p_wxURLDataObject swig_types[164]
2631 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[165]
2632 #define SWIGTYPE_p_wxValidator swig_types[166]
2633 #define SWIGTYPE_p_wxVideoMode swig_types[167]
2634 #define SWIGTYPE_p_wxWindow swig_types[168]
2635 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[169]
2636 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[170]
2637 #define SWIGTYPE_p_wxWindowDisabler swig_types[171]
2638 #define SWIGTYPE_p_wxXPMHandler swig_types[172]
2639 static swig_type_info *swig_types[174];
2640 static swig_module_info swig_module = {swig_types, 173, 0, 0, 0, 0};
2641 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2642 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2643
2644 /* -------- TYPES TABLE (END) -------- */
2645
2646 #if (PY_VERSION_HEX <= 0x02000000)
2647 # if !defined(SWIG_PYTHON_CLASSIC)
2648 # error "This python version requires to use swig with the '-classic' option"
2649 # endif
2650 #endif
2651 #if (PY_VERSION_HEX <= 0x02020000)
2652 # error "This python version requires to use swig with the '-nomodern' option"
2653 #endif
2654 #if (PY_VERSION_HEX <= 0x02020000)
2655 # error "This python version requires to use swig with the '-nomodernargs' option"
2656 #endif
2657 #ifndef METH_O
2658 # error "This python version requires to use swig with the '-nofastunpack' option"
2659 #endif
2660
2661 /*-----------------------------------------------
2662 @(target):= _misc_.so
2663 ------------------------------------------------*/
2664 #define SWIG_init init_misc_
2665
2666 #define SWIG_name "_misc_"
2667
2668 #define SWIGVERSION 0x010329
2669
2670
2671 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2672 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2673
2674
2675 #include <stdexcept>
2676
2677
2678 namespace swig {
2679 class PyObject_ptr {
2680 protected:
2681 PyObject *_obj;
2682
2683 public:
2684 PyObject_ptr() :_obj(0)
2685 {
2686 }
2687
2688 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2689 {
2690 Py_XINCREF(_obj);
2691 }
2692
2693 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2694 {
2695 if (initial_ref) Py_XINCREF(_obj);
2696 }
2697
2698 PyObject_ptr & operator=(const PyObject_ptr& item)
2699 {
2700 Py_XINCREF(item._obj);
2701 Py_XDECREF(_obj);
2702 _obj = item._obj;
2703 return *this;
2704 }
2705
2706 ~PyObject_ptr()
2707 {
2708 Py_XDECREF(_obj);
2709 }
2710
2711 operator PyObject *() const
2712 {
2713 return _obj;
2714 }
2715
2716 PyObject *operator->() const
2717 {
2718 return _obj;
2719 }
2720 };
2721 }
2722
2723
2724 namespace swig {
2725 struct PyObject_var : PyObject_ptr {
2726 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2727
2728 PyObject_var & operator = (PyObject* obj)
2729 {
2730 Py_XDECREF(_obj);
2731 _obj = obj;
2732 return *this;
2733 }
2734 };
2735 }
2736
2737
2738 #include "wx/wxPython/wxPython.h"
2739 #include "wx/wxPython/pyclasses.h"
2740 #include "wx/wxPython/pyistream.h"
2741
2742 static const wxString wxPyEmptyString(wxEmptyString);
2743
2744
2745
2746 #define SWIG_From_long PyInt_FromLong
2747
2748
2749 SWIGINTERNINLINE PyObject *
2750 SWIG_From_int (int value)
2751 {
2752 return SWIG_From_long (value);
2753 }
2754
2755
2756 #include <limits.h>
2757 #ifndef LLONG_MIN
2758 # define LLONG_MIN LONG_LONG_MIN
2759 #endif
2760 #ifndef LLONG_MAX
2761 # define LLONG_MAX LONG_LONG_MAX
2762 #endif
2763 #ifndef ULLONG_MAX
2764 # define ULLONG_MAX ULONG_LONG_MAX
2765 #endif
2766
2767
2768 SWIGINTERN int
2769 SWIG_AsVal_long (PyObject* obj, long* val)
2770 {
2771 if (PyNumber_Check(obj)) {
2772 if (val) *val = PyInt_AsLong(obj);
2773 return SWIG_OK;
2774 }
2775 return SWIG_TypeError;
2776 }
2777
2778
2779 SWIGINTERN int
2780 SWIG_AsVal_int (PyObject * obj, int *val)
2781 {
2782 long v;
2783 int res = SWIG_AsVal_long (obj, &v);
2784 if (SWIG_IsOK(res)) {
2785 if ((v < INT_MIN || v > INT_MAX)) {
2786 return SWIG_OverflowError;
2787 } else {
2788 if (val) *val = static_cast< int >(v);
2789 }
2790 }
2791 return res;
2792 }
2793
2794 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2795
2796 #include <wx/stockitem.h>
2797
2798 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2799 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2800 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2801
2802 SWIGINTERN int
2803 SWIG_AsVal_bool (PyObject *obj, bool *val)
2804 {
2805 if (obj == Py_True) {
2806 if (val) *val = true;
2807 return SWIG_OK;
2808 } else if (obj == Py_False) {
2809 if (val) *val = false;
2810 return SWIG_OK;
2811 } else {
2812 long v = 0;
2813 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2814 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2815 return res;
2816 }
2817 }
2818
2819
2820 SWIGINTERN int
2821 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2822 {
2823 long v = 0;
2824 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2825 return SWIG_TypeError;
2826 }
2827 else if (val)
2828 *val = (unsigned long)v;
2829 return SWIG_OK;
2830 }
2831
2832
2833 SWIGINTERNINLINE PyObject*
2834 SWIG_From_unsigned_SS_long (unsigned long value)
2835 {
2836 return (value > LONG_MAX) ?
2837 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2838 }
2839
2840
2841 void* wxGetXDisplay()
2842 {
2843 #ifdef __WXGTK__
2844 return wxGetDisplay();
2845 #else
2846 return NULL;
2847 #endif
2848 }
2849
2850
2851 wxWindow* FindWindowAtPointer() {
2852 wxPoint unused;
2853 return wxFindWindowAtPointer(unused);
2854 }
2855
2856
2857 bool wxThread_IsMain() {
2858 #ifdef WXP_WITH_THREAD
2859 return wxThread::IsMain();
2860 #else
2861 return true;
2862 #endif
2863 }
2864
2865 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2866 delete self;
2867 }
2868
2869 #include <wx/snglinst.h>
2870
2871
2872 #ifdef __WXMSW__
2873 #include <wx/msw/private.h>
2874 #include <wx/dynload.h>
2875 #endif
2876
2877
2878
2879 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2880 #if 0
2881 , int method
2882 #endif
2883 )
2884 {
2885 #ifdef __WXMSW__
2886 #if 0
2887 switch (method)
2888 {
2889 case 1:
2890 // This one only partially works. Appears to be an undocumented
2891 // "standard" convention that not all widgets adhear to. For
2892 // example, for some widgets backgrounds or non-client areas may
2893 // not be painted.
2894 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2895 break;
2896
2897 case 2:
2898 #endif
2899 // This one works much better, nearly all widgets and their
2900 // children are captured correctly[**]. Prior to the big
2901 // background erase changes that Vadim did in 2004-2005 this
2902 // method failed badly on XP with Themes activated, most native
2903 // widgets draw only partially, if at all. Without themes it
2904 // worked just like on Win2k. After those changes this method
2905 // works very well.
2906 //
2907 // ** For example the radio buttons in a wxRadioBox are not its
2908 // children by default, but you can capture it via the panel
2909 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2910 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2911 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2912 PRF_ERASEBKGND | PRF_OWNED );
2913 return true;
2914 #if 0
2915 break;
2916
2917 case 3:
2918 // This one is only defined in the latest SDK and is only
2919 // available on XP. MSDN says it is similar to sending WM_PRINT
2920 // so I expect that it will work similar to the above. Since it
2921 // is avaialble only on XP, it can't be compiled like this and
2922 // will have to be loaded dynamically.
2923 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2924
2925 // fall through
2926
2927 case 4:
2928 // Use PrintWindow if available, or fallback to WM_PRINT
2929 // otherwise. Unfortunately using PrintWindow is even worse than
2930 // WM_PRINT. For most native widgets nothing is drawn to the dc
2931 // at all, with or without Themes.
2932 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2933 static bool s_triedToLoad = false;
2934 static PrintWindow_t pfnPrintWindow = NULL;
2935 if ( !s_triedToLoad )
2936 {
2937
2938 s_triedToLoad = true;
2939 wxDynamicLibrary dllUser32(_T("user32.dll"));
2940 if ( dllUser32.IsLoaded() )
2941 {
2942 wxLogNull nolog; // Don't report errors here
2943 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2944 }
2945 }
2946 if (pfnPrintWindow)
2947 {
2948 //printf("Using PrintWindow\n");
2949 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2950 }
2951 else
2952 {
2953 //printf("Using WM_PRINT\n");
2954 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2955 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2956 PRF_ERASEBKGND | PRF_OWNED );
2957 }
2958 }
2959 #endif // 0
2960 #else
2961 return false;
2962 #endif // __WXMSW__
2963 }
2964
2965
2966
2967 #include <wx/tipdlg.h>
2968
2969
2970 SWIGINTERNINLINE PyObject *
2971 SWIG_From_size_t (size_t value)
2972 {
2973 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2974 }
2975
2976
2977 class wxPyTipProvider : public wxTipProvider {
2978 public:
2979 wxPyTipProvider(size_t currentTip)
2980 : wxTipProvider(currentTip) {}
2981
2982 DEC_PYCALLBACK_STRING__pure(GetTip);
2983 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2984 PYPRIVATE;
2985 };
2986
2987 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2988 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2989
2990
2991 SWIGINTERNINLINE int
2992 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2993 {
2994 unsigned long v;
2995 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2996 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2997 return res;
2998 }
2999
3000
3001 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3002
3003 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3004
3005 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3006 : wxTimer(owner, id)
3007 {
3008 if (owner == NULL)
3009 SetOwner(this);
3010 }
3011
3012
3013 SWIGINTERN swig_type_info*
3014 SWIG_pchar_descriptor()
3015 {
3016 static int init = 0;
3017 static swig_type_info* info = 0;
3018 if (!init) {
3019 info = SWIG_TypeQuery("_p_char");
3020 init = 1;
3021 }
3022 return info;
3023 }
3024
3025
3026 SWIGINTERNINLINE PyObject *
3027 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3028 {
3029 if (carray) {
3030 if (size > INT_MAX) {
3031 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3032 return pchar_descriptor ?
3033 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3034 } else {
3035 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3036 }
3037 } else {
3038 return SWIG_Py_Void();
3039 }
3040 }
3041
3042
3043 SWIGINTERNINLINE PyObject *
3044 SWIG_FromCharPtr(const char *cptr)
3045 {
3046 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3047 }
3048
3049
3050 SWIGINTERN int
3051 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3052 {
3053 unsigned long v;
3054 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3055 if (SWIG_IsOK(res)) {
3056 if ((v > UINT_MAX)) {
3057 return SWIG_OverflowError;
3058 } else {
3059 if (val) *val = static_cast< unsigned int >(v);
3060 }
3061 }
3062 return res;
3063 }
3064
3065 SWIGINTERN wxString wxLog_TimeStamp(){
3066 wxString msg;
3067 wxLog::TimeStamp(&msg);
3068 return msg;
3069 }
3070 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3071 // Make some wrappers that double any % signs so they are 'escaped'
3072 void wxPyLogFatalError(const wxString& msg)
3073 {
3074 wxString m(msg);
3075 m.Replace(wxT("%"), wxT("%%"));
3076 wxLogFatalError(m);
3077 }
3078
3079 void wxPyLogError(const wxString& msg)
3080 {
3081 wxString m(msg);
3082 m.Replace(wxT("%"), wxT("%%"));
3083 wxLogError(m);
3084 }
3085
3086 void wxPyLogWarning(const wxString& msg)
3087 {
3088 wxString m(msg);
3089 m.Replace(wxT("%"), wxT("%%"));
3090 wxLogWarning(m);
3091 }
3092
3093 void wxPyLogMessage(const wxString& msg)
3094 {
3095 wxString m(msg);
3096 m.Replace(wxT("%"), wxT("%%"));
3097 wxLogMessage(m);
3098 }
3099
3100 void wxPyLogInfo(const wxString& msg)
3101 {
3102 wxString m(msg);
3103 m.Replace(wxT("%"), wxT("%%"));
3104 wxLogInfo(m);
3105 }
3106
3107 void wxPyLogDebug(const wxString& msg)
3108 {
3109 wxString m(msg);
3110 m.Replace(wxT("%"), wxT("%%"));
3111 wxLogDebug(m);
3112 }
3113
3114 void wxPyLogVerbose(const wxString& msg)
3115 {
3116 wxString m(msg);
3117 m.Replace(wxT("%"), wxT("%%"));
3118 wxLogVerbose(m);
3119 }
3120
3121 void wxPyLogStatus(const wxString& msg)
3122 {
3123 wxString m(msg);
3124 m.Replace(wxT("%"), wxT("%%"));
3125 wxLogStatus(m);
3126 }
3127
3128 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3129 {
3130 wxString m(msg);
3131 m.Replace(wxT("%"), wxT("%%"));
3132 wxLogStatus(pFrame, m);
3133 }
3134
3135 void wxPyLogSysError(const wxString& msg)
3136 {
3137 wxString m(msg);
3138 m.Replace(wxT("%"), wxT("%%"));
3139 wxLogSysError(m);
3140 }
3141
3142 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3143 {
3144 wxString m(msg);
3145 m.Replace(wxT("%"), wxT("%%"));
3146 wxLogGeneric(level, m);
3147 }
3148
3149 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3150 {
3151 wxString m(msg);
3152 m.Replace(wxT("%"), wxT("%%"));
3153 wxLogTrace(mask, m);
3154 }
3155
3156 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3157 {
3158 wxString m(msg);
3159 m.Replace(wxT("%"), wxT("%%"));
3160 wxLogTrace(mask, m);
3161 }
3162
3163
3164
3165 // A wxLog class that can be derived from in wxPython
3166 class wxPyLog : public wxLog {
3167 public:
3168 wxPyLog() : wxLog() {}
3169
3170 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3171 bool found;
3172 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3173 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3174 PyObject* s = wx2PyString(szString);
3175 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3176 Py_DECREF(s);
3177 }
3178 wxPyEndBlockThreads(blocked);
3179 if (! found)
3180 wxLog::DoLog(level, szString, t);
3181 }
3182
3183 virtual void DoLogString(const wxChar *szString, time_t t) {
3184 bool found;
3185 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3186 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3187 PyObject* s = wx2PyString(szString);
3188 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3189 Py_DECREF(s);
3190 }
3191 wxPyEndBlockThreads(blocked);
3192 if (! found)
3193 wxLog::DoLogString(szString, t);
3194 }
3195
3196 DEC_PYCALLBACK_VOID_(Flush);
3197 PYPRIVATE;
3198 };
3199 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3200
3201
3202
3203
3204 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3205
3206
3207 #include <wx/joystick.h>
3208
3209
3210 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3211 // A C++ stub class for wxJoystick for platforms that don't have it.
3212 class wxJoystick : public wxObject {
3213 public:
3214 wxJoystick(int joystick = wxJOYSTICK1) {
3215 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3216 PyErr_SetString(PyExc_NotImplementedError,
3217 "wxJoystick is not available on this platform.");
3218 wxPyEndBlockThreads(blocked);
3219 }
3220 wxPoint GetPosition() { return wxPoint(-1,-1); }
3221 int GetZPosition() { return -1; }
3222 int GetButtonState() { return -1; }
3223 int GetPOVPosition() { return -1; }
3224 int GetPOVCTSPosition() { return -1; }
3225 int GetRudderPosition() { return -1; }
3226 int GetUPosition() { return -1; }
3227 int GetVPosition() { return -1; }
3228 int GetMovementThreshold() { return -1; }
3229 void SetMovementThreshold(int threshold) {}
3230
3231 bool IsOk(void) { return false; }
3232 int GetNumberJoysticks() { return -1; }
3233 int GetManufacturerId() { return -1; }
3234 int GetProductId() { return -1; }
3235 wxString GetProductName() { return wxEmptyString; }
3236 int GetXMin() { return -1; }
3237 int GetYMin() { return -1; }
3238 int GetZMin() { return -1; }
3239 int GetXMax() { return -1; }
3240 int GetYMax() { return -1; }
3241 int GetZMax() { return -1; }
3242 int GetNumberButtons() { return -1; }
3243 int GetNumberAxes() { return -1; }
3244 int GetMaxButtons() { return -1; }
3245 int GetMaxAxes() { return -1; }
3246 int GetPollingMin() { return -1; }
3247 int GetPollingMax() { return -1; }
3248 int GetRudderMin() { return -1; }
3249 int GetRudderMax() { return -1; }
3250 int GetUMin() { return -1; }
3251 int GetUMax() { return -1; }
3252 int GetVMin() { return -1; }
3253 int GetVMax() { return -1; }
3254
3255 bool HasRudder() { return false; }
3256 bool HasZ() { return false; }
3257 bool HasU() { return false; }
3258 bool HasV() { return false; }
3259 bool HasPOV() { return false; }
3260 bool HasPOV4Dir() { return false; }
3261 bool HasPOVCTS() { return false; }
3262
3263 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3264 bool ReleaseCapture() { return false; }
3265 };
3266 #endif
3267
3268
3269 #include <wx/sound.h>
3270
3271
3272 #if !wxUSE_SOUND
3273 // A C++ stub class for wxWave for platforms that don't have it.
3274 class wxSound : public wxObject
3275 {
3276 public:
3277 wxSound() {
3278 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3279 PyErr_SetString(PyExc_NotImplementedError,
3280 "wxSound is not available on this platform.");
3281 wxPyEndBlockThreads(blocked);
3282 }
3283 wxSound(const wxString&/*, bool*/) {
3284 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3285 PyErr_SetString(PyExc_NotImplementedError,
3286 "wxSound is not available on this platform.");
3287 wxPyEndBlockThreads(blocked);
3288 }
3289 wxSound(int, const wxByte*) {
3290 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3291 PyErr_SetString(PyExc_NotImplementedError,
3292 "wxSound is not available on this platform.");
3293 wxPyEndBlockThreads(blocked);
3294 }
3295
3296 ~wxSound() {};
3297
3298 bool Create(const wxString&/*, bool*/) { return false; }
3299 bool Create(int, const wxByte*) { return false; };
3300 bool IsOk() { return false; };
3301 bool Play(unsigned) const { return false; }
3302 static bool Play(const wxString&, unsigned) { return false; }
3303 static void Stop() {}
3304 };
3305
3306 #endif
3307
3308 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3309 if (fileName.Length() == 0)
3310 return new wxSound;
3311 else
3312 return new wxSound(fileName);
3313 }
3314 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3315 unsigned char* buffer; int size;
3316 wxSound *sound = NULL;
3317
3318 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3319 if (!PyArg_Parse(data, "t#", &buffer, &size))
3320 goto done;
3321 sound = new wxSound(size, buffer);
3322 done:
3323 wxPyEndBlockThreads(blocked);
3324 return sound;
3325 }
3326 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3327 #ifndef __WXMAC__
3328 unsigned char* buffer;
3329 int size;
3330 bool rv = false;
3331
3332 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3333 if (!PyArg_Parse(data, "t#", &buffer, &size))
3334 goto done;
3335 rv = self->Create(size, buffer);
3336 done:
3337 wxPyEndBlockThreads(blocked);
3338 return rv;
3339 #else
3340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3341 PyErr_SetString(PyExc_NotImplementedError,
3342 "Create from data is not available on this platform.");
3343 wxPyEndBlockThreads(blocked);
3344 return false;
3345 #endif
3346 }
3347
3348 #include <wx/mimetype.h>
3349
3350 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3351 wxString str;
3352 if (self->GetMimeType(&str))
3353 return wx2PyString(str);
3354 else
3355 RETURN_NONE();
3356 }
3357 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3358 wxArrayString arr;
3359 if (self->GetMimeTypes(arr))
3360 return wxArrayString2PyList_helper(arr);
3361 else
3362 RETURN_NONE();
3363 }
3364 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3365 wxArrayString arr;
3366 if (self->GetExtensions(arr))
3367 return wxArrayString2PyList_helper(arr);
3368 else
3369 RETURN_NONE();
3370 }
3371 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3372 wxIconLocation loc;
3373 if (self->GetIcon(&loc))
3374 return new wxIcon(loc);
3375 else
3376 return NULL;
3377 }
3378 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3379 wxIconLocation loc;
3380 if (self->GetIcon(&loc)) {
3381 wxString iconFile = loc.GetFileName();
3382 int iconIndex = -1;
3383
3384
3385
3386 // Make a tuple and put the values in it
3387 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3388 PyObject* tuple = PyTuple_New(3);
3389 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3390 wxT("wxIcon"), true));
3391 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3392 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3393 wxPyEndBlockThreads(blocked);
3394 return tuple;
3395 }
3396 else
3397 RETURN_NONE();
3398 }
3399 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3400 wxString str;
3401 if (self->GetDescription(&str))
3402 return wx2PyString(str);
3403 else
3404 RETURN_NONE();
3405 }
3406 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3407 wxString str;
3408 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3409 return wx2PyString(str);
3410 else
3411 RETURN_NONE();
3412 }
3413 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3414 wxString str;
3415 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3416 return wx2PyString(str);
3417 else
3418 RETURN_NONE();
3419 }
3420 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3421 wxArrayString verbs;
3422 wxArrayString commands;
3423 if (self->GetAllCommands(&verbs, &commands,
3424 wxFileType::MessageParameters(filename, mimetype))) {
3425 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3426 PyObject* tuple = PyTuple_New(2);
3427 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3428 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3429 wxPyEndBlockThreads(blocked);
3430 return tuple;
3431 }
3432 else
3433 RETURN_NONE();
3434 }
3435 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3436 return wxFileType::ExpandCommand(command,
3437 wxFileType::MessageParameters(filename, mimetype));
3438 }
3439 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3440 wxArrayString arr;
3441 self->EnumAllFileTypes(arr);
3442 return wxArrayString2PyList_helper(arr);
3443 }
3444
3445 #include <wx/artprov.h>
3446
3447 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3448 static const wxString wxPyART_MENU(wxART_MENU);
3449 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3450 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3451 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3452 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3453 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3454 static const wxString wxPyART_OTHER(wxART_OTHER);
3455 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3456 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3457 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3458 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3459 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3460 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3461 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3462 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3463 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3464 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3465 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3466 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3467 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3468 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3469 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3470 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3471 static const wxString wxPyART_PRINT(wxART_PRINT);
3472 static const wxString wxPyART_HELP(wxART_HELP);
3473 static const wxString wxPyART_TIP(wxART_TIP);
3474 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3475 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3476 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3477 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3478 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3479 static const wxString wxPyART_CDROM(wxART_CDROM);
3480 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3481 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3482 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3483 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3484 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3485 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3486 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3487 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3488 static const wxString wxPyART_ERROR(wxART_ERROR);
3489 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3490 static const wxString wxPyART_WARNING(wxART_WARNING);
3491 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3492 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3493 static const wxString wxPyART_COPY(wxART_COPY);
3494 static const wxString wxPyART_CUT(wxART_CUT);
3495 static const wxString wxPyART_PASTE(wxART_PASTE);
3496 static const wxString wxPyART_DELETE(wxART_DELETE);
3497 static const wxString wxPyART_NEW(wxART_NEW);
3498 static const wxString wxPyART_UNDO(wxART_UNDO);
3499 static const wxString wxPyART_REDO(wxART_REDO);
3500 static const wxString wxPyART_QUIT(wxART_QUIT);
3501 static const wxString wxPyART_FIND(wxART_FIND);
3502 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3503 // Python aware wxArtProvider
3504 class wxPyArtProvider : public wxArtProvider {
3505 public:
3506
3507 virtual wxBitmap CreateBitmap(const wxArtID& id,
3508 const wxArtClient& client,
3509 const wxSize& size) {
3510 wxBitmap rval = wxNullBitmap;
3511 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3512 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3513 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3514 PyObject* ro;
3515 wxBitmap* ptr;
3516 PyObject* s1, *s2;
3517 s1 = wx2PyString(id);
3518 s2 = wx2PyString(client);
3519 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3520 Py_DECREF(so);
3521 Py_DECREF(s1);
3522 Py_DECREF(s2);
3523 if (ro) {
3524 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3525 rval = *ptr;
3526 Py_DECREF(ro);
3527 }
3528 }
3529 wxPyEndBlockThreads(blocked);
3530 return rval;
3531 }
3532
3533 PYPRIVATE;
3534 };
3535
3536 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3537
3538
3539
3540 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3541 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3542 PyObject* ret = PyTuple_New(3);
3543 if (ret) {
3544 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3545 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3546 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3547 }
3548 wxPyEndBlockThreads(blocked);
3549 return ret;
3550 }
3551
3552 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3553 bool cont;
3554 long index = 0;
3555 wxString value;
3556
3557 cont = self->GetFirstGroup(value, index);
3558 return __EnumerationHelper(cont, value, index);
3559 }
3560 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3561 bool cont;
3562 wxString value;
3563
3564 cont = self->GetNextGroup(value, index);
3565 return __EnumerationHelper(cont, value, index);
3566 }
3567 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3568 bool cont;
3569 long index = 0;
3570 wxString value;
3571
3572 cont = self->GetFirstEntry(value, index);
3573 return __EnumerationHelper(cont, value, index);
3574 }
3575 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3576 bool cont;
3577 wxString value;
3578
3579 cont = self->GetNextEntry(value, index);
3580 return __EnumerationHelper(cont, value, index);
3581 }
3582 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3583 long rv;
3584 self->Read(key, &rv, defaultVal);
3585 return rv;
3586 }
3587
3588 SWIGINTERN int
3589 SWIG_AsVal_double (PyObject *obj, double* val)
3590 {
3591 if (PyNumber_Check(obj)) {
3592 if (val) *val = PyFloat_AsDouble(obj);
3593 return SWIG_OK;
3594 }
3595 return SWIG_TypeError;
3596 }
3597
3598 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3599 double rv;
3600 self->Read(key, &rv, defaultVal);
3601 return rv;
3602 }
3603
3604 #define SWIG_From_double PyFloat_FromDouble
3605
3606 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3607 bool rv;
3608 self->Read(key, &rv, defaultVal);
3609 return rv;
3610 }
3611
3612 #include <wx/datetime.h>
3613
3614 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3615 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3616
3617 #define LOCAL_TZ wxDateTime::Local
3618
3619 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3620 wxString am;
3621 wxString pm;
3622 wxDateTime::GetAmPmStrings(&am, &pm);
3623 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3624 PyObject* tup = PyTuple_New(2);
3625 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3626 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3627 wxPyEndBlockThreads(blocked);
3628 return tup;
3629 }
3630
3631 SWIGINTERNINLINE PyObject *
3632 SWIG_From_unsigned_SS_int (unsigned int value)
3633 {
3634 return SWIG_From_unsigned_SS_long (value);
3635 }
3636
3637 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3638 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3639 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3640 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3641 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3642 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3643 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3644 return (*self < *other);
3645 }
3646 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3647 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3648 return (*self <= *other);
3649 }
3650 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3651 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3652 return (*self > *other);
3653 }
3654 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3655 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3656 return (*self >= *other);
3657 }
3658 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3659 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3660 return (*self == *other);
3661 }
3662 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3663 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3664 return (*self != *other);
3665 }
3666 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3667 const wxChar* rv;
3668 const wxChar* _date = date;
3669 rv = self->ParseRfc822Date(_date);
3670 if (rv == NULL) return -1;
3671 return rv - _date;
3672 }
3673 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3674 const wxChar* rv;
3675 const wxChar* _date = date;
3676 rv = self->ParseFormat(_date, format, dateDef);
3677 if (rv == NULL) return -1;
3678 return rv - _date;
3679 }
3680 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3681 const wxChar* rv;
3682 const wxChar* _datetime = datetime;
3683 rv = self->ParseDateTime(_datetime);
3684 if (rv == NULL) return -1;
3685 return rv - _datetime;
3686 }
3687 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3688 const wxChar* rv;
3689 const wxChar* _date = date;
3690 rv = self->ParseDate(_date);
3691 if (rv == NULL) return -1;
3692 return rv - _date;
3693 }
3694 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3695 const wxChar* rv;
3696 const wxChar* _time = time;
3697 rv = self->ParseTime(_time);
3698 if (rv == NULL) return -1;
3699 return rv - _time;
3700 }
3701 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3702 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3703 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3704 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3705 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3706 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3707 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3708 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3709 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3710 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3711 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3712 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3713 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3714 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3715 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3716 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3717
3718 #include <wx/dataobj.h>
3719
3720 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3721 size_t count = self->GetFormatCount(dir);
3722 wxDataFormat* formats = new wxDataFormat[count];
3723 self->GetAllFormats(formats, dir);
3724
3725 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3726 PyObject* list = PyList_New(count);
3727 for (size_t i=0; i<count; i++) {
3728 wxDataFormat* format = new wxDataFormat(formats[i]);
3729 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3730 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3731 }
3732 wxPyEndBlockThreads(blocked);
3733 delete [] formats;
3734 return list;
3735 }
3736 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3737 PyObject* rval = NULL;
3738 size_t size = self->GetDataSize(format);
3739 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3740 if (size) {
3741 char* buf = new char[size];
3742 if (self->GetDataHere(format, buf))
3743 rval = PyString_FromStringAndSize(buf, size);
3744 delete [] buf;
3745 }
3746 if (! rval) {
3747 rval = Py_None;
3748 Py_INCREF(rval);
3749 }
3750 wxPyEndBlockThreads(blocked);
3751 return rval;
3752 }
3753 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3754 bool rval;
3755 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3756 if (PyString_Check(data)) {
3757 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3758 }
3759 else {
3760 // raise a TypeError if not a string
3761 PyErr_SetString(PyExc_TypeError, "String expected.");
3762 rval = false;
3763 }
3764 wxPyEndBlockThreads(blocked);
3765 return rval;
3766 }
3767 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3768 PyObject* rval = NULL;
3769 size_t size = self->GetDataSize();
3770 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3771 if (size) {
3772 char* buf = new char[size];
3773 if (self->GetDataHere(buf))
3774 rval = PyString_FromStringAndSize(buf, size);
3775 delete [] buf;
3776 }
3777 if (! rval) {
3778 rval = Py_None;
3779 Py_INCREF(rval);
3780 }
3781 wxPyEndBlockThreads(blocked);
3782 return rval;
3783 }
3784 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3785 bool rval;
3786 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3787 if (PyString_Check(data)) {
3788 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3789 }
3790 else {
3791 // raise a TypeError if not a string
3792 PyErr_SetString(PyExc_TypeError, "String expected.");
3793 rval = false;
3794 }
3795 wxPyEndBlockThreads(blocked);
3796 return rval;
3797 }
3798 // Create a new class for wxPython to use
3799 class wxPyDataObjectSimple : public wxDataObjectSimple {
3800 public:
3801 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3802 : wxDataObjectSimple(format) {}
3803
3804 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3805 bool GetDataHere(void *buf) const;
3806 bool SetData(size_t len, const void *buf);
3807 PYPRIVATE;
3808 };
3809
3810 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3811
3812 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3813 // We need to get the data for this object and write it to buf. I think
3814 // the best way to do this for wxPython is to have the Python method
3815 // return either a string or None and then act appropriately with the
3816 // C++ version.
3817
3818 bool rval = false;
3819 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3820 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3821 PyObject* ro;
3822 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3823 if (ro) {
3824 rval = (ro != Py_None && PyString_Check(ro));
3825 if (rval)
3826 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3827 Py_DECREF(ro);
3828 }
3829 }
3830 wxPyEndBlockThreads(blocked);
3831 return rval;
3832 }
3833
3834 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3835 // For this one we simply need to make a string from buf and len
3836 // and send it to the Python method.
3837 bool rval = false;
3838 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3839 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3840 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3841 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3842 Py_DECREF(data);
3843 }
3844 wxPyEndBlockThreads(blocked);
3845 return rval;
3846 }
3847
3848 // Create a new class for wxPython to use
3849 class wxPyTextDataObject : public wxTextDataObject {
3850 public:
3851 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3852 : wxTextDataObject(text) {}
3853
3854 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3855 DEC_PYCALLBACK_STRING__const(GetText);
3856 DEC_PYCALLBACK__STRING(SetText);
3857 PYPRIVATE;
3858 };
3859
3860 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3861 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3862 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3863
3864
3865 // Create a new class for wxPython to use
3866 class wxPyBitmapDataObject : public wxBitmapDataObject {
3867 public:
3868 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3869 : wxBitmapDataObject(bitmap) {}
3870
3871 wxBitmap GetBitmap() const;
3872 void SetBitmap(const wxBitmap& bitmap);
3873 PYPRIVATE;
3874 };
3875
3876 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3877 wxBitmap* rval = &wxNullBitmap;
3878 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3879 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3880 PyObject* ro;
3881 wxBitmap* ptr;
3882 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3883 if (ro) {
3884 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3885 rval = ptr;
3886 Py_DECREF(ro);
3887 }
3888 }
3889 wxPyEndBlockThreads(blocked);
3890 return *rval;
3891 }
3892
3893 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3894 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3895 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3896 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3897 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3898 Py_DECREF(bo);
3899 }
3900 wxPyEndBlockThreads(blocked);
3901 }
3902
3903 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3904 return new wxCustomDataObject(wxDataFormat(formatName));
3905 }
3906 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3907 bool rval;
3908 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3909 if (PyString_Check(data)) {
3910 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3911 }
3912 else {
3913 // raise a TypeError if not a string
3914 PyErr_SetString(PyExc_TypeError, "String expected.");
3915 rval = false;
3916 }
3917 wxPyEndBlockThreads(blocked);
3918 return rval;
3919 }
3920 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3921 PyObject* obj;
3922 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3923 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3924 wxPyEndBlockThreads(blocked);
3925 return obj;
3926 }
3927
3928 #include <wx/metafile.h>
3929
3930
3931 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3932
3933
3934 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3935 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3936 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3937 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3938 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3939
3940
3941 class wxPyTextDropTarget : public wxTextDropTarget {
3942 public:
3943 wxPyTextDropTarget() {}
3944
3945 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3946
3947 DEC_PYCALLBACK__(OnLeave);
3948 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3949 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3950 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3951 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3952
3953 PYPRIVATE;
3954 };
3955
3956 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3957 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3958 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3959 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3960 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3961 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3962
3963
3964
3965 class wxPyFileDropTarget : public wxFileDropTarget {
3966 public:
3967 wxPyFileDropTarget() {}
3968
3969 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3970
3971 DEC_PYCALLBACK__(OnLeave);
3972 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3973 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3974 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3975 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3976
3977 PYPRIVATE;
3978 };
3979
3980 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3981 const wxArrayString& filenames) {
3982 bool rval = false;
3983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3984 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3985 PyObject* list = wxArrayString2PyList_helper(filenames);
3986 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3987 Py_DECREF(list);
3988 }
3989 wxPyEndBlockThreads(blocked);
3990 return rval;
3991 }
3992
3993
3994
3995 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3996 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3997 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3998 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
3999 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4000
4001
4002
4003
4004 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4005
4006 #include <wx/display.h>
4007
4008 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4009 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4010
4011 #if !wxUSE_DISPLAY
4012 const wxVideoMode wxDefaultVideoMode;
4013 #endif
4014
4015 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4016 #if wxUSE_DISPLAY
4017 PyObject* pyList = NULL;
4018 wxArrayVideoModes arr = self->GetModes(mode);
4019 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4020 pyList = PyList_New(0);
4021 for (size_t i=0; i < arr.GetCount(); i++)
4022 {
4023 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4024 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4025 PyList_Append(pyList, pyObj);
4026 Py_DECREF(pyObj);
4027 }
4028 wxPyEndBlockThreads(blocked);
4029 return pyList;
4030 #else
4031 wxPyRaiseNotImplemented();
4032 return NULL;
4033 #endif
4034 }
4035 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4036 #if wxUSE_DISPLAY
4037 return self->GetCurrentMode();
4038 #else
4039 wxPyRaiseNotImplemented();
4040 return wxDefaultVideoMode;
4041 #endif
4042 }
4043 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4044 #if wxUSE_DISPLAY
4045 return self->ChangeMode(mode);
4046 #else
4047 wxPyRaiseNotImplemented();
4048 return false;
4049 #endif
4050 }
4051 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4052 #if wxUSE_DISPLAY
4053 self->ResetMode();
4054 #else
4055 wxPyRaiseNotImplemented();
4056 #endif
4057 }
4058
4059 #include <wx/stdpaths.h>
4060
4061 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4062 return (wxStandardPaths*) &wxStandardPaths::Get();
4063 }
4064 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4065 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4066
4067 #ifndef wxHAS_POWER_EVENTS
4068 // Dummy class and other definitions for platforms that don't have them
4069
4070 // See wxPython_int.h for wxPowerEvent
4071
4072 enum {
4073 wxEVT_POWER_SUSPENDING,
4074 wxEVT_POWER_SUSPENDED,
4075 wxEVT_POWER_SUSPEND_CANCEL,
4076 wxEVT_POWER_RESUME,
4077 };
4078
4079 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4080 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4081
4082 #endif
4083
4084 #ifdef __cplusplus
4085 extern "C" {
4086 #endif
4087 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4088 PyObject *resultobj = 0;
4089 wxSystemColour arg1 ;
4090 wxColour result;
4091 int val1 ;
4092 int ecode1 = 0 ;
4093 PyObject * obj0 = 0 ;
4094 char * kwnames[] = {
4095 (char *) "index", NULL
4096 };
4097
4098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4099 ecode1 = SWIG_AsVal_int(obj0, &val1);
4100 if (!SWIG_IsOK(ecode1)) {
4101 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4102 }
4103 arg1 = static_cast< wxSystemColour >(val1);
4104 {
4105 if (!wxPyCheckForApp()) SWIG_fail;
4106 PyThreadState* __tstate = wxPyBeginAllowThreads();
4107 result = wxSystemSettings::GetColour(arg1);
4108 wxPyEndAllowThreads(__tstate);
4109 if (PyErr_Occurred()) SWIG_fail;
4110 }
4111 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4112 return resultobj;
4113 fail:
4114 return NULL;
4115 }
4116
4117
4118 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4119 PyObject *resultobj = 0;
4120 wxSystemFont arg1 ;
4121 wxFont result;
4122 int val1 ;
4123 int ecode1 = 0 ;
4124 PyObject * obj0 = 0 ;
4125 char * kwnames[] = {
4126 (char *) "index", NULL
4127 };
4128
4129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4130 ecode1 = SWIG_AsVal_int(obj0, &val1);
4131 if (!SWIG_IsOK(ecode1)) {
4132 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4133 }
4134 arg1 = static_cast< wxSystemFont >(val1);
4135 {
4136 if (!wxPyCheckForApp()) SWIG_fail;
4137 PyThreadState* __tstate = wxPyBeginAllowThreads();
4138 result = wxSystemSettings::GetFont(arg1);
4139 wxPyEndAllowThreads(__tstate);
4140 if (PyErr_Occurred()) SWIG_fail;
4141 }
4142 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4143 return resultobj;
4144 fail:
4145 return NULL;
4146 }
4147
4148
4149 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4150 PyObject *resultobj = 0;
4151 wxSystemMetric arg1 ;
4152 wxWindow *arg2 = (wxWindow *) NULL ;
4153 int result;
4154 int val1 ;
4155 int ecode1 = 0 ;
4156 void *argp2 = 0 ;
4157 int res2 = 0 ;
4158 PyObject * obj0 = 0 ;
4159 PyObject * obj1 = 0 ;
4160 char * kwnames[] = {
4161 (char *) "index",(char *) "win", NULL
4162 };
4163
4164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4165 ecode1 = SWIG_AsVal_int(obj0, &val1);
4166 if (!SWIG_IsOK(ecode1)) {
4167 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4168 }
4169 arg1 = static_cast< wxSystemMetric >(val1);
4170 if (obj1) {
4171 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4172 if (!SWIG_IsOK(res2)) {
4173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4174 }
4175 arg2 = reinterpret_cast< wxWindow * >(argp2);
4176 }
4177 {
4178 if (!wxPyCheckForApp()) SWIG_fail;
4179 PyThreadState* __tstate = wxPyBeginAllowThreads();
4180 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4181 wxPyEndAllowThreads(__tstate);
4182 if (PyErr_Occurred()) SWIG_fail;
4183 }
4184 resultobj = SWIG_From_int(static_cast< int >(result));
4185 return resultobj;
4186 fail:
4187 return NULL;
4188 }
4189
4190
4191 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4192 PyObject *resultobj = 0;
4193 wxSystemFeature arg1 ;
4194 bool result;
4195 int val1 ;
4196 int ecode1 = 0 ;
4197 PyObject * obj0 = 0 ;
4198 char * kwnames[] = {
4199 (char *) "index", NULL
4200 };
4201
4202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4203 ecode1 = SWIG_AsVal_int(obj0, &val1);
4204 if (!SWIG_IsOK(ecode1)) {
4205 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4206 }
4207 arg1 = static_cast< wxSystemFeature >(val1);
4208 {
4209 if (!wxPyCheckForApp()) SWIG_fail;
4210 PyThreadState* __tstate = wxPyBeginAllowThreads();
4211 result = (bool)wxSystemSettings::HasFeature(arg1);
4212 wxPyEndAllowThreads(__tstate);
4213 if (PyErr_Occurred()) SWIG_fail;
4214 }
4215 {
4216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4217 }
4218 return resultobj;
4219 fail:
4220 return NULL;
4221 }
4222
4223
4224 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4225 PyObject *resultobj = 0;
4226 wxSystemScreenType result;
4227
4228 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4229 {
4230 if (!wxPyCheckForApp()) SWIG_fail;
4231 PyThreadState* __tstate = wxPyBeginAllowThreads();
4232 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4233 wxPyEndAllowThreads(__tstate);
4234 if (PyErr_Occurred()) SWIG_fail;
4235 }
4236 resultobj = SWIG_From_int(static_cast< int >(result));
4237 return resultobj;
4238 fail:
4239 return NULL;
4240 }
4241
4242
4243 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4244 PyObject *resultobj = 0;
4245 wxSystemScreenType arg1 ;
4246 int val1 ;
4247 int ecode1 = 0 ;
4248 PyObject * obj0 = 0 ;
4249 char * kwnames[] = {
4250 (char *) "screen", NULL
4251 };
4252
4253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4254 ecode1 = SWIG_AsVal_int(obj0, &val1);
4255 if (!SWIG_IsOK(ecode1)) {
4256 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4257 }
4258 arg1 = static_cast< wxSystemScreenType >(val1);
4259 {
4260 if (!wxPyCheckForApp()) SWIG_fail;
4261 PyThreadState* __tstate = wxPyBeginAllowThreads();
4262 wxSystemSettings::SetScreenType(arg1);
4263 wxPyEndAllowThreads(__tstate);
4264 if (PyErr_Occurred()) SWIG_fail;
4265 }
4266 resultobj = SWIG_Py_Void();
4267 return resultobj;
4268 fail:
4269 return NULL;
4270 }
4271
4272
4273 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4274 PyObject *obj;
4275 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4276 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4277 return SWIG_Py_Void();
4278 }
4279
4280 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4281 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4282 return 1;
4283 }
4284
4285
4286 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4287 PyObject *pyobj = 0;
4288
4289 {
4290 #if wxUSE_UNICODE
4291 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4292 #else
4293 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4294 #endif
4295 }
4296 return pyobj;
4297 }
4298
4299
4300 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4301 PyObject *resultobj = 0;
4302 wxSystemOptions *result = 0 ;
4303
4304 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4305 {
4306 PyThreadState* __tstate = wxPyBeginAllowThreads();
4307 result = (wxSystemOptions *)new wxSystemOptions();
4308 wxPyEndAllowThreads(__tstate);
4309 if (PyErr_Occurred()) SWIG_fail;
4310 }
4311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4312 return resultobj;
4313 fail:
4314 return NULL;
4315 }
4316
4317
4318 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4319 PyObject *resultobj = 0;
4320 wxString *arg1 = 0 ;
4321 wxString *arg2 = 0 ;
4322 bool temp1 = false ;
4323 bool temp2 = false ;
4324 PyObject * obj0 = 0 ;
4325 PyObject * obj1 = 0 ;
4326 char * kwnames[] = {
4327 (char *) "name",(char *) "value", NULL
4328 };
4329
4330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4331 {
4332 arg1 = wxString_in_helper(obj0);
4333 if (arg1 == NULL) SWIG_fail;
4334 temp1 = true;
4335 }
4336 {
4337 arg2 = wxString_in_helper(obj1);
4338 if (arg2 == NULL) SWIG_fail;
4339 temp2 = true;
4340 }
4341 {
4342 PyThreadState* __tstate = wxPyBeginAllowThreads();
4343 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4344 wxPyEndAllowThreads(__tstate);
4345 if (PyErr_Occurred()) SWIG_fail;
4346 }
4347 resultobj = SWIG_Py_Void();
4348 {
4349 if (temp1)
4350 delete arg1;
4351 }
4352 {
4353 if (temp2)
4354 delete arg2;
4355 }
4356 return resultobj;
4357 fail:
4358 {
4359 if (temp1)
4360 delete arg1;
4361 }
4362 {
4363 if (temp2)
4364 delete arg2;
4365 }
4366 return NULL;
4367 }
4368
4369
4370 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4371 PyObject *resultobj = 0;
4372 wxString *arg1 = 0 ;
4373 int arg2 ;
4374 bool temp1 = false ;
4375 int val2 ;
4376 int ecode2 = 0 ;
4377 PyObject * obj0 = 0 ;
4378 PyObject * obj1 = 0 ;
4379 char * kwnames[] = {
4380 (char *) "name",(char *) "value", NULL
4381 };
4382
4383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4384 {
4385 arg1 = wxString_in_helper(obj0);
4386 if (arg1 == NULL) SWIG_fail;
4387 temp1 = true;
4388 }
4389 ecode2 = SWIG_AsVal_int(obj1, &val2);
4390 if (!SWIG_IsOK(ecode2)) {
4391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4392 }
4393 arg2 = static_cast< int >(val2);
4394 {
4395 PyThreadState* __tstate = wxPyBeginAllowThreads();
4396 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4397 wxPyEndAllowThreads(__tstate);
4398 if (PyErr_Occurred()) SWIG_fail;
4399 }
4400 resultobj = SWIG_Py_Void();
4401 {
4402 if (temp1)
4403 delete arg1;
4404 }
4405 return resultobj;
4406 fail:
4407 {
4408 if (temp1)
4409 delete arg1;
4410 }
4411 return NULL;
4412 }
4413
4414
4415 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4416 PyObject *resultobj = 0;
4417 wxString *arg1 = 0 ;
4418 wxString result;
4419 bool temp1 = false ;
4420 PyObject * obj0 = 0 ;
4421 char * kwnames[] = {
4422 (char *) "name", NULL
4423 };
4424
4425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4426 {
4427 arg1 = wxString_in_helper(obj0);
4428 if (arg1 == NULL) SWIG_fail;
4429 temp1 = true;
4430 }
4431 {
4432 PyThreadState* __tstate = wxPyBeginAllowThreads();
4433 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4434 wxPyEndAllowThreads(__tstate);
4435 if (PyErr_Occurred()) SWIG_fail;
4436 }
4437 {
4438 #if wxUSE_UNICODE
4439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4440 #else
4441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4442 #endif
4443 }
4444 {
4445 if (temp1)
4446 delete arg1;
4447 }
4448 return resultobj;
4449 fail:
4450 {
4451 if (temp1)
4452 delete arg1;
4453 }
4454 return NULL;
4455 }
4456
4457
4458 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4459 PyObject *resultobj = 0;
4460 wxString *arg1 = 0 ;
4461 int result;
4462 bool temp1 = false ;
4463 PyObject * obj0 = 0 ;
4464 char * kwnames[] = {
4465 (char *) "name", NULL
4466 };
4467
4468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4469 {
4470 arg1 = wxString_in_helper(obj0);
4471 if (arg1 == NULL) SWIG_fail;
4472 temp1 = true;
4473 }
4474 {
4475 PyThreadState* __tstate = wxPyBeginAllowThreads();
4476 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4477 wxPyEndAllowThreads(__tstate);
4478 if (PyErr_Occurred()) SWIG_fail;
4479 }
4480 resultobj = SWIG_From_int(static_cast< int >(result));
4481 {
4482 if (temp1)
4483 delete arg1;
4484 }
4485 return resultobj;
4486 fail:
4487 {
4488 if (temp1)
4489 delete arg1;
4490 }
4491 return NULL;
4492 }
4493
4494
4495 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4496 PyObject *resultobj = 0;
4497 wxString *arg1 = 0 ;
4498 bool result;
4499 bool temp1 = false ;
4500 PyObject * obj0 = 0 ;
4501 char * kwnames[] = {
4502 (char *) "name", NULL
4503 };
4504
4505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4506 {
4507 arg1 = wxString_in_helper(obj0);
4508 if (arg1 == NULL) SWIG_fail;
4509 temp1 = true;
4510 }
4511 {
4512 PyThreadState* __tstate = wxPyBeginAllowThreads();
4513 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4514 wxPyEndAllowThreads(__tstate);
4515 if (PyErr_Occurred()) SWIG_fail;
4516 }
4517 {
4518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4519 }
4520 {
4521 if (temp1)
4522 delete arg1;
4523 }
4524 return resultobj;
4525 fail:
4526 {
4527 if (temp1)
4528 delete arg1;
4529 }
4530 return NULL;
4531 }
4532
4533
4534 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4535 PyObject *resultobj = 0;
4536 wxString *arg1 = 0 ;
4537 bool result;
4538 bool temp1 = false ;
4539 PyObject * obj0 = 0 ;
4540 char * kwnames[] = {
4541 (char *) "name", NULL
4542 };
4543
4544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4545 {
4546 arg1 = wxString_in_helper(obj0);
4547 if (arg1 == NULL) SWIG_fail;
4548 temp1 = true;
4549 }
4550 {
4551 PyThreadState* __tstate = wxPyBeginAllowThreads();
4552 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4553 wxPyEndAllowThreads(__tstate);
4554 if (PyErr_Occurred()) SWIG_fail;
4555 }
4556 {
4557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4558 }
4559 {
4560 if (temp1)
4561 delete arg1;
4562 }
4563 return resultobj;
4564 fail:
4565 {
4566 if (temp1)
4567 delete arg1;
4568 }
4569 return NULL;
4570 }
4571
4572
4573 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4574 PyObject *obj;
4575 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4576 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4577 return SWIG_Py_Void();
4578 }
4579
4580 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4581 return SWIG_Python_InitShadowInstance(args);
4582 }
4583
4584 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4585 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4586 return 1;
4587 }
4588
4589
4590 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4591 PyObject *pyobj = 0;
4592
4593 {
4594 #if wxUSE_UNICODE
4595 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4596 #else
4597 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4598 #endif
4599 }
4600 return pyobj;
4601 }
4602
4603
4604 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4605 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4606 return 1;
4607 }
4608
4609
4610 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4611 PyObject *pyobj = 0;
4612
4613 {
4614 #if wxUSE_UNICODE
4615 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4616 #else
4617 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4618 #endif
4619 }
4620 return pyobj;
4621 }
4622
4623
4624 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4625 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4626 return 1;
4627 }
4628
4629
4630 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4631 PyObject *pyobj = 0;
4632
4633 {
4634 #if wxUSE_UNICODE
4635 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4636 #else
4637 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4638 #endif
4639 }
4640 return pyobj;
4641 }
4642
4643
4644 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4645 PyObject *resultobj = 0;
4646 long result;
4647
4648 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4649 {
4650 PyThreadState* __tstate = wxPyBeginAllowThreads();
4651 result = (long)wxNewId();
4652 wxPyEndAllowThreads(__tstate);
4653 if (PyErr_Occurred()) SWIG_fail;
4654 }
4655 resultobj = SWIG_From_long(static_cast< long >(result));
4656 return resultobj;
4657 fail:
4658 return NULL;
4659 }
4660
4661
4662 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4663 PyObject *resultobj = 0;
4664 long arg1 ;
4665 long val1 ;
4666 int ecode1 = 0 ;
4667 PyObject * obj0 = 0 ;
4668 char * kwnames[] = {
4669 (char *) "id", NULL
4670 };
4671
4672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4673 ecode1 = SWIG_AsVal_long(obj0, &val1);
4674 if (!SWIG_IsOK(ecode1)) {
4675 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4676 }
4677 arg1 = static_cast< long >(val1);
4678 {
4679 PyThreadState* __tstate = wxPyBeginAllowThreads();
4680 wxRegisterId(arg1);
4681 wxPyEndAllowThreads(__tstate);
4682 if (PyErr_Occurred()) SWIG_fail;
4683 }
4684 resultobj = SWIG_Py_Void();
4685 return resultobj;
4686 fail:
4687 return NULL;
4688 }
4689
4690
4691 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4692 PyObject *resultobj = 0;
4693 long result;
4694
4695 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4696 {
4697 PyThreadState* __tstate = wxPyBeginAllowThreads();
4698 result = (long)wxGetCurrentId();
4699 wxPyEndAllowThreads(__tstate);
4700 if (PyErr_Occurred()) SWIG_fail;
4701 }
4702 resultobj = SWIG_From_long(static_cast< long >(result));
4703 return resultobj;
4704 fail:
4705 return NULL;
4706 }
4707
4708
4709 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4710 PyObject *resultobj = 0;
4711 int arg1 ;
4712 bool result;
4713 int val1 ;
4714 int ecode1 = 0 ;
4715 PyObject * obj0 = 0 ;
4716 char * kwnames[] = {
4717 (char *) "id", NULL
4718 };
4719
4720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4721 ecode1 = SWIG_AsVal_int(obj0, &val1);
4722 if (!SWIG_IsOK(ecode1)) {
4723 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4724 }
4725 arg1 = static_cast< int >(val1);
4726 {
4727 PyThreadState* __tstate = wxPyBeginAllowThreads();
4728 result = (bool)wxIsStockID(arg1);
4729 wxPyEndAllowThreads(__tstate);
4730 if (PyErr_Occurred()) SWIG_fail;
4731 }
4732 {
4733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4734 }
4735 return resultobj;
4736 fail:
4737 return NULL;
4738 }
4739
4740
4741 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4742 PyObject *resultobj = 0;
4743 int arg1 ;
4744 wxString *arg2 = 0 ;
4745 bool result;
4746 int val1 ;
4747 int ecode1 = 0 ;
4748 bool temp2 = false ;
4749 PyObject * obj0 = 0 ;
4750 PyObject * obj1 = 0 ;
4751 char * kwnames[] = {
4752 (char *) "id",(char *) "label", NULL
4753 };
4754
4755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4756 ecode1 = SWIG_AsVal_int(obj0, &val1);
4757 if (!SWIG_IsOK(ecode1)) {
4758 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4759 }
4760 arg1 = static_cast< int >(val1);
4761 {
4762 arg2 = wxString_in_helper(obj1);
4763 if (arg2 == NULL) SWIG_fail;
4764 temp2 = true;
4765 }
4766 {
4767 PyThreadState* __tstate = wxPyBeginAllowThreads();
4768 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4769 wxPyEndAllowThreads(__tstate);
4770 if (PyErr_Occurred()) SWIG_fail;
4771 }
4772 {
4773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4774 }
4775 {
4776 if (temp2)
4777 delete arg2;
4778 }
4779 return resultobj;
4780 fail:
4781 {
4782 if (temp2)
4783 delete arg2;
4784 }
4785 return NULL;
4786 }
4787
4788
4789 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4790 PyObject *resultobj = 0;
4791 int arg1 ;
4792 bool arg2 = (bool) true ;
4793 wxString arg3 = (wxString) wxPyEmptyString ;
4794 wxString result;
4795 int val1 ;
4796 int ecode1 = 0 ;
4797 bool val2 ;
4798 int ecode2 = 0 ;
4799 PyObject * obj0 = 0 ;
4800 PyObject * obj1 = 0 ;
4801 PyObject * obj2 = 0 ;
4802 char * kwnames[] = {
4803 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4804 };
4805
4806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4807 ecode1 = SWIG_AsVal_int(obj0, &val1);
4808 if (!SWIG_IsOK(ecode1)) {
4809 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4810 }
4811 arg1 = static_cast< int >(val1);
4812 if (obj1) {
4813 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4814 if (!SWIG_IsOK(ecode2)) {
4815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4816 }
4817 arg2 = static_cast< bool >(val2);
4818 }
4819 if (obj2) {
4820 {
4821 wxString* sptr = wxString_in_helper(obj2);
4822 if (sptr == NULL) SWIG_fail;
4823 arg3 = *sptr;
4824 delete sptr;
4825 }
4826 }
4827 {
4828 PyThreadState* __tstate = wxPyBeginAllowThreads();
4829 result = wxGetStockLabel(arg1,arg2,arg3);
4830 wxPyEndAllowThreads(__tstate);
4831 if (PyErr_Occurred()) SWIG_fail;
4832 }
4833 {
4834 #if wxUSE_UNICODE
4835 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4836 #else
4837 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4838 #endif
4839 }
4840 return resultobj;
4841 fail:
4842 return NULL;
4843 }
4844
4845
4846 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4847 PyObject *resultobj = 0;
4848
4849 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4850 {
4851 if (!wxPyCheckForApp()) SWIG_fail;
4852 PyThreadState* __tstate = wxPyBeginAllowThreads();
4853 wxBell();
4854 wxPyEndAllowThreads(__tstate);
4855 if (PyErr_Occurred()) SWIG_fail;
4856 }
4857 resultobj = SWIG_Py_Void();
4858 return resultobj;
4859 fail:
4860 return NULL;
4861 }
4862
4863
4864 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4865 PyObject *resultobj = 0;
4866
4867 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4868 {
4869 if (!wxPyCheckForApp()) SWIG_fail;
4870 PyThreadState* __tstate = wxPyBeginAllowThreads();
4871 wxEndBusyCursor();
4872 wxPyEndAllowThreads(__tstate);
4873 if (PyErr_Occurred()) SWIG_fail;
4874 }
4875 resultobj = SWIG_Py_Void();
4876 return resultobj;
4877 fail:
4878 return NULL;
4879 }
4880
4881
4882 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4883 PyObject *resultobj = 0;
4884 bool arg1 = (bool) true ;
4885 long result;
4886 bool val1 ;
4887 int ecode1 = 0 ;
4888 PyObject * obj0 = 0 ;
4889 char * kwnames[] = {
4890 (char *) "resetTimer", NULL
4891 };
4892
4893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4894 if (obj0) {
4895 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4896 if (!SWIG_IsOK(ecode1)) {
4897 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4898 }
4899 arg1 = static_cast< bool >(val1);
4900 }
4901 {
4902 PyThreadState* __tstate = wxPyBeginAllowThreads();
4903 result = (long)wxGetElapsedTime(arg1);
4904 wxPyEndAllowThreads(__tstate);
4905 if (PyErr_Occurred()) SWIG_fail;
4906 }
4907 resultobj = SWIG_From_long(static_cast< long >(result));
4908 return resultobj;
4909 fail:
4910 return NULL;
4911 }
4912
4913
4914 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4915 PyObject *resultobj = 0;
4916 bool result;
4917
4918 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4919 {
4920 PyThreadState* __tstate = wxPyBeginAllowThreads();
4921 result = (bool)wxIsBusy();
4922 wxPyEndAllowThreads(__tstate);
4923 if (PyErr_Occurred()) SWIG_fail;
4924 }
4925 {
4926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4927 }
4928 return resultobj;
4929 fail:
4930 return NULL;
4931 }
4932
4933
4934 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4935 PyObject *resultobj = 0;
4936 wxString result;
4937
4938 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4939 {
4940 PyThreadState* __tstate = wxPyBeginAllowThreads();
4941 result = wxNow();
4942 wxPyEndAllowThreads(__tstate);
4943 if (PyErr_Occurred()) SWIG_fail;
4944 }
4945 {
4946 #if wxUSE_UNICODE
4947 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4948 #else
4949 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4950 #endif
4951 }
4952 return resultobj;
4953 fail:
4954 return NULL;
4955 }
4956
4957
4958 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4959 PyObject *resultobj = 0;
4960 wxString const &arg1_defvalue = wxPyEmptyString ;
4961 wxString *arg1 = (wxString *) &arg1_defvalue ;
4962 bool result;
4963 bool temp1 = false ;
4964 PyObject * obj0 = 0 ;
4965 char * kwnames[] = {
4966 (char *) "command", NULL
4967 };
4968
4969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4970 if (obj0) {
4971 {
4972 arg1 = wxString_in_helper(obj0);
4973 if (arg1 == NULL) SWIG_fail;
4974 temp1 = true;
4975 }
4976 }
4977 {
4978 PyThreadState* __tstate = wxPyBeginAllowThreads();
4979 result = (bool)wxShell((wxString const &)*arg1);
4980 wxPyEndAllowThreads(__tstate);
4981 if (PyErr_Occurred()) SWIG_fail;
4982 }
4983 {
4984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4985 }
4986 {
4987 if (temp1)
4988 delete arg1;
4989 }
4990 return resultobj;
4991 fail:
4992 {
4993 if (temp1)
4994 delete arg1;
4995 }
4996 return NULL;
4997 }
4998
4999
5000 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5001 PyObject *resultobj = 0;
5002
5003 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5004 {
5005 PyThreadState* __tstate = wxPyBeginAllowThreads();
5006 wxStartTimer();
5007 wxPyEndAllowThreads(__tstate);
5008 if (PyErr_Occurred()) SWIG_fail;
5009 }
5010 resultobj = SWIG_Py_Void();
5011 return resultobj;
5012 fail:
5013 return NULL;
5014 }
5015
5016
5017 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5018 PyObject *resultobj = 0;
5019 int *arg1 = (int *) 0 ;
5020 int *arg2 = (int *) 0 ;
5021 int result;
5022 int temp1 ;
5023 int res1 = SWIG_TMPOBJ ;
5024 int temp2 ;
5025 int res2 = SWIG_TMPOBJ ;
5026
5027 arg1 = &temp1;
5028 arg2 = &temp2;
5029 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5030 {
5031 PyThreadState* __tstate = wxPyBeginAllowThreads();
5032 result = (int)wxGetOsVersion(arg1,arg2);
5033 wxPyEndAllowThreads(__tstate);
5034 if (PyErr_Occurred()) SWIG_fail;
5035 }
5036 resultobj = SWIG_From_int(static_cast< int >(result));
5037 if (SWIG_IsTmpObj(res1)) {
5038 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5039 } else {
5040 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5041 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5042 }
5043 if (SWIG_IsTmpObj(res2)) {
5044 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5045 } else {
5046 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5047 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5048 }
5049 return resultobj;
5050 fail:
5051 return NULL;
5052 }
5053
5054
5055 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5056 PyObject *resultobj = 0;
5057 wxString result;
5058
5059 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5060 {
5061 PyThreadState* __tstate = wxPyBeginAllowThreads();
5062 result = wxGetOsDescription();
5063 wxPyEndAllowThreads(__tstate);
5064 if (PyErr_Occurred()) SWIG_fail;
5065 }
5066 {
5067 #if wxUSE_UNICODE
5068 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5069 #else
5070 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5071 #endif
5072 }
5073 return resultobj;
5074 fail:
5075 return NULL;
5076 }
5077
5078
5079 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5080 PyObject *resultobj = 0;
5081 bool result;
5082
5083 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5084 {
5085 PyThreadState* __tstate = wxPyBeginAllowThreads();
5086 result = (bool)wxIsPlatformLittleEndian();
5087 wxPyEndAllowThreads(__tstate);
5088 if (PyErr_Occurred()) SWIG_fail;
5089 }
5090 {
5091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5092 }
5093 return resultobj;
5094 fail:
5095 return NULL;
5096 }
5097
5098
5099 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5100 PyObject *resultobj = 0;
5101 bool result;
5102
5103 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5104 {
5105 PyThreadState* __tstate = wxPyBeginAllowThreads();
5106 result = (bool)wxIsPlatform64Bit();
5107 wxPyEndAllowThreads(__tstate);
5108 if (PyErr_Occurred()) SWIG_fail;
5109 }
5110 {
5111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5112 }
5113 return resultobj;
5114 fail:
5115 return NULL;
5116 }
5117
5118
5119 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5120 PyObject *resultobj = 0;
5121 wxMemorySize result;
5122
5123 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5124 {
5125 PyThreadState* __tstate = wxPyBeginAllowThreads();
5126 result = wxGetFreeMemory();
5127 wxPyEndAllowThreads(__tstate);
5128 if (PyErr_Occurred()) SWIG_fail;
5129 }
5130 {
5131 #if wxUSE_LONGLONG
5132 resultobj = PyLong_FromLongLong((&result)->GetValue());
5133 #else
5134 resultobj = PyInt_FromLong(result);
5135 #endif
5136 }
5137 return resultobj;
5138 fail:
5139 return NULL;
5140 }
5141
5142
5143 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5144 PyObject *resultobj = 0;
5145 wxShutdownFlags arg1 ;
5146 bool result;
5147 int val1 ;
5148 int ecode1 = 0 ;
5149 PyObject * obj0 = 0 ;
5150 char * kwnames[] = {
5151 (char *) "wFlags", NULL
5152 };
5153
5154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5155 ecode1 = SWIG_AsVal_int(obj0, &val1);
5156 if (!SWIG_IsOK(ecode1)) {
5157 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5158 }
5159 arg1 = static_cast< wxShutdownFlags >(val1);
5160 {
5161 if (!wxPyCheckForApp()) SWIG_fail;
5162 PyThreadState* __tstate = wxPyBeginAllowThreads();
5163 result = (bool)wxShutdown(arg1);
5164 wxPyEndAllowThreads(__tstate);
5165 if (PyErr_Occurred()) SWIG_fail;
5166 }
5167 {
5168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5169 }
5170 return resultobj;
5171 fail:
5172 return NULL;
5173 }
5174
5175
5176 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5177 PyObject *resultobj = 0;
5178 int arg1 ;
5179 int val1 ;
5180 int ecode1 = 0 ;
5181 PyObject * obj0 = 0 ;
5182 char * kwnames[] = {
5183 (char *) "secs", NULL
5184 };
5185
5186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5187 ecode1 = SWIG_AsVal_int(obj0, &val1);
5188 if (!SWIG_IsOK(ecode1)) {
5189 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5190 }
5191 arg1 = static_cast< int >(val1);
5192 {
5193 PyThreadState* __tstate = wxPyBeginAllowThreads();
5194 wxSleep(arg1);
5195 wxPyEndAllowThreads(__tstate);
5196 if (PyErr_Occurred()) SWIG_fail;
5197 }
5198 resultobj = SWIG_Py_Void();
5199 return resultobj;
5200 fail:
5201 return NULL;
5202 }
5203
5204
5205 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5206 PyObject *resultobj = 0;
5207 unsigned long arg1 ;
5208 unsigned long val1 ;
5209 int ecode1 = 0 ;
5210 PyObject * obj0 = 0 ;
5211 char * kwnames[] = {
5212 (char *) "milliseconds", NULL
5213 };
5214
5215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5216 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5217 if (!SWIG_IsOK(ecode1)) {
5218 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5219 }
5220 arg1 = static_cast< unsigned long >(val1);
5221 {
5222 PyThreadState* __tstate = wxPyBeginAllowThreads();
5223 wxMilliSleep(arg1);
5224 wxPyEndAllowThreads(__tstate);
5225 if (PyErr_Occurred()) SWIG_fail;
5226 }
5227 resultobj = SWIG_Py_Void();
5228 return resultobj;
5229 fail:
5230 return NULL;
5231 }
5232
5233
5234 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5235 PyObject *resultobj = 0;
5236 unsigned long arg1 ;
5237 unsigned long val1 ;
5238 int ecode1 = 0 ;
5239 PyObject * obj0 = 0 ;
5240 char * kwnames[] = {
5241 (char *) "microseconds", NULL
5242 };
5243
5244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5245 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5246 if (!SWIG_IsOK(ecode1)) {
5247 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5248 }
5249 arg1 = static_cast< unsigned long >(val1);
5250 {
5251 PyThreadState* __tstate = wxPyBeginAllowThreads();
5252 wxMicroSleep(arg1);
5253 wxPyEndAllowThreads(__tstate);
5254 if (PyErr_Occurred()) SWIG_fail;
5255 }
5256 resultobj = SWIG_Py_Void();
5257 return resultobj;
5258 fail:
5259 return NULL;
5260 }
5261
5262
5263 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5264 PyObject *resultobj = 0;
5265 bool arg1 ;
5266 bool val1 ;
5267 int ecode1 = 0 ;
5268 PyObject * obj0 = 0 ;
5269 char * kwnames[] = {
5270 (char *) "enable", NULL
5271 };
5272
5273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5274 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5275 if (!SWIG_IsOK(ecode1)) {
5276 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5277 }
5278 arg1 = static_cast< bool >(val1);
5279 {
5280 PyThreadState* __tstate = wxPyBeginAllowThreads();
5281 wxEnableTopLevelWindows(arg1);
5282 wxPyEndAllowThreads(__tstate);
5283 if (PyErr_Occurred()) SWIG_fail;
5284 }
5285 resultobj = SWIG_Py_Void();
5286 return resultobj;
5287 fail:
5288 return NULL;
5289 }
5290
5291
5292 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5293 PyObject *resultobj = 0;
5294 wxString *arg1 = 0 ;
5295 wxString result;
5296 bool temp1 = false ;
5297 PyObject * obj0 = 0 ;
5298 char * kwnames[] = {
5299 (char *) "in", NULL
5300 };
5301
5302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5303 {
5304 arg1 = wxString_in_helper(obj0);
5305 if (arg1 == NULL) SWIG_fail;
5306 temp1 = true;
5307 }
5308 {
5309 PyThreadState* __tstate = wxPyBeginAllowThreads();
5310 result = wxStripMenuCodes((wxString const &)*arg1);
5311 wxPyEndAllowThreads(__tstate);
5312 if (PyErr_Occurred()) SWIG_fail;
5313 }
5314 {
5315 #if wxUSE_UNICODE
5316 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5317 #else
5318 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5319 #endif
5320 }
5321 {
5322 if (temp1)
5323 delete arg1;
5324 }
5325 return resultobj;
5326 fail:
5327 {
5328 if (temp1)
5329 delete arg1;
5330 }
5331 return NULL;
5332 }
5333
5334
5335 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5336 PyObject *resultobj = 0;
5337 wxString result;
5338
5339 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5340 {
5341 PyThreadState* __tstate = wxPyBeginAllowThreads();
5342 result = wxGetEmailAddress();
5343 wxPyEndAllowThreads(__tstate);
5344 if (PyErr_Occurred()) SWIG_fail;
5345 }
5346 {
5347 #if wxUSE_UNICODE
5348 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5349 #else
5350 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5351 #endif
5352 }
5353 return resultobj;
5354 fail:
5355 return NULL;
5356 }
5357
5358
5359 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5360 PyObject *resultobj = 0;
5361 wxString result;
5362
5363 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5364 {
5365 PyThreadState* __tstate = wxPyBeginAllowThreads();
5366 result = wxGetHostName();
5367 wxPyEndAllowThreads(__tstate);
5368 if (PyErr_Occurred()) SWIG_fail;
5369 }
5370 {
5371 #if wxUSE_UNICODE
5372 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5373 #else
5374 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5375 #endif
5376 }
5377 return resultobj;
5378 fail:
5379 return NULL;
5380 }
5381
5382
5383 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5384 PyObject *resultobj = 0;
5385 wxString result;
5386
5387 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5388 {
5389 PyThreadState* __tstate = wxPyBeginAllowThreads();
5390 result = wxGetFullHostName();
5391 wxPyEndAllowThreads(__tstate);
5392 if (PyErr_Occurred()) SWIG_fail;
5393 }
5394 {
5395 #if wxUSE_UNICODE
5396 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5397 #else
5398 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5399 #endif
5400 }
5401 return resultobj;
5402 fail:
5403 return NULL;
5404 }
5405
5406
5407 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5408 PyObject *resultobj = 0;
5409 wxString result;
5410
5411 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5412 {
5413 PyThreadState* __tstate = wxPyBeginAllowThreads();
5414 result = wxGetUserId();
5415 wxPyEndAllowThreads(__tstate);
5416 if (PyErr_Occurred()) SWIG_fail;
5417 }
5418 {
5419 #if wxUSE_UNICODE
5420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5421 #else
5422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5423 #endif
5424 }
5425 return resultobj;
5426 fail:
5427 return NULL;
5428 }
5429
5430
5431 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5432 PyObject *resultobj = 0;
5433 wxString result;
5434
5435 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5436 {
5437 PyThreadState* __tstate = wxPyBeginAllowThreads();
5438 result = wxGetUserName();
5439 wxPyEndAllowThreads(__tstate);
5440 if (PyErr_Occurred()) SWIG_fail;
5441 }
5442 {
5443 #if wxUSE_UNICODE
5444 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5445 #else
5446 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5447 #endif
5448 }
5449 return resultobj;
5450 fail:
5451 return NULL;
5452 }
5453
5454
5455 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5456 PyObject *resultobj = 0;
5457 wxString result;
5458
5459 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5460 {
5461 PyThreadState* __tstate = wxPyBeginAllowThreads();
5462 result = wxGetHomeDir();
5463 wxPyEndAllowThreads(__tstate);
5464 if (PyErr_Occurred()) SWIG_fail;
5465 }
5466 {
5467 #if wxUSE_UNICODE
5468 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5469 #else
5470 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5471 #endif
5472 }
5473 return resultobj;
5474 fail:
5475 return NULL;
5476 }
5477
5478
5479 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5480 PyObject *resultobj = 0;
5481 wxString const &arg1_defvalue = wxPyEmptyString ;
5482 wxString *arg1 = (wxString *) &arg1_defvalue ;
5483 wxString result;
5484 bool temp1 = false ;
5485 PyObject * obj0 = 0 ;
5486 char * kwnames[] = {
5487 (char *) "user", NULL
5488 };
5489
5490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5491 if (obj0) {
5492 {
5493 arg1 = wxString_in_helper(obj0);
5494 if (arg1 == NULL) SWIG_fail;
5495 temp1 = true;
5496 }
5497 }
5498 {
5499 PyThreadState* __tstate = wxPyBeginAllowThreads();
5500 result = wxGetUserHome((wxString const &)*arg1);
5501 wxPyEndAllowThreads(__tstate);
5502 if (PyErr_Occurred()) SWIG_fail;
5503 }
5504 {
5505 #if wxUSE_UNICODE
5506 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5507 #else
5508 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5509 #endif
5510 }
5511 {
5512 if (temp1)
5513 delete arg1;
5514 }
5515 return resultobj;
5516 fail:
5517 {
5518 if (temp1)
5519 delete arg1;
5520 }
5521 return NULL;
5522 }
5523
5524
5525 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5526 PyObject *resultobj = 0;
5527 unsigned long result;
5528
5529 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5530 {
5531 PyThreadState* __tstate = wxPyBeginAllowThreads();
5532 result = (unsigned long)wxGetProcessId();
5533 wxPyEndAllowThreads(__tstate);
5534 if (PyErr_Occurred()) SWIG_fail;
5535 }
5536 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5537 return resultobj;
5538 fail:
5539 return NULL;
5540 }
5541
5542
5543 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5544 PyObject *resultobj = 0;
5545
5546 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5547 {
5548 PyThreadState* __tstate = wxPyBeginAllowThreads();
5549 wxTrap();
5550 wxPyEndAllowThreads(__tstate);
5551 if (PyErr_Occurred()) SWIG_fail;
5552 }
5553 resultobj = SWIG_Py_Void();
5554 return resultobj;
5555 fail:
5556 return NULL;
5557 }
5558
5559
5560 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5561 PyObject *resultobj = 0;
5562 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5563 wxString *arg1 = (wxString *) &arg1_defvalue ;
5564 wxString const &arg2_defvalue = wxPyEmptyString ;
5565 wxString *arg2 = (wxString *) &arg2_defvalue ;
5566 wxString const &arg3_defvalue = wxPyEmptyString ;
5567 wxString *arg3 = (wxString *) &arg3_defvalue ;
5568 wxString const &arg4_defvalue = wxPyEmptyString ;
5569 wxString *arg4 = (wxString *) &arg4_defvalue ;
5570 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5571 wxString *arg5 = (wxString *) &arg5_defvalue ;
5572 int arg6 = (int) 0 ;
5573 wxWindow *arg7 = (wxWindow *) NULL ;
5574 int arg8 = (int) -1 ;
5575 int arg9 = (int) -1 ;
5576 wxString result;
5577 bool temp1 = false ;
5578 bool temp2 = false ;
5579 bool temp3 = false ;
5580 bool temp4 = false ;
5581 bool temp5 = false ;
5582 int val6 ;
5583 int ecode6 = 0 ;
5584 void *argp7 = 0 ;
5585 int res7 = 0 ;
5586 int val8 ;
5587 int ecode8 = 0 ;
5588 int val9 ;
5589 int ecode9 = 0 ;
5590 PyObject * obj0 = 0 ;
5591 PyObject * obj1 = 0 ;
5592 PyObject * obj2 = 0 ;
5593 PyObject * obj3 = 0 ;
5594 PyObject * obj4 = 0 ;
5595 PyObject * obj5 = 0 ;
5596 PyObject * obj6 = 0 ;
5597 PyObject * obj7 = 0 ;
5598 PyObject * obj8 = 0 ;
5599 char * kwnames[] = {
5600 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5601 };
5602
5603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5604 if (obj0) {
5605 {
5606 arg1 = wxString_in_helper(obj0);
5607 if (arg1 == NULL) SWIG_fail;
5608 temp1 = true;
5609 }
5610 }
5611 if (obj1) {
5612 {
5613 arg2 = wxString_in_helper(obj1);
5614 if (arg2 == NULL) SWIG_fail;
5615 temp2 = true;
5616 }
5617 }
5618 if (obj2) {
5619 {
5620 arg3 = wxString_in_helper(obj2);
5621 if (arg3 == NULL) SWIG_fail;
5622 temp3 = true;
5623 }
5624 }
5625 if (obj3) {
5626 {
5627 arg4 = wxString_in_helper(obj3);
5628 if (arg4 == NULL) SWIG_fail;
5629 temp4 = true;
5630 }
5631 }
5632 if (obj4) {
5633 {
5634 arg5 = wxString_in_helper(obj4);
5635 if (arg5 == NULL) SWIG_fail;
5636 temp5 = true;
5637 }
5638 }
5639 if (obj5) {
5640 ecode6 = SWIG_AsVal_int(obj5, &val6);
5641 if (!SWIG_IsOK(ecode6)) {
5642 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5643 }
5644 arg6 = static_cast< int >(val6);
5645 }
5646 if (obj6) {
5647 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5648 if (!SWIG_IsOK(res7)) {
5649 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5650 }
5651 arg7 = reinterpret_cast< wxWindow * >(argp7);
5652 }
5653 if (obj7) {
5654 ecode8 = SWIG_AsVal_int(obj7, &val8);
5655 if (!SWIG_IsOK(ecode8)) {
5656 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5657 }
5658 arg8 = static_cast< int >(val8);
5659 }
5660 if (obj8) {
5661 ecode9 = SWIG_AsVal_int(obj8, &val9);
5662 if (!SWIG_IsOK(ecode9)) {
5663 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5664 }
5665 arg9 = static_cast< int >(val9);
5666 }
5667 {
5668 if (!wxPyCheckForApp()) SWIG_fail;
5669 PyThreadState* __tstate = wxPyBeginAllowThreads();
5670 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5671 wxPyEndAllowThreads(__tstate);
5672 if (PyErr_Occurred()) SWIG_fail;
5673 }
5674 {
5675 #if wxUSE_UNICODE
5676 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5677 #else
5678 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5679 #endif
5680 }
5681 {
5682 if (temp1)
5683 delete arg1;
5684 }
5685 {
5686 if (temp2)
5687 delete arg2;
5688 }
5689 {
5690 if (temp3)
5691 delete arg3;
5692 }
5693 {
5694 if (temp4)
5695 delete arg4;
5696 }
5697 {
5698 if (temp5)
5699 delete arg5;
5700 }
5701 return resultobj;
5702 fail:
5703 {
5704 if (temp1)
5705 delete arg1;
5706 }
5707 {
5708 if (temp2)
5709 delete arg2;
5710 }
5711 {
5712 if (temp3)
5713 delete arg3;
5714 }
5715 {
5716 if (temp4)
5717 delete arg4;
5718 }
5719 {
5720 if (temp5)
5721 delete arg5;
5722 }
5723 return NULL;
5724 }
5725
5726
5727 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5728 PyObject *resultobj = 0;
5729 wxString *arg1 = 0 ;
5730 wxString *arg2 = 0 ;
5731 wxString const &arg3_defvalue = wxPyEmptyString ;
5732 wxString *arg3 = (wxString *) &arg3_defvalue ;
5733 wxWindow *arg4 = (wxWindow *) NULL ;
5734 wxString result;
5735 bool temp1 = false ;
5736 bool temp2 = false ;
5737 bool temp3 = false ;
5738 void *argp4 = 0 ;
5739 int res4 = 0 ;
5740 PyObject * obj0 = 0 ;
5741 PyObject * obj1 = 0 ;
5742 PyObject * obj2 = 0 ;
5743 PyObject * obj3 = 0 ;
5744 char * kwnames[] = {
5745 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5746 };
5747
5748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5749 {
5750 arg1 = wxString_in_helper(obj0);
5751 if (arg1 == NULL) SWIG_fail;
5752 temp1 = true;
5753 }
5754 {
5755 arg2 = wxString_in_helper(obj1);
5756 if (arg2 == NULL) SWIG_fail;
5757 temp2 = true;
5758 }
5759 if (obj2) {
5760 {
5761 arg3 = wxString_in_helper(obj2);
5762 if (arg3 == NULL) SWIG_fail;
5763 temp3 = true;
5764 }
5765 }
5766 if (obj3) {
5767 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5768 if (!SWIG_IsOK(res4)) {
5769 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5770 }
5771 arg4 = reinterpret_cast< wxWindow * >(argp4);
5772 }
5773 {
5774 if (!wxPyCheckForApp()) SWIG_fail;
5775 PyThreadState* __tstate = wxPyBeginAllowThreads();
5776 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5777 wxPyEndAllowThreads(__tstate);
5778 if (PyErr_Occurred()) SWIG_fail;
5779 }
5780 {
5781 #if wxUSE_UNICODE
5782 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5783 #else
5784 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5785 #endif
5786 }
5787 {
5788 if (temp1)
5789 delete arg1;
5790 }
5791 {
5792 if (temp2)
5793 delete arg2;
5794 }
5795 {
5796 if (temp3)
5797 delete arg3;
5798 }
5799 return resultobj;
5800 fail:
5801 {
5802 if (temp1)
5803 delete arg1;
5804 }
5805 {
5806 if (temp2)
5807 delete arg2;
5808 }
5809 {
5810 if (temp3)
5811 delete arg3;
5812 }
5813 return NULL;
5814 }
5815
5816
5817 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5818 PyObject *resultobj = 0;
5819 wxString *arg1 = 0 ;
5820 wxString *arg2 = 0 ;
5821 wxString const &arg3_defvalue = wxPyEmptyString ;
5822 wxString *arg3 = (wxString *) &arg3_defvalue ;
5823 wxWindow *arg4 = (wxWindow *) NULL ;
5824 wxString result;
5825 bool temp1 = false ;
5826 bool temp2 = false ;
5827 bool temp3 = false ;
5828 void *argp4 = 0 ;
5829 int res4 = 0 ;
5830 PyObject * obj0 = 0 ;
5831 PyObject * obj1 = 0 ;
5832 PyObject * obj2 = 0 ;
5833 PyObject * obj3 = 0 ;
5834 char * kwnames[] = {
5835 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5836 };
5837
5838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5839 {
5840 arg1 = wxString_in_helper(obj0);
5841 if (arg1 == NULL) SWIG_fail;
5842 temp1 = true;
5843 }
5844 {
5845 arg2 = wxString_in_helper(obj1);
5846 if (arg2 == NULL) SWIG_fail;
5847 temp2 = true;
5848 }
5849 if (obj2) {
5850 {
5851 arg3 = wxString_in_helper(obj2);
5852 if (arg3 == NULL) SWIG_fail;
5853 temp3 = true;
5854 }
5855 }
5856 if (obj3) {
5857 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5858 if (!SWIG_IsOK(res4)) {
5859 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5860 }
5861 arg4 = reinterpret_cast< wxWindow * >(argp4);
5862 }
5863 {
5864 if (!wxPyCheckForApp()) SWIG_fail;
5865 PyThreadState* __tstate = wxPyBeginAllowThreads();
5866 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5867 wxPyEndAllowThreads(__tstate);
5868 if (PyErr_Occurred()) SWIG_fail;
5869 }
5870 {
5871 #if wxUSE_UNICODE
5872 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5873 #else
5874 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5875 #endif
5876 }
5877 {
5878 if (temp1)
5879 delete arg1;
5880 }
5881 {
5882 if (temp2)
5883 delete arg2;
5884 }
5885 {
5886 if (temp3)
5887 delete arg3;
5888 }
5889 return resultobj;
5890 fail:
5891 {
5892 if (temp1)
5893 delete arg1;
5894 }
5895 {
5896 if (temp2)
5897 delete arg2;
5898 }
5899 {
5900 if (temp3)
5901 delete arg3;
5902 }
5903 return NULL;
5904 }
5905
5906
5907 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5908 PyObject *resultobj = 0;
5909 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5910 wxString *arg1 = (wxString *) &arg1_defvalue ;
5911 wxString const &arg2_defvalue = wxPyEmptyString ;
5912 wxString *arg2 = (wxString *) &arg2_defvalue ;
5913 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5914 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5915 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5916 wxWindow *arg5 = (wxWindow *) NULL ;
5917 wxString result;
5918 bool temp1 = false ;
5919 bool temp2 = false ;
5920 long val3 ;
5921 int ecode3 = 0 ;
5922 wxPoint temp4 ;
5923 void *argp5 = 0 ;
5924 int res5 = 0 ;
5925 PyObject * obj0 = 0 ;
5926 PyObject * obj1 = 0 ;
5927 PyObject * obj2 = 0 ;
5928 PyObject * obj3 = 0 ;
5929 PyObject * obj4 = 0 ;
5930 char * kwnames[] = {
5931 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5932 };
5933
5934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5935 if (obj0) {
5936 {
5937 arg1 = wxString_in_helper(obj0);
5938 if (arg1 == NULL) SWIG_fail;
5939 temp1 = true;
5940 }
5941 }
5942 if (obj1) {
5943 {
5944 arg2 = wxString_in_helper(obj1);
5945 if (arg2 == NULL) SWIG_fail;
5946 temp2 = true;
5947 }
5948 }
5949 if (obj2) {
5950 ecode3 = SWIG_AsVal_long(obj2, &val3);
5951 if (!SWIG_IsOK(ecode3)) {
5952 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5953 }
5954 arg3 = static_cast< long >(val3);
5955 }
5956 if (obj3) {
5957 {
5958 arg4 = &temp4;
5959 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5960 }
5961 }
5962 if (obj4) {
5963 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5964 if (!SWIG_IsOK(res5)) {
5965 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5966 }
5967 arg5 = reinterpret_cast< wxWindow * >(argp5);
5968 }
5969 {
5970 if (!wxPyCheckForApp()) SWIG_fail;
5971 PyThreadState* __tstate = wxPyBeginAllowThreads();
5972 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5973 wxPyEndAllowThreads(__tstate);
5974 if (PyErr_Occurred()) SWIG_fail;
5975 }
5976 {
5977 #if wxUSE_UNICODE
5978 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5979 #else
5980 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5981 #endif
5982 }
5983 {
5984 if (temp1)
5985 delete arg1;
5986 }
5987 {
5988 if (temp2)
5989 delete arg2;
5990 }
5991 return resultobj;
5992 fail:
5993 {
5994 if (temp1)
5995 delete arg1;
5996 }
5997 {
5998 if (temp2)
5999 delete arg2;
6000 }
6001 return NULL;
6002 }
6003
6004
6005 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6006 PyObject *resultobj = 0;
6007 wxString *arg1 = 0 ;
6008 wxString const &arg2_defvalue = wxPyEmptyString ;
6009 wxString *arg2 = (wxString *) &arg2_defvalue ;
6010 wxString const &arg3_defvalue = wxPyEmptyString ;
6011 wxString *arg3 = (wxString *) &arg3_defvalue ;
6012 wxWindow *arg4 = (wxWindow *) NULL ;
6013 int arg5 = (int) -1 ;
6014 int arg6 = (int) -1 ;
6015 bool arg7 = (bool) true ;
6016 wxString result;
6017 bool temp1 = false ;
6018 bool temp2 = false ;
6019 bool temp3 = false ;
6020 void *argp4 = 0 ;
6021 int res4 = 0 ;
6022 int val5 ;
6023 int ecode5 = 0 ;
6024 int val6 ;
6025 int ecode6 = 0 ;
6026 bool val7 ;
6027 int ecode7 = 0 ;
6028 PyObject * obj0 = 0 ;
6029 PyObject * obj1 = 0 ;
6030 PyObject * obj2 = 0 ;
6031 PyObject * obj3 = 0 ;
6032 PyObject * obj4 = 0 ;
6033 PyObject * obj5 = 0 ;
6034 PyObject * obj6 = 0 ;
6035 char * kwnames[] = {
6036 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6037 };
6038
6039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6040 {
6041 arg1 = wxString_in_helper(obj0);
6042 if (arg1 == NULL) SWIG_fail;
6043 temp1 = true;
6044 }
6045 if (obj1) {
6046 {
6047 arg2 = wxString_in_helper(obj1);
6048 if (arg2 == NULL) SWIG_fail;
6049 temp2 = true;
6050 }
6051 }
6052 if (obj2) {
6053 {
6054 arg3 = wxString_in_helper(obj2);
6055 if (arg3 == NULL) SWIG_fail;
6056 temp3 = true;
6057 }
6058 }
6059 if (obj3) {
6060 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6061 if (!SWIG_IsOK(res4)) {
6062 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6063 }
6064 arg4 = reinterpret_cast< wxWindow * >(argp4);
6065 }
6066 if (obj4) {
6067 ecode5 = SWIG_AsVal_int(obj4, &val5);
6068 if (!SWIG_IsOK(ecode5)) {
6069 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6070 }
6071 arg5 = static_cast< int >(val5);
6072 }
6073 if (obj5) {
6074 ecode6 = SWIG_AsVal_int(obj5, &val6);
6075 if (!SWIG_IsOK(ecode6)) {
6076 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6077 }
6078 arg6 = static_cast< int >(val6);
6079 }
6080 if (obj6) {
6081 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6082 if (!SWIG_IsOK(ecode7)) {
6083 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6084 }
6085 arg7 = static_cast< bool >(val7);
6086 }
6087 {
6088 if (!wxPyCheckForApp()) SWIG_fail;
6089 PyThreadState* __tstate = wxPyBeginAllowThreads();
6090 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6091 wxPyEndAllowThreads(__tstate);
6092 if (PyErr_Occurred()) SWIG_fail;
6093 }
6094 {
6095 #if wxUSE_UNICODE
6096 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6097 #else
6098 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6099 #endif
6100 }
6101 {
6102 if (temp1)
6103 delete arg1;
6104 }
6105 {
6106 if (temp2)
6107 delete arg2;
6108 }
6109 {
6110 if (temp3)
6111 delete arg3;
6112 }
6113 return resultobj;
6114 fail:
6115 {
6116 if (temp1)
6117 delete arg1;
6118 }
6119 {
6120 if (temp2)
6121 delete arg2;
6122 }
6123 {
6124 if (temp3)
6125 delete arg3;
6126 }
6127 return NULL;
6128 }
6129
6130
6131 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6132 PyObject *resultobj = 0;
6133 wxString *arg1 = 0 ;
6134 wxString const &arg2_defvalue = wxPyEmptyString ;
6135 wxString *arg2 = (wxString *) &arg2_defvalue ;
6136 wxString const &arg3_defvalue = wxPyEmptyString ;
6137 wxString *arg3 = (wxString *) &arg3_defvalue ;
6138 wxWindow *arg4 = (wxWindow *) NULL ;
6139 wxString result;
6140 bool temp1 = false ;
6141 bool temp2 = false ;
6142 bool temp3 = false ;
6143 void *argp4 = 0 ;
6144 int res4 = 0 ;
6145 PyObject * obj0 = 0 ;
6146 PyObject * obj1 = 0 ;
6147 PyObject * obj2 = 0 ;
6148 PyObject * obj3 = 0 ;
6149 char * kwnames[] = {
6150 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6151 };
6152
6153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6154 {
6155 arg1 = wxString_in_helper(obj0);
6156 if (arg1 == NULL) SWIG_fail;
6157 temp1 = true;
6158 }
6159 if (obj1) {
6160 {
6161 arg2 = wxString_in_helper(obj1);
6162 if (arg2 == NULL) SWIG_fail;
6163 temp2 = true;
6164 }
6165 }
6166 if (obj2) {
6167 {
6168 arg3 = wxString_in_helper(obj2);
6169 if (arg3 == NULL) SWIG_fail;
6170 temp3 = true;
6171 }
6172 }
6173 if (obj3) {
6174 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6175 if (!SWIG_IsOK(res4)) {
6176 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6177 }
6178 arg4 = reinterpret_cast< wxWindow * >(argp4);
6179 }
6180 {
6181 if (!wxPyCheckForApp()) SWIG_fail;
6182 PyThreadState* __tstate = wxPyBeginAllowThreads();
6183 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6184 wxPyEndAllowThreads(__tstate);
6185 if (PyErr_Occurred()) SWIG_fail;
6186 }
6187 {
6188 #if wxUSE_UNICODE
6189 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6190 #else
6191 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6192 #endif
6193 }
6194 {
6195 if (temp1)
6196 delete arg1;
6197 }
6198 {
6199 if (temp2)
6200 delete arg2;
6201 }
6202 {
6203 if (temp3)
6204 delete arg3;
6205 }
6206 return resultobj;
6207 fail:
6208 {
6209 if (temp1)
6210 delete arg1;
6211 }
6212 {
6213 if (temp2)
6214 delete arg2;
6215 }
6216 {
6217 if (temp3)
6218 delete arg3;
6219 }
6220 return NULL;
6221 }
6222
6223
6224 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6225 PyObject *resultobj = 0;
6226 wxString *arg1 = 0 ;
6227 wxString *arg2 = 0 ;
6228 int arg3 ;
6229 wxString *arg4 = (wxString *) 0 ;
6230 wxWindow *arg5 = (wxWindow *) NULL ;
6231 int arg6 = (int) -1 ;
6232 int arg7 = (int) -1 ;
6233 bool arg8 = (bool) true ;
6234 int arg9 = (int) 150 ;
6235 int arg10 = (int) 200 ;
6236 wxString result;
6237 bool temp1 = false ;
6238 bool temp2 = false ;
6239 void *argp5 = 0 ;
6240 int res5 = 0 ;
6241 int val6 ;
6242 int ecode6 = 0 ;
6243 int val7 ;
6244 int ecode7 = 0 ;
6245 bool val8 ;
6246 int ecode8 = 0 ;
6247 int val9 ;
6248 int ecode9 = 0 ;
6249 int val10 ;
6250 int ecode10 = 0 ;
6251 PyObject * obj0 = 0 ;
6252 PyObject * obj1 = 0 ;
6253 PyObject * obj2 = 0 ;
6254 PyObject * obj3 = 0 ;
6255 PyObject * obj4 = 0 ;
6256 PyObject * obj5 = 0 ;
6257 PyObject * obj6 = 0 ;
6258 PyObject * obj7 = 0 ;
6259 PyObject * obj8 = 0 ;
6260 char * kwnames[] = {
6261 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6262 };
6263
6264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6265 {
6266 arg1 = wxString_in_helper(obj0);
6267 if (arg1 == NULL) SWIG_fail;
6268 temp1 = true;
6269 }
6270 {
6271 arg2 = wxString_in_helper(obj1);
6272 if (arg2 == NULL) SWIG_fail;
6273 temp2 = true;
6274 }
6275 {
6276 arg3 = PyList_Size(obj2);
6277 arg4 = wxString_LIST_helper(obj2);
6278 if (arg4 == NULL) SWIG_fail;
6279 }
6280 if (obj3) {
6281 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6282 if (!SWIG_IsOK(res5)) {
6283 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6284 }
6285 arg5 = reinterpret_cast< wxWindow * >(argp5);
6286 }
6287 if (obj4) {
6288 ecode6 = SWIG_AsVal_int(obj4, &val6);
6289 if (!SWIG_IsOK(ecode6)) {
6290 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6291 }
6292 arg6 = static_cast< int >(val6);
6293 }
6294 if (obj5) {
6295 ecode7 = SWIG_AsVal_int(obj5, &val7);
6296 if (!SWIG_IsOK(ecode7)) {
6297 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6298 }
6299 arg7 = static_cast< int >(val7);
6300 }
6301 if (obj6) {
6302 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6303 if (!SWIG_IsOK(ecode8)) {
6304 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6305 }
6306 arg8 = static_cast< bool >(val8);
6307 }
6308 if (obj7) {
6309 ecode9 = SWIG_AsVal_int(obj7, &val9);
6310 if (!SWIG_IsOK(ecode9)) {
6311 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6312 }
6313 arg9 = static_cast< int >(val9);
6314 }
6315 if (obj8) {
6316 ecode10 = SWIG_AsVal_int(obj8, &val10);
6317 if (!SWIG_IsOK(ecode10)) {
6318 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6319 }
6320 arg10 = static_cast< int >(val10);
6321 }
6322 {
6323 if (!wxPyCheckForApp()) SWIG_fail;
6324 PyThreadState* __tstate = wxPyBeginAllowThreads();
6325 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6326 wxPyEndAllowThreads(__tstate);
6327 if (PyErr_Occurred()) SWIG_fail;
6328 }
6329 {
6330 #if wxUSE_UNICODE
6331 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6332 #else
6333 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6334 #endif
6335 }
6336 {
6337 if (temp1)
6338 delete arg1;
6339 }
6340 {
6341 if (temp2)
6342 delete arg2;
6343 }
6344 {
6345 if (arg4) delete [] arg4;
6346 }
6347 return resultobj;
6348 fail:
6349 {
6350 if (temp1)
6351 delete arg1;
6352 }
6353 {
6354 if (temp2)
6355 delete arg2;
6356 }
6357 {
6358 if (arg4) delete [] arg4;
6359 }
6360 return NULL;
6361 }
6362
6363
6364 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6365 PyObject *resultobj = 0;
6366 wxString *arg1 = 0 ;
6367 wxString *arg2 = 0 ;
6368 int arg3 ;
6369 wxString *arg4 = (wxString *) 0 ;
6370 wxWindow *arg5 = (wxWindow *) NULL ;
6371 int arg6 = (int) -1 ;
6372 int arg7 = (int) -1 ;
6373 bool arg8 = (bool) true ;
6374 int arg9 = (int) 150 ;
6375 int arg10 = (int) 200 ;
6376 int result;
6377 bool temp1 = false ;
6378 bool temp2 = false ;
6379 void *argp5 = 0 ;
6380 int res5 = 0 ;
6381 int val6 ;
6382 int ecode6 = 0 ;
6383 int val7 ;
6384 int ecode7 = 0 ;
6385 bool val8 ;
6386 int ecode8 = 0 ;
6387 int val9 ;
6388 int ecode9 = 0 ;
6389 int val10 ;
6390 int ecode10 = 0 ;
6391 PyObject * obj0 = 0 ;
6392 PyObject * obj1 = 0 ;
6393 PyObject * obj2 = 0 ;
6394 PyObject * obj3 = 0 ;
6395 PyObject * obj4 = 0 ;
6396 PyObject * obj5 = 0 ;
6397 PyObject * obj6 = 0 ;
6398 PyObject * obj7 = 0 ;
6399 PyObject * obj8 = 0 ;
6400 char * kwnames[] = {
6401 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6402 };
6403
6404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6405 {
6406 arg1 = wxString_in_helper(obj0);
6407 if (arg1 == NULL) SWIG_fail;
6408 temp1 = true;
6409 }
6410 {
6411 arg2 = wxString_in_helper(obj1);
6412 if (arg2 == NULL) SWIG_fail;
6413 temp2 = true;
6414 }
6415 {
6416 arg3 = PyList_Size(obj2);
6417 arg4 = wxString_LIST_helper(obj2);
6418 if (arg4 == NULL) SWIG_fail;
6419 }
6420 if (obj3) {
6421 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6422 if (!SWIG_IsOK(res5)) {
6423 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6424 }
6425 arg5 = reinterpret_cast< wxWindow * >(argp5);
6426 }
6427 if (obj4) {
6428 ecode6 = SWIG_AsVal_int(obj4, &val6);
6429 if (!SWIG_IsOK(ecode6)) {
6430 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6431 }
6432 arg6 = static_cast< int >(val6);
6433 }
6434 if (obj5) {
6435 ecode7 = SWIG_AsVal_int(obj5, &val7);
6436 if (!SWIG_IsOK(ecode7)) {
6437 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6438 }
6439 arg7 = static_cast< int >(val7);
6440 }
6441 if (obj6) {
6442 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6443 if (!SWIG_IsOK(ecode8)) {
6444 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6445 }
6446 arg8 = static_cast< bool >(val8);
6447 }
6448 if (obj7) {
6449 ecode9 = SWIG_AsVal_int(obj7, &val9);
6450 if (!SWIG_IsOK(ecode9)) {
6451 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6452 }
6453 arg9 = static_cast< int >(val9);
6454 }
6455 if (obj8) {
6456 ecode10 = SWIG_AsVal_int(obj8, &val10);
6457 if (!SWIG_IsOK(ecode10)) {
6458 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6459 }
6460 arg10 = static_cast< int >(val10);
6461 }
6462 {
6463 if (!wxPyCheckForApp()) SWIG_fail;
6464 PyThreadState* __tstate = wxPyBeginAllowThreads();
6465 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6466 wxPyEndAllowThreads(__tstate);
6467 if (PyErr_Occurred()) SWIG_fail;
6468 }
6469 resultobj = SWIG_From_int(static_cast< int >(result));
6470 {
6471 if (temp1)
6472 delete arg1;
6473 }
6474 {
6475 if (temp2)
6476 delete arg2;
6477 }
6478 {
6479 if (arg4) delete [] arg4;
6480 }
6481 return resultobj;
6482 fail:
6483 {
6484 if (temp1)
6485 delete arg1;
6486 }
6487 {
6488 if (temp2)
6489 delete arg2;
6490 }
6491 {
6492 if (arg4) delete [] arg4;
6493 }
6494 return NULL;
6495 }
6496
6497
6498 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6499 PyObject *resultobj = 0;
6500 wxString *arg1 = 0 ;
6501 wxString const &arg2_defvalue = wxPyEmptyString ;
6502 wxString *arg2 = (wxString *) &arg2_defvalue ;
6503 int arg3 = (int) wxOK|wxCENTRE ;
6504 wxWindow *arg4 = (wxWindow *) NULL ;
6505 int arg5 = (int) -1 ;
6506 int arg6 = (int) -1 ;
6507 int result;
6508 bool temp1 = false ;
6509 bool temp2 = false ;
6510 int val3 ;
6511 int ecode3 = 0 ;
6512 void *argp4 = 0 ;
6513 int res4 = 0 ;
6514 int val5 ;
6515 int ecode5 = 0 ;
6516 int val6 ;
6517 int ecode6 = 0 ;
6518 PyObject * obj0 = 0 ;
6519 PyObject * obj1 = 0 ;
6520 PyObject * obj2 = 0 ;
6521 PyObject * obj3 = 0 ;
6522 PyObject * obj4 = 0 ;
6523 PyObject * obj5 = 0 ;
6524 char * kwnames[] = {
6525 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6526 };
6527
6528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6529 {
6530 arg1 = wxString_in_helper(obj0);
6531 if (arg1 == NULL) SWIG_fail;
6532 temp1 = true;
6533 }
6534 if (obj1) {
6535 {
6536 arg2 = wxString_in_helper(obj1);
6537 if (arg2 == NULL) SWIG_fail;
6538 temp2 = true;
6539 }
6540 }
6541 if (obj2) {
6542 ecode3 = SWIG_AsVal_int(obj2, &val3);
6543 if (!SWIG_IsOK(ecode3)) {
6544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6545 }
6546 arg3 = static_cast< int >(val3);
6547 }
6548 if (obj3) {
6549 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6550 if (!SWIG_IsOK(res4)) {
6551 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6552 }
6553 arg4 = reinterpret_cast< wxWindow * >(argp4);
6554 }
6555 if (obj4) {
6556 ecode5 = SWIG_AsVal_int(obj4, &val5);
6557 if (!SWIG_IsOK(ecode5)) {
6558 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6559 }
6560 arg5 = static_cast< int >(val5);
6561 }
6562 if (obj5) {
6563 ecode6 = SWIG_AsVal_int(obj5, &val6);
6564 if (!SWIG_IsOK(ecode6)) {
6565 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6566 }
6567 arg6 = static_cast< int >(val6);
6568 }
6569 {
6570 if (!wxPyCheckForApp()) SWIG_fail;
6571 PyThreadState* __tstate = wxPyBeginAllowThreads();
6572 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6573 wxPyEndAllowThreads(__tstate);
6574 if (PyErr_Occurred()) SWIG_fail;
6575 }
6576 resultobj = SWIG_From_int(static_cast< int >(result));
6577 {
6578 if (temp1)
6579 delete arg1;
6580 }
6581 {
6582 if (temp2)
6583 delete arg2;
6584 }
6585 return resultobj;
6586 fail:
6587 {
6588 if (temp1)
6589 delete arg1;
6590 }
6591 {
6592 if (temp2)
6593 delete arg2;
6594 }
6595 return NULL;
6596 }
6597
6598
6599 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6600 PyObject *resultobj = 0;
6601 wxString *arg1 = 0 ;
6602 wxString *arg2 = 0 ;
6603 wxString *arg3 = 0 ;
6604 long arg4 ;
6605 long arg5 = (long) 0 ;
6606 long arg6 = (long) 100 ;
6607 wxWindow *arg7 = (wxWindow *) NULL ;
6608 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6609 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6610 long result;
6611 bool temp1 = false ;
6612 bool temp2 = false ;
6613 bool temp3 = false ;
6614 long val4 ;
6615 int ecode4 = 0 ;
6616 long val5 ;
6617 int ecode5 = 0 ;
6618 long val6 ;
6619 int ecode6 = 0 ;
6620 void *argp7 = 0 ;
6621 int res7 = 0 ;
6622 wxPoint temp8 ;
6623 PyObject * obj0 = 0 ;
6624 PyObject * obj1 = 0 ;
6625 PyObject * obj2 = 0 ;
6626 PyObject * obj3 = 0 ;
6627 PyObject * obj4 = 0 ;
6628 PyObject * obj5 = 0 ;
6629 PyObject * obj6 = 0 ;
6630 PyObject * obj7 = 0 ;
6631 char * kwnames[] = {
6632 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6633 };
6634
6635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6636 {
6637 arg1 = wxString_in_helper(obj0);
6638 if (arg1 == NULL) SWIG_fail;
6639 temp1 = true;
6640 }
6641 {
6642 arg2 = wxString_in_helper(obj1);
6643 if (arg2 == NULL) SWIG_fail;
6644 temp2 = true;
6645 }
6646 {
6647 arg3 = wxString_in_helper(obj2);
6648 if (arg3 == NULL) SWIG_fail;
6649 temp3 = true;
6650 }
6651 ecode4 = SWIG_AsVal_long(obj3, &val4);
6652 if (!SWIG_IsOK(ecode4)) {
6653 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6654 }
6655 arg4 = static_cast< long >(val4);
6656 if (obj4) {
6657 ecode5 = SWIG_AsVal_long(obj4, &val5);
6658 if (!SWIG_IsOK(ecode5)) {
6659 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6660 }
6661 arg5 = static_cast< long >(val5);
6662 }
6663 if (obj5) {
6664 ecode6 = SWIG_AsVal_long(obj5, &val6);
6665 if (!SWIG_IsOK(ecode6)) {
6666 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6667 }
6668 arg6 = static_cast< long >(val6);
6669 }
6670 if (obj6) {
6671 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6672 if (!SWIG_IsOK(res7)) {
6673 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6674 }
6675 arg7 = reinterpret_cast< wxWindow * >(argp7);
6676 }
6677 if (obj7) {
6678 {
6679 arg8 = &temp8;
6680 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6681 }
6682 }
6683 {
6684 if (!wxPyCheckForApp()) SWIG_fail;
6685 PyThreadState* __tstate = wxPyBeginAllowThreads();
6686 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6687 wxPyEndAllowThreads(__tstate);
6688 if (PyErr_Occurred()) SWIG_fail;
6689 }
6690 resultobj = SWIG_From_long(static_cast< long >(result));
6691 {
6692 if (temp1)
6693 delete arg1;
6694 }
6695 {
6696 if (temp2)
6697 delete arg2;
6698 }
6699 {
6700 if (temp3)
6701 delete arg3;
6702 }
6703 return resultobj;
6704 fail:
6705 {
6706 if (temp1)
6707 delete arg1;
6708 }
6709 {
6710 if (temp2)
6711 delete arg2;
6712 }
6713 {
6714 if (temp3)
6715 delete arg3;
6716 }
6717 return NULL;
6718 }
6719
6720
6721 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6722 PyObject *resultobj = 0;
6723 bool result;
6724
6725 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6726 {
6727 if (!wxPyCheckForApp()) SWIG_fail;
6728 PyThreadState* __tstate = wxPyBeginAllowThreads();
6729 result = (bool)wxColourDisplay();
6730 wxPyEndAllowThreads(__tstate);
6731 if (PyErr_Occurred()) SWIG_fail;
6732 }
6733 {
6734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6735 }
6736 return resultobj;
6737 fail:
6738 return NULL;
6739 }
6740
6741
6742 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6743 PyObject *resultobj = 0;
6744 int result;
6745
6746 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6747 {
6748 if (!wxPyCheckForApp()) SWIG_fail;
6749 PyThreadState* __tstate = wxPyBeginAllowThreads();
6750 result = (int)wxDisplayDepth();
6751 wxPyEndAllowThreads(__tstate);
6752 if (PyErr_Occurred()) SWIG_fail;
6753 }
6754 resultobj = SWIG_From_int(static_cast< int >(result));
6755 return resultobj;
6756 fail:
6757 return NULL;
6758 }
6759
6760
6761 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6762 PyObject *resultobj = 0;
6763 int result;
6764
6765 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6766 {
6767 if (!wxPyCheckForApp()) SWIG_fail;
6768 PyThreadState* __tstate = wxPyBeginAllowThreads();
6769 result = (int)wxGetDisplayDepth();
6770 wxPyEndAllowThreads(__tstate);
6771 if (PyErr_Occurred()) SWIG_fail;
6772 }
6773 resultobj = SWIG_From_int(static_cast< int >(result));
6774 return resultobj;
6775 fail:
6776 return NULL;
6777 }
6778
6779
6780 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6781 PyObject *resultobj = 0;
6782 int *arg1 = (int *) 0 ;
6783 int *arg2 = (int *) 0 ;
6784 int temp1 ;
6785 int res1 = SWIG_TMPOBJ ;
6786 int temp2 ;
6787 int res2 = SWIG_TMPOBJ ;
6788
6789 arg1 = &temp1;
6790 arg2 = &temp2;
6791 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6792 {
6793 if (!wxPyCheckForApp()) SWIG_fail;
6794 PyThreadState* __tstate = wxPyBeginAllowThreads();
6795 wxDisplaySize(arg1,arg2);
6796 wxPyEndAllowThreads(__tstate);
6797 if (PyErr_Occurred()) SWIG_fail;
6798 }
6799 resultobj = SWIG_Py_Void();
6800 if (SWIG_IsTmpObj(res1)) {
6801 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6802 } else {
6803 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6804 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6805 }
6806 if (SWIG_IsTmpObj(res2)) {
6807 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6808 } else {
6809 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6810 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6811 }
6812 return resultobj;
6813 fail:
6814 return NULL;
6815 }
6816
6817
6818 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6819 PyObject *resultobj = 0;
6820 wxSize result;
6821
6822 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6823 {
6824 if (!wxPyCheckForApp()) SWIG_fail;
6825 PyThreadState* __tstate = wxPyBeginAllowThreads();
6826 result = wxGetDisplaySize();
6827 wxPyEndAllowThreads(__tstate);
6828 if (PyErr_Occurred()) SWIG_fail;
6829 }
6830 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6831 return resultobj;
6832 fail:
6833 return NULL;
6834 }
6835
6836
6837 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6838 PyObject *resultobj = 0;
6839 int *arg1 = (int *) 0 ;
6840 int *arg2 = (int *) 0 ;
6841 int temp1 ;
6842 int res1 = SWIG_TMPOBJ ;
6843 int temp2 ;
6844 int res2 = SWIG_TMPOBJ ;
6845
6846 arg1 = &temp1;
6847 arg2 = &temp2;
6848 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6849 {
6850 if (!wxPyCheckForApp()) SWIG_fail;
6851 PyThreadState* __tstate = wxPyBeginAllowThreads();
6852 wxDisplaySizeMM(arg1,arg2);
6853 wxPyEndAllowThreads(__tstate);
6854 if (PyErr_Occurred()) SWIG_fail;
6855 }
6856 resultobj = SWIG_Py_Void();
6857 if (SWIG_IsTmpObj(res1)) {
6858 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6859 } else {
6860 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6861 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6862 }
6863 if (SWIG_IsTmpObj(res2)) {
6864 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6865 } else {
6866 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6867 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6868 }
6869 return resultobj;
6870 fail:
6871 return NULL;
6872 }
6873
6874
6875 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6876 PyObject *resultobj = 0;
6877 wxSize result;
6878
6879 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6880 {
6881 if (!wxPyCheckForApp()) SWIG_fail;
6882 PyThreadState* __tstate = wxPyBeginAllowThreads();
6883 result = wxGetDisplaySizeMM();
6884 wxPyEndAllowThreads(__tstate);
6885 if (PyErr_Occurred()) SWIG_fail;
6886 }
6887 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6888 return resultobj;
6889 fail:
6890 return NULL;
6891 }
6892
6893
6894 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6895 PyObject *resultobj = 0;
6896 int *arg1 = (int *) 0 ;
6897 int *arg2 = (int *) 0 ;
6898 int *arg3 = (int *) 0 ;
6899 int *arg4 = (int *) 0 ;
6900 int temp1 ;
6901 int res1 = SWIG_TMPOBJ ;
6902 int temp2 ;
6903 int res2 = SWIG_TMPOBJ ;
6904 int temp3 ;
6905 int res3 = SWIG_TMPOBJ ;
6906 int temp4 ;
6907 int res4 = SWIG_TMPOBJ ;
6908
6909 arg1 = &temp1;
6910 arg2 = &temp2;
6911 arg3 = &temp3;
6912 arg4 = &temp4;
6913 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6914 {
6915 if (!wxPyCheckForApp()) SWIG_fail;
6916 PyThreadState* __tstate = wxPyBeginAllowThreads();
6917 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6918 wxPyEndAllowThreads(__tstate);
6919 if (PyErr_Occurred()) SWIG_fail;
6920 }
6921 resultobj = SWIG_Py_Void();
6922 if (SWIG_IsTmpObj(res1)) {
6923 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6924 } else {
6925 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6926 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6927 }
6928 if (SWIG_IsTmpObj(res2)) {
6929 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6930 } else {
6931 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6932 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6933 }
6934 if (SWIG_IsTmpObj(res3)) {
6935 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6936 } else {
6937 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6938 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6939 }
6940 if (SWIG_IsTmpObj(res4)) {
6941 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6942 } else {
6943 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6944 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6945 }
6946 return resultobj;
6947 fail:
6948 return NULL;
6949 }
6950
6951
6952 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6953 PyObject *resultobj = 0;
6954 wxRect result;
6955
6956 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6957 {
6958 if (!wxPyCheckForApp()) SWIG_fail;
6959 PyThreadState* __tstate = wxPyBeginAllowThreads();
6960 result = wxGetClientDisplayRect();
6961 wxPyEndAllowThreads(__tstate);
6962 if (PyErr_Occurred()) SWIG_fail;
6963 }
6964 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6965 return resultobj;
6966 fail:
6967 return NULL;
6968 }
6969
6970
6971 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6972 PyObject *resultobj = 0;
6973 wxCursor *arg1 = 0 ;
6974 void *argp1 = 0 ;
6975 int res1 = 0 ;
6976 PyObject * obj0 = 0 ;
6977 char * kwnames[] = {
6978 (char *) "cursor", NULL
6979 };
6980
6981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6982 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6983 if (!SWIG_IsOK(res1)) {
6984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6985 }
6986 if (!argp1) {
6987 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6988 }
6989 arg1 = reinterpret_cast< wxCursor * >(argp1);
6990 {
6991 if (!wxPyCheckForApp()) SWIG_fail;
6992 PyThreadState* __tstate = wxPyBeginAllowThreads();
6993 wxSetCursor(*arg1);
6994 wxPyEndAllowThreads(__tstate);
6995 if (PyErr_Occurred()) SWIG_fail;
6996 }
6997 resultobj = SWIG_Py_Void();
6998 return resultobj;
6999 fail:
7000 return NULL;
7001 }
7002
7003
7004 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7005 PyObject *resultobj = 0;
7006 void *result = 0 ;
7007
7008 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7009 {
7010 if (!wxPyCheckForApp()) SWIG_fail;
7011 PyThreadState* __tstate = wxPyBeginAllowThreads();
7012 result = (void *)wxGetXDisplay();
7013 wxPyEndAllowThreads(__tstate);
7014 if (PyErr_Occurred()) SWIG_fail;
7015 }
7016 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7017 return resultobj;
7018 fail:
7019 return NULL;
7020 }
7021
7022
7023 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7024 PyObject *resultobj = 0;
7025 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7026 void *argp1 = 0 ;
7027 int res1 = 0 ;
7028 PyObject * obj0 = 0 ;
7029 char * kwnames[] = {
7030 (char *) "cursor", NULL
7031 };
7032
7033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7034 if (obj0) {
7035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7036 if (!SWIG_IsOK(res1)) {
7037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7038 }
7039 arg1 = reinterpret_cast< wxCursor * >(argp1);
7040 }
7041 {
7042 if (!wxPyCheckForApp()) SWIG_fail;
7043 PyThreadState* __tstate = wxPyBeginAllowThreads();
7044 wxBeginBusyCursor(arg1);
7045 wxPyEndAllowThreads(__tstate);
7046 if (PyErr_Occurred()) SWIG_fail;
7047 }
7048 resultobj = SWIG_Py_Void();
7049 return resultobj;
7050 fail:
7051 return NULL;
7052 }
7053
7054
7055 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7056 PyObject *resultobj = 0;
7057 wxPoint result;
7058
7059 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7060 {
7061 if (!wxPyCheckForApp()) SWIG_fail;
7062 PyThreadState* __tstate = wxPyBeginAllowThreads();
7063 result = wxGetMousePosition();
7064 wxPyEndAllowThreads(__tstate);
7065 if (PyErr_Occurred()) SWIG_fail;
7066 }
7067 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7068 return resultobj;
7069 fail:
7070 return NULL;
7071 }
7072
7073
7074 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7075 PyObject *resultobj = 0;
7076 wxWindow *result = 0 ;
7077
7078 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7079 {
7080 if (!wxPyCheckForApp()) SWIG_fail;
7081 PyThreadState* __tstate = wxPyBeginAllowThreads();
7082 result = (wxWindow *)FindWindowAtPointer();
7083 wxPyEndAllowThreads(__tstate);
7084 if (PyErr_Occurred()) SWIG_fail;
7085 }
7086 {
7087 resultobj = wxPyMake_wxObject(result, 0);
7088 }
7089 return resultobj;
7090 fail:
7091 return NULL;
7092 }
7093
7094
7095 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7096 PyObject *resultobj = 0;
7097 wxWindow *result = 0 ;
7098
7099 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7100 {
7101 if (!wxPyCheckForApp()) SWIG_fail;
7102 PyThreadState* __tstate = wxPyBeginAllowThreads();
7103 result = (wxWindow *)wxGetActiveWindow();
7104 wxPyEndAllowThreads(__tstate);
7105 if (PyErr_Occurred()) SWIG_fail;
7106 }
7107 {
7108 resultobj = wxPyMake_wxObject(result, 0);
7109 }
7110 return resultobj;
7111 fail:
7112 return NULL;
7113 }
7114
7115
7116 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7117 PyObject *resultobj = 0;
7118 wxPoint *arg1 = 0 ;
7119 wxWindow *result = 0 ;
7120 wxPoint temp1 ;
7121 PyObject * obj0 = 0 ;
7122 char * kwnames[] = {
7123 (char *) "pt", NULL
7124 };
7125
7126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7127 {
7128 arg1 = &temp1;
7129 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7130 }
7131 {
7132 if (!wxPyCheckForApp()) SWIG_fail;
7133 PyThreadState* __tstate = wxPyBeginAllowThreads();
7134 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7135 wxPyEndAllowThreads(__tstate);
7136 if (PyErr_Occurred()) SWIG_fail;
7137 }
7138 {
7139 resultobj = wxPyMake_wxObject(result, 0);
7140 }
7141 return resultobj;
7142 fail:
7143 return NULL;
7144 }
7145
7146
7147 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7148 PyObject *resultobj = 0;
7149 wxPoint *arg1 = 0 ;
7150 wxWindow *result = 0 ;
7151 wxPoint temp1 ;
7152 PyObject * obj0 = 0 ;
7153 char * kwnames[] = {
7154 (char *) "pt", NULL
7155 };
7156
7157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7158 {
7159 arg1 = &temp1;
7160 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7161 }
7162 {
7163 if (!wxPyCheckForApp()) SWIG_fail;
7164 PyThreadState* __tstate = wxPyBeginAllowThreads();
7165 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7166 wxPyEndAllowThreads(__tstate);
7167 if (PyErr_Occurred()) SWIG_fail;
7168 }
7169 {
7170 resultobj = wxPyMake_wxObject(result, 0);
7171 }
7172 return resultobj;
7173 fail:
7174 return NULL;
7175 }
7176
7177
7178 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7179 PyObject *resultobj = 0;
7180 wxWindow *arg1 = (wxWindow *) 0 ;
7181 wxWindow *result = 0 ;
7182 void *argp1 = 0 ;
7183 int res1 = 0 ;
7184 PyObject * obj0 = 0 ;
7185 char * kwnames[] = {
7186 (char *) "win", NULL
7187 };
7188
7189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7191 if (!SWIG_IsOK(res1)) {
7192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7193 }
7194 arg1 = reinterpret_cast< wxWindow * >(argp1);
7195 {
7196 if (!wxPyCheckForApp()) SWIG_fail;
7197 PyThreadState* __tstate = wxPyBeginAllowThreads();
7198 result = (wxWindow *)wxGetTopLevelParent(arg1);
7199 wxPyEndAllowThreads(__tstate);
7200 if (PyErr_Occurred()) SWIG_fail;
7201 }
7202 {
7203 resultobj = wxPyMake_wxObject(result, 0);
7204 }
7205 return resultobj;
7206 fail:
7207 return NULL;
7208 }
7209
7210
7211 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7212 PyObject *resultobj = 0;
7213 wxString *arg1 = 0 ;
7214 bool result;
7215 bool temp1 = false ;
7216 PyObject * obj0 = 0 ;
7217 char * kwnames[] = {
7218 (char *) "url", NULL
7219 };
7220
7221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7222 {
7223 arg1 = wxString_in_helper(obj0);
7224 if (arg1 == NULL) SWIG_fail;
7225 temp1 = true;
7226 }
7227 {
7228 PyThreadState* __tstate = wxPyBeginAllowThreads();
7229 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7230 wxPyEndAllowThreads(__tstate);
7231 if (PyErr_Occurred()) SWIG_fail;
7232 }
7233 {
7234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7235 }
7236 {
7237 if (temp1)
7238 delete arg1;
7239 }
7240 return resultobj;
7241 fail:
7242 {
7243 if (temp1)
7244 delete arg1;
7245 }
7246 return NULL;
7247 }
7248
7249
7250 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7251 PyObject *resultobj = 0;
7252 wxKeyCode arg1 ;
7253 bool result;
7254 int val1 ;
7255 int ecode1 = 0 ;
7256 PyObject * obj0 = 0 ;
7257 char * kwnames[] = {
7258 (char *) "key", NULL
7259 };
7260
7261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7262 ecode1 = SWIG_AsVal_int(obj0, &val1);
7263 if (!SWIG_IsOK(ecode1)) {
7264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7265 }
7266 arg1 = static_cast< wxKeyCode >(val1);
7267 {
7268 if (!wxPyCheckForApp()) SWIG_fail;
7269 PyThreadState* __tstate = wxPyBeginAllowThreads();
7270 result = (bool)wxGetKeyState(arg1);
7271 wxPyEndAllowThreads(__tstate);
7272 if (PyErr_Occurred()) SWIG_fail;
7273 }
7274 {
7275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7276 }
7277 return resultobj;
7278 fail:
7279 return NULL;
7280 }
7281
7282
7283 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7284 PyObject *resultobj = 0;
7285 wxMouseState *result = 0 ;
7286
7287 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7288 {
7289 PyThreadState* __tstate = wxPyBeginAllowThreads();
7290 result = (wxMouseState *)new wxMouseState();
7291 wxPyEndAllowThreads(__tstate);
7292 if (PyErr_Occurred()) SWIG_fail;
7293 }
7294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7295 return resultobj;
7296 fail:
7297 return NULL;
7298 }
7299
7300
7301 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7302 PyObject *resultobj = 0;
7303 wxMouseState *arg1 = (wxMouseState *) 0 ;
7304 void *argp1 = 0 ;
7305 int res1 = 0 ;
7306 PyObject *swig_obj[1] ;
7307
7308 if (!args) SWIG_fail;
7309 swig_obj[0] = args;
7310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7311 if (!SWIG_IsOK(res1)) {
7312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7313 }
7314 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7315 {
7316 PyThreadState* __tstate = wxPyBeginAllowThreads();
7317 delete arg1;
7318
7319 wxPyEndAllowThreads(__tstate);
7320 if (PyErr_Occurred()) SWIG_fail;
7321 }
7322 resultobj = SWIG_Py_Void();
7323 return resultobj;
7324 fail:
7325 return NULL;
7326 }
7327
7328
7329 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7330 PyObject *resultobj = 0;
7331 wxMouseState *arg1 = (wxMouseState *) 0 ;
7332 int result;
7333 void *argp1 = 0 ;
7334 int res1 = 0 ;
7335 PyObject *swig_obj[1] ;
7336
7337 if (!args) SWIG_fail;
7338 swig_obj[0] = args;
7339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7340 if (!SWIG_IsOK(res1)) {
7341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7342 }
7343 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7344 {
7345 PyThreadState* __tstate = wxPyBeginAllowThreads();
7346 result = (int)(arg1)->GetX();
7347 wxPyEndAllowThreads(__tstate);
7348 if (PyErr_Occurred()) SWIG_fail;
7349 }
7350 resultobj = SWIG_From_int(static_cast< int >(result));
7351 return resultobj;
7352 fail:
7353 return NULL;
7354 }
7355
7356
7357 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7358 PyObject *resultobj = 0;
7359 wxMouseState *arg1 = (wxMouseState *) 0 ;
7360 int result;
7361 void *argp1 = 0 ;
7362 int res1 = 0 ;
7363 PyObject *swig_obj[1] ;
7364
7365 if (!args) SWIG_fail;
7366 swig_obj[0] = args;
7367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7368 if (!SWIG_IsOK(res1)) {
7369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7370 }
7371 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7372 {
7373 PyThreadState* __tstate = wxPyBeginAllowThreads();
7374 result = (int)(arg1)->GetY();
7375 wxPyEndAllowThreads(__tstate);
7376 if (PyErr_Occurred()) SWIG_fail;
7377 }
7378 resultobj = SWIG_From_int(static_cast< int >(result));
7379 return resultobj;
7380 fail:
7381 return NULL;
7382 }
7383
7384
7385 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7386 PyObject *resultobj = 0;
7387 wxMouseState *arg1 = (wxMouseState *) 0 ;
7388 bool result;
7389 void *argp1 = 0 ;
7390 int res1 = 0 ;
7391 PyObject *swig_obj[1] ;
7392
7393 if (!args) SWIG_fail;
7394 swig_obj[0] = args;
7395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7396 if (!SWIG_IsOK(res1)) {
7397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7398 }
7399 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7400 {
7401 PyThreadState* __tstate = wxPyBeginAllowThreads();
7402 result = (bool)(arg1)->LeftDown();
7403 wxPyEndAllowThreads(__tstate);
7404 if (PyErr_Occurred()) SWIG_fail;
7405 }
7406 {
7407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7408 }
7409 return resultobj;
7410 fail:
7411 return NULL;
7412 }
7413
7414
7415 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7416 PyObject *resultobj = 0;
7417 wxMouseState *arg1 = (wxMouseState *) 0 ;
7418 bool result;
7419 void *argp1 = 0 ;
7420 int res1 = 0 ;
7421 PyObject *swig_obj[1] ;
7422
7423 if (!args) SWIG_fail;
7424 swig_obj[0] = args;
7425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7426 if (!SWIG_IsOK(res1)) {
7427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7428 }
7429 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7430 {
7431 PyThreadState* __tstate = wxPyBeginAllowThreads();
7432 result = (bool)(arg1)->MiddleDown();
7433 wxPyEndAllowThreads(__tstate);
7434 if (PyErr_Occurred()) SWIG_fail;
7435 }
7436 {
7437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7438 }
7439 return resultobj;
7440 fail:
7441 return NULL;
7442 }
7443
7444
7445 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7446 PyObject *resultobj = 0;
7447 wxMouseState *arg1 = (wxMouseState *) 0 ;
7448 bool result;
7449 void *argp1 = 0 ;
7450 int res1 = 0 ;
7451 PyObject *swig_obj[1] ;
7452
7453 if (!args) SWIG_fail;
7454 swig_obj[0] = args;
7455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7456 if (!SWIG_IsOK(res1)) {
7457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7458 }
7459 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7460 {
7461 PyThreadState* __tstate = wxPyBeginAllowThreads();
7462 result = (bool)(arg1)->RightDown();
7463 wxPyEndAllowThreads(__tstate);
7464 if (PyErr_Occurred()) SWIG_fail;
7465 }
7466 {
7467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7468 }
7469 return resultobj;
7470 fail:
7471 return NULL;
7472 }
7473
7474
7475 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7476 PyObject *resultobj = 0;
7477 wxMouseState *arg1 = (wxMouseState *) 0 ;
7478 bool result;
7479 void *argp1 = 0 ;
7480 int res1 = 0 ;
7481 PyObject *swig_obj[1] ;
7482
7483 if (!args) SWIG_fail;
7484 swig_obj[0] = args;
7485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7486 if (!SWIG_IsOK(res1)) {
7487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7488 }
7489 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7490 {
7491 PyThreadState* __tstate = wxPyBeginAllowThreads();
7492 result = (bool)(arg1)->ControlDown();
7493 wxPyEndAllowThreads(__tstate);
7494 if (PyErr_Occurred()) SWIG_fail;
7495 }
7496 {
7497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7498 }
7499 return resultobj;
7500 fail:
7501 return NULL;
7502 }
7503
7504
7505 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7506 PyObject *resultobj = 0;
7507 wxMouseState *arg1 = (wxMouseState *) 0 ;
7508 bool result;
7509 void *argp1 = 0 ;
7510 int res1 = 0 ;
7511 PyObject *swig_obj[1] ;
7512
7513 if (!args) SWIG_fail;
7514 swig_obj[0] = args;
7515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7516 if (!SWIG_IsOK(res1)) {
7517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7518 }
7519 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7520 {
7521 PyThreadState* __tstate = wxPyBeginAllowThreads();
7522 result = (bool)(arg1)->ShiftDown();
7523 wxPyEndAllowThreads(__tstate);
7524 if (PyErr_Occurred()) SWIG_fail;
7525 }
7526 {
7527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7528 }
7529 return resultobj;
7530 fail:
7531 return NULL;
7532 }
7533
7534
7535 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7536 PyObject *resultobj = 0;
7537 wxMouseState *arg1 = (wxMouseState *) 0 ;
7538 bool result;
7539 void *argp1 = 0 ;
7540 int res1 = 0 ;
7541 PyObject *swig_obj[1] ;
7542
7543 if (!args) SWIG_fail;
7544 swig_obj[0] = args;
7545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7546 if (!SWIG_IsOK(res1)) {
7547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7548 }
7549 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7550 {
7551 PyThreadState* __tstate = wxPyBeginAllowThreads();
7552 result = (bool)(arg1)->AltDown();
7553 wxPyEndAllowThreads(__tstate);
7554 if (PyErr_Occurred()) SWIG_fail;
7555 }
7556 {
7557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7558 }
7559 return resultobj;
7560 fail:
7561 return NULL;
7562 }
7563
7564
7565 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7566 PyObject *resultobj = 0;
7567 wxMouseState *arg1 = (wxMouseState *) 0 ;
7568 bool result;
7569 void *argp1 = 0 ;
7570 int res1 = 0 ;
7571 PyObject *swig_obj[1] ;
7572
7573 if (!args) SWIG_fail;
7574 swig_obj[0] = args;
7575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7576 if (!SWIG_IsOK(res1)) {
7577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7578 }
7579 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7580 {
7581 PyThreadState* __tstate = wxPyBeginAllowThreads();
7582 result = (bool)(arg1)->MetaDown();
7583 wxPyEndAllowThreads(__tstate);
7584 if (PyErr_Occurred()) SWIG_fail;
7585 }
7586 {
7587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7588 }
7589 return resultobj;
7590 fail:
7591 return NULL;
7592 }
7593
7594
7595 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7596 PyObject *resultobj = 0;
7597 wxMouseState *arg1 = (wxMouseState *) 0 ;
7598 bool result;
7599 void *argp1 = 0 ;
7600 int res1 = 0 ;
7601 PyObject *swig_obj[1] ;
7602
7603 if (!args) SWIG_fail;
7604 swig_obj[0] = args;
7605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7606 if (!SWIG_IsOK(res1)) {
7607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7608 }
7609 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7610 {
7611 PyThreadState* __tstate = wxPyBeginAllowThreads();
7612 result = (bool)(arg1)->CmdDown();
7613 wxPyEndAllowThreads(__tstate);
7614 if (PyErr_Occurred()) SWIG_fail;
7615 }
7616 {
7617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7618 }
7619 return resultobj;
7620 fail:
7621 return NULL;
7622 }
7623
7624
7625 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7626 PyObject *resultobj = 0;
7627 wxMouseState *arg1 = (wxMouseState *) 0 ;
7628 int arg2 ;
7629 void *argp1 = 0 ;
7630 int res1 = 0 ;
7631 int val2 ;
7632 int ecode2 = 0 ;
7633 PyObject * obj0 = 0 ;
7634 PyObject * obj1 = 0 ;
7635 char * kwnames[] = {
7636 (char *) "self",(char *) "x", NULL
7637 };
7638
7639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7641 if (!SWIG_IsOK(res1)) {
7642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7643 }
7644 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7645 ecode2 = SWIG_AsVal_int(obj1, &val2);
7646 if (!SWIG_IsOK(ecode2)) {
7647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7648 }
7649 arg2 = static_cast< int >(val2);
7650 {
7651 PyThreadState* __tstate = wxPyBeginAllowThreads();
7652 (arg1)->SetX(arg2);
7653 wxPyEndAllowThreads(__tstate);
7654 if (PyErr_Occurred()) SWIG_fail;
7655 }
7656 resultobj = SWIG_Py_Void();
7657 return resultobj;
7658 fail:
7659 return NULL;
7660 }
7661
7662
7663 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7664 PyObject *resultobj = 0;
7665 wxMouseState *arg1 = (wxMouseState *) 0 ;
7666 int arg2 ;
7667 void *argp1 = 0 ;
7668 int res1 = 0 ;
7669 int val2 ;
7670 int ecode2 = 0 ;
7671 PyObject * obj0 = 0 ;
7672 PyObject * obj1 = 0 ;
7673 char * kwnames[] = {
7674 (char *) "self",(char *) "y", NULL
7675 };
7676
7677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7679 if (!SWIG_IsOK(res1)) {
7680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7681 }
7682 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7683 ecode2 = SWIG_AsVal_int(obj1, &val2);
7684 if (!SWIG_IsOK(ecode2)) {
7685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7686 }
7687 arg2 = static_cast< int >(val2);
7688 {
7689 PyThreadState* __tstate = wxPyBeginAllowThreads();
7690 (arg1)->SetY(arg2);
7691 wxPyEndAllowThreads(__tstate);
7692 if (PyErr_Occurred()) SWIG_fail;
7693 }
7694 resultobj = SWIG_Py_Void();
7695 return resultobj;
7696 fail:
7697 return NULL;
7698 }
7699
7700
7701 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7702 PyObject *resultobj = 0;
7703 wxMouseState *arg1 = (wxMouseState *) 0 ;
7704 bool arg2 ;
7705 void *argp1 = 0 ;
7706 int res1 = 0 ;
7707 bool val2 ;
7708 int ecode2 = 0 ;
7709 PyObject * obj0 = 0 ;
7710 PyObject * obj1 = 0 ;
7711 char * kwnames[] = {
7712 (char *) "self",(char *) "down", NULL
7713 };
7714
7715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7717 if (!SWIG_IsOK(res1)) {
7718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7719 }
7720 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7721 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7722 if (!SWIG_IsOK(ecode2)) {
7723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7724 }
7725 arg2 = static_cast< bool >(val2);
7726 {
7727 PyThreadState* __tstate = wxPyBeginAllowThreads();
7728 (arg1)->SetLeftDown(arg2);
7729 wxPyEndAllowThreads(__tstate);
7730 if (PyErr_Occurred()) SWIG_fail;
7731 }
7732 resultobj = SWIG_Py_Void();
7733 return resultobj;
7734 fail:
7735 return NULL;
7736 }
7737
7738
7739 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7740 PyObject *resultobj = 0;
7741 wxMouseState *arg1 = (wxMouseState *) 0 ;
7742 bool arg2 ;
7743 void *argp1 = 0 ;
7744 int res1 = 0 ;
7745 bool val2 ;
7746 int ecode2 = 0 ;
7747 PyObject * obj0 = 0 ;
7748 PyObject * obj1 = 0 ;
7749 char * kwnames[] = {
7750 (char *) "self",(char *) "down", NULL
7751 };
7752
7753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7755 if (!SWIG_IsOK(res1)) {
7756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7757 }
7758 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7759 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7760 if (!SWIG_IsOK(ecode2)) {
7761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7762 }
7763 arg2 = static_cast< bool >(val2);
7764 {
7765 PyThreadState* __tstate = wxPyBeginAllowThreads();
7766 (arg1)->SetMiddleDown(arg2);
7767 wxPyEndAllowThreads(__tstate);
7768 if (PyErr_Occurred()) SWIG_fail;
7769 }
7770 resultobj = SWIG_Py_Void();
7771 return resultobj;
7772 fail:
7773 return NULL;
7774 }
7775
7776
7777 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7778 PyObject *resultobj = 0;
7779 wxMouseState *arg1 = (wxMouseState *) 0 ;
7780 bool arg2 ;
7781 void *argp1 = 0 ;
7782 int res1 = 0 ;
7783 bool val2 ;
7784 int ecode2 = 0 ;
7785 PyObject * obj0 = 0 ;
7786 PyObject * obj1 = 0 ;
7787 char * kwnames[] = {
7788 (char *) "self",(char *) "down", NULL
7789 };
7790
7791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7793 if (!SWIG_IsOK(res1)) {
7794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7795 }
7796 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7797 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7798 if (!SWIG_IsOK(ecode2)) {
7799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7800 }
7801 arg2 = static_cast< bool >(val2);
7802 {
7803 PyThreadState* __tstate = wxPyBeginAllowThreads();
7804 (arg1)->SetRightDown(arg2);
7805 wxPyEndAllowThreads(__tstate);
7806 if (PyErr_Occurred()) SWIG_fail;
7807 }
7808 resultobj = SWIG_Py_Void();
7809 return resultobj;
7810 fail:
7811 return NULL;
7812 }
7813
7814
7815 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7816 PyObject *resultobj = 0;
7817 wxMouseState *arg1 = (wxMouseState *) 0 ;
7818 bool arg2 ;
7819 void *argp1 = 0 ;
7820 int res1 = 0 ;
7821 bool val2 ;
7822 int ecode2 = 0 ;
7823 PyObject * obj0 = 0 ;
7824 PyObject * obj1 = 0 ;
7825 char * kwnames[] = {
7826 (char *) "self",(char *) "down", NULL
7827 };
7828
7829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7831 if (!SWIG_IsOK(res1)) {
7832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7833 }
7834 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7835 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7836 if (!SWIG_IsOK(ecode2)) {
7837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7838 }
7839 arg2 = static_cast< bool >(val2);
7840 {
7841 PyThreadState* __tstate = wxPyBeginAllowThreads();
7842 (arg1)->SetControlDown(arg2);
7843 wxPyEndAllowThreads(__tstate);
7844 if (PyErr_Occurred()) SWIG_fail;
7845 }
7846 resultobj = SWIG_Py_Void();
7847 return resultobj;
7848 fail:
7849 return NULL;
7850 }
7851
7852
7853 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7854 PyObject *resultobj = 0;
7855 wxMouseState *arg1 = (wxMouseState *) 0 ;
7856 bool arg2 ;
7857 void *argp1 = 0 ;
7858 int res1 = 0 ;
7859 bool val2 ;
7860 int ecode2 = 0 ;
7861 PyObject * obj0 = 0 ;
7862 PyObject * obj1 = 0 ;
7863 char * kwnames[] = {
7864 (char *) "self",(char *) "down", NULL
7865 };
7866
7867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7869 if (!SWIG_IsOK(res1)) {
7870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7871 }
7872 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7873 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7874 if (!SWIG_IsOK(ecode2)) {
7875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7876 }
7877 arg2 = static_cast< bool >(val2);
7878 {
7879 PyThreadState* __tstate = wxPyBeginAllowThreads();
7880 (arg1)->SetShiftDown(arg2);
7881 wxPyEndAllowThreads(__tstate);
7882 if (PyErr_Occurred()) SWIG_fail;
7883 }
7884 resultobj = SWIG_Py_Void();
7885 return resultobj;
7886 fail:
7887 return NULL;
7888 }
7889
7890
7891 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7892 PyObject *resultobj = 0;
7893 wxMouseState *arg1 = (wxMouseState *) 0 ;
7894 bool arg2 ;
7895 void *argp1 = 0 ;
7896 int res1 = 0 ;
7897 bool val2 ;
7898 int ecode2 = 0 ;
7899 PyObject * obj0 = 0 ;
7900 PyObject * obj1 = 0 ;
7901 char * kwnames[] = {
7902 (char *) "self",(char *) "down", NULL
7903 };
7904
7905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7907 if (!SWIG_IsOK(res1)) {
7908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7909 }
7910 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7911 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7912 if (!SWIG_IsOK(ecode2)) {
7913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7914 }
7915 arg2 = static_cast< bool >(val2);
7916 {
7917 PyThreadState* __tstate = wxPyBeginAllowThreads();
7918 (arg1)->SetAltDown(arg2);
7919 wxPyEndAllowThreads(__tstate);
7920 if (PyErr_Occurred()) SWIG_fail;
7921 }
7922 resultobj = SWIG_Py_Void();
7923 return resultobj;
7924 fail:
7925 return NULL;
7926 }
7927
7928
7929 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7930 PyObject *resultobj = 0;
7931 wxMouseState *arg1 = (wxMouseState *) 0 ;
7932 bool arg2 ;
7933 void *argp1 = 0 ;
7934 int res1 = 0 ;
7935 bool val2 ;
7936 int ecode2 = 0 ;
7937 PyObject * obj0 = 0 ;
7938 PyObject * obj1 = 0 ;
7939 char * kwnames[] = {
7940 (char *) "self",(char *) "down", NULL
7941 };
7942
7943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7945 if (!SWIG_IsOK(res1)) {
7946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7947 }
7948 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7949 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7950 if (!SWIG_IsOK(ecode2)) {
7951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7952 }
7953 arg2 = static_cast< bool >(val2);
7954 {
7955 PyThreadState* __tstate = wxPyBeginAllowThreads();
7956 (arg1)->SetMetaDown(arg2);
7957 wxPyEndAllowThreads(__tstate);
7958 if (PyErr_Occurred()) SWIG_fail;
7959 }
7960 resultobj = SWIG_Py_Void();
7961 return resultobj;
7962 fail:
7963 return NULL;
7964 }
7965
7966
7967 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7968 PyObject *obj;
7969 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7970 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7971 return SWIG_Py_Void();
7972 }
7973
7974 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7975 return SWIG_Python_InitShadowInstance(args);
7976 }
7977
7978 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7979 PyObject *resultobj = 0;
7980 wxMouseState result;
7981
7982 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7983 {
7984 PyThreadState* __tstate = wxPyBeginAllowThreads();
7985 result = wxGetMouseState();
7986 wxPyEndAllowThreads(__tstate);
7987 if (PyErr_Occurred()) SWIG_fail;
7988 }
7989 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7990 return resultobj;
7991 fail:
7992 return NULL;
7993 }
7994
7995
7996 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7997 PyObject *resultobj = 0;
7998
7999 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8000 {
8001 if (!wxPyCheckForApp()) SWIG_fail;
8002 PyThreadState* __tstate = wxPyBeginAllowThreads();
8003 wxWakeUpMainThread();
8004 wxPyEndAllowThreads(__tstate);
8005 if (PyErr_Occurred()) SWIG_fail;
8006 }
8007 resultobj = SWIG_Py_Void();
8008 return resultobj;
8009 fail:
8010 return NULL;
8011 }
8012
8013
8014 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8015 PyObject *resultobj = 0;
8016
8017 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8018 {
8019 if (!wxPyCheckForApp()) SWIG_fail;
8020 PyThreadState* __tstate = wxPyBeginAllowThreads();
8021 wxMutexGuiEnter();
8022 wxPyEndAllowThreads(__tstate);
8023 if (PyErr_Occurred()) SWIG_fail;
8024 }
8025 resultobj = SWIG_Py_Void();
8026 return resultobj;
8027 fail:
8028 return NULL;
8029 }
8030
8031
8032 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8033 PyObject *resultobj = 0;
8034
8035 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8036 {
8037 if (!wxPyCheckForApp()) SWIG_fail;
8038 PyThreadState* __tstate = wxPyBeginAllowThreads();
8039 wxMutexGuiLeave();
8040 wxPyEndAllowThreads(__tstate);
8041 if (PyErr_Occurred()) SWIG_fail;
8042 }
8043 resultobj = SWIG_Py_Void();
8044 return resultobj;
8045 fail:
8046 return NULL;
8047 }
8048
8049
8050 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8051 PyObject *resultobj = 0;
8052 wxMutexGuiLocker *result = 0 ;
8053
8054 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8055 {
8056 if (!wxPyCheckForApp()) SWIG_fail;
8057 PyThreadState* __tstate = wxPyBeginAllowThreads();
8058 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8059 wxPyEndAllowThreads(__tstate);
8060 if (PyErr_Occurred()) SWIG_fail;
8061 }
8062 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8063 return resultobj;
8064 fail:
8065 return NULL;
8066 }
8067
8068
8069 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8070 PyObject *resultobj = 0;
8071 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8072 void *argp1 = 0 ;
8073 int res1 = 0 ;
8074 PyObject *swig_obj[1] ;
8075
8076 if (!args) SWIG_fail;
8077 swig_obj[0] = args;
8078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8079 if (!SWIG_IsOK(res1)) {
8080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8081 }
8082 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8083 {
8084 PyThreadState* __tstate = wxPyBeginAllowThreads();
8085 delete arg1;
8086
8087 wxPyEndAllowThreads(__tstate);
8088 if (PyErr_Occurred()) SWIG_fail;
8089 }
8090 resultobj = SWIG_Py_Void();
8091 return resultobj;
8092 fail:
8093 return NULL;
8094 }
8095
8096
8097 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8098 PyObject *obj;
8099 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8100 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8101 return SWIG_Py_Void();
8102 }
8103
8104 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8105 return SWIG_Python_InitShadowInstance(args);
8106 }
8107
8108 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8109 PyObject *resultobj = 0;
8110 bool result;
8111
8112 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8113 {
8114 PyThreadState* __tstate = wxPyBeginAllowThreads();
8115 result = (bool)wxThread_IsMain();
8116 wxPyEndAllowThreads(__tstate);
8117 if (PyErr_Occurred()) SWIG_fail;
8118 }
8119 {
8120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8121 }
8122 return resultobj;
8123 fail:
8124 return NULL;
8125 }
8126
8127
8128 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8129 PyObject *resultobj = 0;
8130 wxString *arg1 = 0 ;
8131 wxToolTip *result = 0 ;
8132 bool temp1 = false ;
8133 PyObject * obj0 = 0 ;
8134 char * kwnames[] = {
8135 (char *) "tip", NULL
8136 };
8137
8138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8139 {
8140 arg1 = wxString_in_helper(obj0);
8141 if (arg1 == NULL) SWIG_fail;
8142 temp1 = true;
8143 }
8144 {
8145 if (!wxPyCheckForApp()) SWIG_fail;
8146 PyThreadState* __tstate = wxPyBeginAllowThreads();
8147 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8148 wxPyEndAllowThreads(__tstate);
8149 if (PyErr_Occurred()) SWIG_fail;
8150 }
8151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8152 {
8153 if (temp1)
8154 delete arg1;
8155 }
8156 return resultobj;
8157 fail:
8158 {
8159 if (temp1)
8160 delete arg1;
8161 }
8162 return NULL;
8163 }
8164
8165
8166 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8167 PyObject *resultobj = 0;
8168 wxToolTip *arg1 = (wxToolTip *) 0 ;
8169 void *argp1 = 0 ;
8170 int res1 = 0 ;
8171 PyObject *swig_obj[1] ;
8172
8173 if (!args) SWIG_fail;
8174 swig_obj[0] = args;
8175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8176 if (!SWIG_IsOK(res1)) {
8177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8178 }
8179 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8180 {
8181 PyThreadState* __tstate = wxPyBeginAllowThreads();
8182 delete arg1;
8183
8184 wxPyEndAllowThreads(__tstate);
8185 if (PyErr_Occurred()) SWIG_fail;
8186 }
8187 resultobj = SWIG_Py_Void();
8188 return resultobj;
8189 fail:
8190 return NULL;
8191 }
8192
8193
8194 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8195 PyObject *resultobj = 0;
8196 wxToolTip *arg1 = (wxToolTip *) 0 ;
8197 wxString *arg2 = 0 ;
8198 void *argp1 = 0 ;
8199 int res1 = 0 ;
8200 bool temp2 = false ;
8201 PyObject * obj0 = 0 ;
8202 PyObject * obj1 = 0 ;
8203 char * kwnames[] = {
8204 (char *) "self",(char *) "tip", NULL
8205 };
8206
8207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8209 if (!SWIG_IsOK(res1)) {
8210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8211 }
8212 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8213 {
8214 arg2 = wxString_in_helper(obj1);
8215 if (arg2 == NULL) SWIG_fail;
8216 temp2 = true;
8217 }
8218 {
8219 PyThreadState* __tstate = wxPyBeginAllowThreads();
8220 (arg1)->SetTip((wxString const &)*arg2);
8221 wxPyEndAllowThreads(__tstate);
8222 if (PyErr_Occurred()) SWIG_fail;
8223 }
8224 resultobj = SWIG_Py_Void();
8225 {
8226 if (temp2)
8227 delete arg2;
8228 }
8229 return resultobj;
8230 fail:
8231 {
8232 if (temp2)
8233 delete arg2;
8234 }
8235 return NULL;
8236 }
8237
8238
8239 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8240 PyObject *resultobj = 0;
8241 wxToolTip *arg1 = (wxToolTip *) 0 ;
8242 wxString result;
8243 void *argp1 = 0 ;
8244 int res1 = 0 ;
8245 PyObject *swig_obj[1] ;
8246
8247 if (!args) SWIG_fail;
8248 swig_obj[0] = args;
8249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8250 if (!SWIG_IsOK(res1)) {
8251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8252 }
8253 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8254 {
8255 PyThreadState* __tstate = wxPyBeginAllowThreads();
8256 result = (arg1)->GetTip();
8257 wxPyEndAllowThreads(__tstate);
8258 if (PyErr_Occurred()) SWIG_fail;
8259 }
8260 {
8261 #if wxUSE_UNICODE
8262 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8263 #else
8264 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8265 #endif
8266 }
8267 return resultobj;
8268 fail:
8269 return NULL;
8270 }
8271
8272
8273 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8274 PyObject *resultobj = 0;
8275 wxToolTip *arg1 = (wxToolTip *) 0 ;
8276 wxWindow *result = 0 ;
8277 void *argp1 = 0 ;
8278 int res1 = 0 ;
8279 PyObject *swig_obj[1] ;
8280
8281 if (!args) SWIG_fail;
8282 swig_obj[0] = args;
8283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8284 if (!SWIG_IsOK(res1)) {
8285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8286 }
8287 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8288 {
8289 PyThreadState* __tstate = wxPyBeginAllowThreads();
8290 result = (wxWindow *)(arg1)->GetWindow();
8291 wxPyEndAllowThreads(__tstate);
8292 if (PyErr_Occurred()) SWIG_fail;
8293 }
8294 {
8295 resultobj = wxPyMake_wxObject(result, 0);
8296 }
8297 return resultobj;
8298 fail:
8299 return NULL;
8300 }
8301
8302
8303 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8304 PyObject *resultobj = 0;
8305 bool arg1 ;
8306 bool val1 ;
8307 int ecode1 = 0 ;
8308 PyObject * obj0 = 0 ;
8309 char * kwnames[] = {
8310 (char *) "flag", NULL
8311 };
8312
8313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8314 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8315 if (!SWIG_IsOK(ecode1)) {
8316 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8317 }
8318 arg1 = static_cast< bool >(val1);
8319 {
8320 PyThreadState* __tstate = wxPyBeginAllowThreads();
8321 wxToolTip::Enable(arg1);
8322 wxPyEndAllowThreads(__tstate);
8323 if (PyErr_Occurred()) SWIG_fail;
8324 }
8325 resultobj = SWIG_Py_Void();
8326 return resultobj;
8327 fail:
8328 return NULL;
8329 }
8330
8331
8332 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8333 PyObject *resultobj = 0;
8334 long arg1 ;
8335 long val1 ;
8336 int ecode1 = 0 ;
8337 PyObject * obj0 = 0 ;
8338 char * kwnames[] = {
8339 (char *) "milliseconds", NULL
8340 };
8341
8342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8343 ecode1 = SWIG_AsVal_long(obj0, &val1);
8344 if (!SWIG_IsOK(ecode1)) {
8345 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8346 }
8347 arg1 = static_cast< long >(val1);
8348 {
8349 PyThreadState* __tstate = wxPyBeginAllowThreads();
8350 wxToolTip::SetDelay(arg1);
8351 wxPyEndAllowThreads(__tstate);
8352 if (PyErr_Occurred()) SWIG_fail;
8353 }
8354 resultobj = SWIG_Py_Void();
8355 return resultobj;
8356 fail:
8357 return NULL;
8358 }
8359
8360
8361 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8362 PyObject *obj;
8363 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8364 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8365 return SWIG_Py_Void();
8366 }
8367
8368 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8369 return SWIG_Python_InitShadowInstance(args);
8370 }
8371
8372 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8373 PyObject *resultobj = 0;
8374 wxWindow *arg1 = (wxWindow *) 0 ;
8375 wxSize *arg2 = 0 ;
8376 wxCaret *result = 0 ;
8377 void *argp1 = 0 ;
8378 int res1 = 0 ;
8379 wxSize temp2 ;
8380 PyObject * obj0 = 0 ;
8381 PyObject * obj1 = 0 ;
8382 char * kwnames[] = {
8383 (char *) "window",(char *) "size", NULL
8384 };
8385
8386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8388 if (!SWIG_IsOK(res1)) {
8389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8390 }
8391 arg1 = reinterpret_cast< wxWindow * >(argp1);
8392 {
8393 arg2 = &temp2;
8394 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8395 }
8396 {
8397 if (!wxPyCheckForApp()) SWIG_fail;
8398 PyThreadState* __tstate = wxPyBeginAllowThreads();
8399 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8400 wxPyEndAllowThreads(__tstate);
8401 if (PyErr_Occurred()) SWIG_fail;
8402 }
8403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8404 return resultobj;
8405 fail:
8406 return NULL;
8407 }
8408
8409
8410 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8411 PyObject *resultobj = 0;
8412 wxCaret *arg1 = (wxCaret *) 0 ;
8413 void *argp1 = 0 ;
8414 int res1 = 0 ;
8415 PyObject *swig_obj[1] ;
8416
8417 if (!args) SWIG_fail;
8418 swig_obj[0] = args;
8419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8420 if (!SWIG_IsOK(res1)) {
8421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8422 }
8423 arg1 = reinterpret_cast< wxCaret * >(argp1);
8424 {
8425 PyThreadState* __tstate = wxPyBeginAllowThreads();
8426 delete arg1;
8427
8428 wxPyEndAllowThreads(__tstate);
8429 if (PyErr_Occurred()) SWIG_fail;
8430 }
8431 resultobj = SWIG_Py_Void();
8432 return resultobj;
8433 fail:
8434 return NULL;
8435 }
8436
8437
8438 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8439 PyObject *resultobj = 0;
8440 wxCaret *arg1 = (wxCaret *) 0 ;
8441 void *argp1 = 0 ;
8442 int res1 = 0 ;
8443 PyObject *swig_obj[1] ;
8444
8445 if (!args) SWIG_fail;
8446 swig_obj[0] = args;
8447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8448 if (!SWIG_IsOK(res1)) {
8449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8450 }
8451 arg1 = reinterpret_cast< wxCaret * >(argp1);
8452 {
8453 PyThreadState* __tstate = wxPyBeginAllowThreads();
8454 wxCaret_Destroy(arg1);
8455 wxPyEndAllowThreads(__tstate);
8456 if (PyErr_Occurred()) SWIG_fail;
8457 }
8458 resultobj = SWIG_Py_Void();
8459 return resultobj;
8460 fail:
8461 return NULL;
8462 }
8463
8464
8465 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8466 PyObject *resultobj = 0;
8467 wxCaret *arg1 = (wxCaret *) 0 ;
8468 bool result;
8469 void *argp1 = 0 ;
8470 int res1 = 0 ;
8471 PyObject *swig_obj[1] ;
8472
8473 if (!args) SWIG_fail;
8474 swig_obj[0] = args;
8475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8476 if (!SWIG_IsOK(res1)) {
8477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8478 }
8479 arg1 = reinterpret_cast< wxCaret * >(argp1);
8480 {
8481 PyThreadState* __tstate = wxPyBeginAllowThreads();
8482 result = (bool)(arg1)->IsOk();
8483 wxPyEndAllowThreads(__tstate);
8484 if (PyErr_Occurred()) SWIG_fail;
8485 }
8486 {
8487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8488 }
8489 return resultobj;
8490 fail:
8491 return NULL;
8492 }
8493
8494
8495 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8496 PyObject *resultobj = 0;
8497 wxCaret *arg1 = (wxCaret *) 0 ;
8498 bool result;
8499 void *argp1 = 0 ;
8500 int res1 = 0 ;
8501 PyObject *swig_obj[1] ;
8502
8503 if (!args) SWIG_fail;
8504 swig_obj[0] = args;
8505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8506 if (!SWIG_IsOK(res1)) {
8507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8508 }
8509 arg1 = reinterpret_cast< wxCaret * >(argp1);
8510 {
8511 PyThreadState* __tstate = wxPyBeginAllowThreads();
8512 result = (bool)(arg1)->IsVisible();
8513 wxPyEndAllowThreads(__tstate);
8514 if (PyErr_Occurred()) SWIG_fail;
8515 }
8516 {
8517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8518 }
8519 return resultobj;
8520 fail:
8521 return NULL;
8522 }
8523
8524
8525 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8526 PyObject *resultobj = 0;
8527 wxCaret *arg1 = (wxCaret *) 0 ;
8528 wxPoint result;
8529 void *argp1 = 0 ;
8530 int res1 = 0 ;
8531 PyObject *swig_obj[1] ;
8532
8533 if (!args) SWIG_fail;
8534 swig_obj[0] = args;
8535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8536 if (!SWIG_IsOK(res1)) {
8537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8538 }
8539 arg1 = reinterpret_cast< wxCaret * >(argp1);
8540 {
8541 PyThreadState* __tstate = wxPyBeginAllowThreads();
8542 result = (arg1)->GetPosition();
8543 wxPyEndAllowThreads(__tstate);
8544 if (PyErr_Occurred()) SWIG_fail;
8545 }
8546 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8547 return resultobj;
8548 fail:
8549 return NULL;
8550 }
8551
8552
8553 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8554 PyObject *resultobj = 0;
8555 wxCaret *arg1 = (wxCaret *) 0 ;
8556 int *arg2 = (int *) 0 ;
8557 int *arg3 = (int *) 0 ;
8558 void *argp1 = 0 ;
8559 int res1 = 0 ;
8560 int temp2 ;
8561 int res2 = SWIG_TMPOBJ ;
8562 int temp3 ;
8563 int res3 = SWIG_TMPOBJ ;
8564 PyObject *swig_obj[1] ;
8565
8566 arg2 = &temp2;
8567 arg3 = &temp3;
8568 if (!args) SWIG_fail;
8569 swig_obj[0] = args;
8570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8571 if (!SWIG_IsOK(res1)) {
8572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8573 }
8574 arg1 = reinterpret_cast< wxCaret * >(argp1);
8575 {
8576 PyThreadState* __tstate = wxPyBeginAllowThreads();
8577 (arg1)->GetPosition(arg2,arg3);
8578 wxPyEndAllowThreads(__tstate);
8579 if (PyErr_Occurred()) SWIG_fail;
8580 }
8581 resultobj = SWIG_Py_Void();
8582 if (SWIG_IsTmpObj(res2)) {
8583 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8584 } else {
8585 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8586 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8587 }
8588 if (SWIG_IsTmpObj(res3)) {
8589 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8590 } else {
8591 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8592 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8593 }
8594 return resultobj;
8595 fail:
8596 return NULL;
8597 }
8598
8599
8600 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8601 PyObject *resultobj = 0;
8602 wxCaret *arg1 = (wxCaret *) 0 ;
8603 wxSize result;
8604 void *argp1 = 0 ;
8605 int res1 = 0 ;
8606 PyObject *swig_obj[1] ;
8607
8608 if (!args) SWIG_fail;
8609 swig_obj[0] = args;
8610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8611 if (!SWIG_IsOK(res1)) {
8612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8613 }
8614 arg1 = reinterpret_cast< wxCaret * >(argp1);
8615 {
8616 PyThreadState* __tstate = wxPyBeginAllowThreads();
8617 result = (arg1)->GetSize();
8618 wxPyEndAllowThreads(__tstate);
8619 if (PyErr_Occurred()) SWIG_fail;
8620 }
8621 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8622 return resultobj;
8623 fail:
8624 return NULL;
8625 }
8626
8627
8628 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8629 PyObject *resultobj = 0;
8630 wxCaret *arg1 = (wxCaret *) 0 ;
8631 int *arg2 = (int *) 0 ;
8632 int *arg3 = (int *) 0 ;
8633 void *argp1 = 0 ;
8634 int res1 = 0 ;
8635 int temp2 ;
8636 int res2 = SWIG_TMPOBJ ;
8637 int temp3 ;
8638 int res3 = SWIG_TMPOBJ ;
8639 PyObject *swig_obj[1] ;
8640
8641 arg2 = &temp2;
8642 arg3 = &temp3;
8643 if (!args) SWIG_fail;
8644 swig_obj[0] = args;
8645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8646 if (!SWIG_IsOK(res1)) {
8647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8648 }
8649 arg1 = reinterpret_cast< wxCaret * >(argp1);
8650 {
8651 PyThreadState* __tstate = wxPyBeginAllowThreads();
8652 (arg1)->GetSize(arg2,arg3);
8653 wxPyEndAllowThreads(__tstate);
8654 if (PyErr_Occurred()) SWIG_fail;
8655 }
8656 resultobj = SWIG_Py_Void();
8657 if (SWIG_IsTmpObj(res2)) {
8658 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8659 } else {
8660 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8661 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8662 }
8663 if (SWIG_IsTmpObj(res3)) {
8664 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8665 } else {
8666 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8667 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8668 }
8669 return resultobj;
8670 fail:
8671 return NULL;
8672 }
8673
8674
8675 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8676 PyObject *resultobj = 0;
8677 wxCaret *arg1 = (wxCaret *) 0 ;
8678 wxWindow *result = 0 ;
8679 void *argp1 = 0 ;
8680 int res1 = 0 ;
8681 PyObject *swig_obj[1] ;
8682
8683 if (!args) SWIG_fail;
8684 swig_obj[0] = args;
8685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8686 if (!SWIG_IsOK(res1)) {
8687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8688 }
8689 arg1 = reinterpret_cast< wxCaret * >(argp1);
8690 {
8691 PyThreadState* __tstate = wxPyBeginAllowThreads();
8692 result = (wxWindow *)(arg1)->GetWindow();
8693 wxPyEndAllowThreads(__tstate);
8694 if (PyErr_Occurred()) SWIG_fail;
8695 }
8696 {
8697 resultobj = wxPyMake_wxObject(result, 0);
8698 }
8699 return resultobj;
8700 fail:
8701 return NULL;
8702 }
8703
8704
8705 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8706 PyObject *resultobj = 0;
8707 wxCaret *arg1 = (wxCaret *) 0 ;
8708 int arg2 ;
8709 int arg3 ;
8710 void *argp1 = 0 ;
8711 int res1 = 0 ;
8712 int val2 ;
8713 int ecode2 = 0 ;
8714 int val3 ;
8715 int ecode3 = 0 ;
8716 PyObject * obj0 = 0 ;
8717 PyObject * obj1 = 0 ;
8718 PyObject * obj2 = 0 ;
8719 char * kwnames[] = {
8720 (char *) "self",(char *) "x",(char *) "y", NULL
8721 };
8722
8723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8725 if (!SWIG_IsOK(res1)) {
8726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8727 }
8728 arg1 = reinterpret_cast< wxCaret * >(argp1);
8729 ecode2 = SWIG_AsVal_int(obj1, &val2);
8730 if (!SWIG_IsOK(ecode2)) {
8731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8732 }
8733 arg2 = static_cast< int >(val2);
8734 ecode3 = SWIG_AsVal_int(obj2, &val3);
8735 if (!SWIG_IsOK(ecode3)) {
8736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8737 }
8738 arg3 = static_cast< int >(val3);
8739 {
8740 PyThreadState* __tstate = wxPyBeginAllowThreads();
8741 (arg1)->Move(arg2,arg3);
8742 wxPyEndAllowThreads(__tstate);
8743 if (PyErr_Occurred()) SWIG_fail;
8744 }
8745 resultobj = SWIG_Py_Void();
8746 return resultobj;
8747 fail:
8748 return NULL;
8749 }
8750
8751
8752 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8753 PyObject *resultobj = 0;
8754 wxCaret *arg1 = (wxCaret *) 0 ;
8755 wxPoint *arg2 = 0 ;
8756 void *argp1 = 0 ;
8757 int res1 = 0 ;
8758 wxPoint temp2 ;
8759 PyObject * obj0 = 0 ;
8760 PyObject * obj1 = 0 ;
8761 char * kwnames[] = {
8762 (char *) "self",(char *) "pt", NULL
8763 };
8764
8765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8767 if (!SWIG_IsOK(res1)) {
8768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8769 }
8770 arg1 = reinterpret_cast< wxCaret * >(argp1);
8771 {
8772 arg2 = &temp2;
8773 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8774 }
8775 {
8776 PyThreadState* __tstate = wxPyBeginAllowThreads();
8777 (arg1)->Move((wxPoint const &)*arg2);
8778 wxPyEndAllowThreads(__tstate);
8779 if (PyErr_Occurred()) SWIG_fail;
8780 }
8781 resultobj = SWIG_Py_Void();
8782 return resultobj;
8783 fail:
8784 return NULL;
8785 }
8786
8787
8788 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8789 PyObject *resultobj = 0;
8790 wxCaret *arg1 = (wxCaret *) 0 ;
8791 int arg2 ;
8792 int arg3 ;
8793 void *argp1 = 0 ;
8794 int res1 = 0 ;
8795 int val2 ;
8796 int ecode2 = 0 ;
8797 int val3 ;
8798 int ecode3 = 0 ;
8799 PyObject * obj0 = 0 ;
8800 PyObject * obj1 = 0 ;
8801 PyObject * obj2 = 0 ;
8802 char * kwnames[] = {
8803 (char *) "self",(char *) "width",(char *) "height", NULL
8804 };
8805
8806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8808 if (!SWIG_IsOK(res1)) {
8809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8810 }
8811 arg1 = reinterpret_cast< wxCaret * >(argp1);
8812 ecode2 = SWIG_AsVal_int(obj1, &val2);
8813 if (!SWIG_IsOK(ecode2)) {
8814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8815 }
8816 arg2 = static_cast< int >(val2);
8817 ecode3 = SWIG_AsVal_int(obj2, &val3);
8818 if (!SWIG_IsOK(ecode3)) {
8819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8820 }
8821 arg3 = static_cast< int >(val3);
8822 {
8823 PyThreadState* __tstate = wxPyBeginAllowThreads();
8824 (arg1)->SetSize(arg2,arg3);
8825 wxPyEndAllowThreads(__tstate);
8826 if (PyErr_Occurred()) SWIG_fail;
8827 }
8828 resultobj = SWIG_Py_Void();
8829 return resultobj;
8830 fail:
8831 return NULL;
8832 }
8833
8834
8835 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8836 PyObject *resultobj = 0;
8837 wxCaret *arg1 = (wxCaret *) 0 ;
8838 wxSize *arg2 = 0 ;
8839 void *argp1 = 0 ;
8840 int res1 = 0 ;
8841 wxSize temp2 ;
8842 PyObject * obj0 = 0 ;
8843 PyObject * obj1 = 0 ;
8844 char * kwnames[] = {
8845 (char *) "self",(char *) "size", NULL
8846 };
8847
8848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8850 if (!SWIG_IsOK(res1)) {
8851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8852 }
8853 arg1 = reinterpret_cast< wxCaret * >(argp1);
8854 {
8855 arg2 = &temp2;
8856 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8857 }
8858 {
8859 PyThreadState* __tstate = wxPyBeginAllowThreads();
8860 (arg1)->SetSize((wxSize const &)*arg2);
8861 wxPyEndAllowThreads(__tstate);
8862 if (PyErr_Occurred()) SWIG_fail;
8863 }
8864 resultobj = SWIG_Py_Void();
8865 return resultobj;
8866 fail:
8867 return NULL;
8868 }
8869
8870
8871 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8872 PyObject *resultobj = 0;
8873 wxCaret *arg1 = (wxCaret *) 0 ;
8874 int arg2 = (int) true ;
8875 void *argp1 = 0 ;
8876 int res1 = 0 ;
8877 int val2 ;
8878 int ecode2 = 0 ;
8879 PyObject * obj0 = 0 ;
8880 PyObject * obj1 = 0 ;
8881 char * kwnames[] = {
8882 (char *) "self",(char *) "show", NULL
8883 };
8884
8885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8887 if (!SWIG_IsOK(res1)) {
8888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8889 }
8890 arg1 = reinterpret_cast< wxCaret * >(argp1);
8891 if (obj1) {
8892 ecode2 = SWIG_AsVal_int(obj1, &val2);
8893 if (!SWIG_IsOK(ecode2)) {
8894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8895 }
8896 arg2 = static_cast< int >(val2);
8897 }
8898 {
8899 PyThreadState* __tstate = wxPyBeginAllowThreads();
8900 (arg1)->Show(arg2);
8901 wxPyEndAllowThreads(__tstate);
8902 if (PyErr_Occurred()) SWIG_fail;
8903 }
8904 resultobj = SWIG_Py_Void();
8905 return resultobj;
8906 fail:
8907 return NULL;
8908 }
8909
8910
8911 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8912 PyObject *resultobj = 0;
8913 wxCaret *arg1 = (wxCaret *) 0 ;
8914 void *argp1 = 0 ;
8915 int res1 = 0 ;
8916 PyObject *swig_obj[1] ;
8917
8918 if (!args) SWIG_fail;
8919 swig_obj[0] = args;
8920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8921 if (!SWIG_IsOK(res1)) {
8922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8923 }
8924 arg1 = reinterpret_cast< wxCaret * >(argp1);
8925 {
8926 PyThreadState* __tstate = wxPyBeginAllowThreads();
8927 (arg1)->Hide();
8928 wxPyEndAllowThreads(__tstate);
8929 if (PyErr_Occurred()) SWIG_fail;
8930 }
8931 resultobj = SWIG_Py_Void();
8932 return resultobj;
8933 fail:
8934 return NULL;
8935 }
8936
8937
8938 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8939 PyObject *resultobj = 0;
8940 int result;
8941
8942 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8943 {
8944 PyThreadState* __tstate = wxPyBeginAllowThreads();
8945 result = (int)wxCaret::GetBlinkTime();
8946 wxPyEndAllowThreads(__tstate);
8947 if (PyErr_Occurred()) SWIG_fail;
8948 }
8949 resultobj = SWIG_From_int(static_cast< int >(result));
8950 return resultobj;
8951 fail:
8952 return NULL;
8953 }
8954
8955
8956 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8957 PyObject *resultobj = 0;
8958 int arg1 ;
8959 int val1 ;
8960 int ecode1 = 0 ;
8961 PyObject * obj0 = 0 ;
8962 char * kwnames[] = {
8963 (char *) "milliseconds", NULL
8964 };
8965
8966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8967 ecode1 = SWIG_AsVal_int(obj0, &val1);
8968 if (!SWIG_IsOK(ecode1)) {
8969 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8970 }
8971 arg1 = static_cast< int >(val1);
8972 {
8973 PyThreadState* __tstate = wxPyBeginAllowThreads();
8974 wxCaret::SetBlinkTime(arg1);
8975 wxPyEndAllowThreads(__tstate);
8976 if (PyErr_Occurred()) SWIG_fail;
8977 }
8978 resultobj = SWIG_Py_Void();
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
8985 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8986 PyObject *obj;
8987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8988 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8989 return SWIG_Py_Void();
8990 }
8991
8992 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8993 return SWIG_Python_InitShadowInstance(args);
8994 }
8995
8996 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8997 PyObject *resultobj = 0;
8998 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8999 wxBusyCursor *result = 0 ;
9000 void *argp1 = 0 ;
9001 int res1 = 0 ;
9002 PyObject * obj0 = 0 ;
9003 char * kwnames[] = {
9004 (char *) "cursor", NULL
9005 };
9006
9007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9008 if (obj0) {
9009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9010 if (!SWIG_IsOK(res1)) {
9011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9012 }
9013 arg1 = reinterpret_cast< wxCursor * >(argp1);
9014 }
9015 {
9016 if (!wxPyCheckForApp()) SWIG_fail;
9017 PyThreadState* __tstate = wxPyBeginAllowThreads();
9018 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9019 wxPyEndAllowThreads(__tstate);
9020 if (PyErr_Occurred()) SWIG_fail;
9021 }
9022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9023 return resultobj;
9024 fail:
9025 return NULL;
9026 }
9027
9028
9029 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9030 PyObject *resultobj = 0;
9031 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9032 void *argp1 = 0 ;
9033 int res1 = 0 ;
9034 PyObject *swig_obj[1] ;
9035
9036 if (!args) SWIG_fail;
9037 swig_obj[0] = args;
9038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9039 if (!SWIG_IsOK(res1)) {
9040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9041 }
9042 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9043 {
9044 PyThreadState* __tstate = wxPyBeginAllowThreads();
9045 delete arg1;
9046
9047 wxPyEndAllowThreads(__tstate);
9048 if (PyErr_Occurred()) SWIG_fail;
9049 }
9050 resultobj = SWIG_Py_Void();
9051 return resultobj;
9052 fail:
9053 return NULL;
9054 }
9055
9056
9057 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9058 PyObject *obj;
9059 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9060 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9061 return SWIG_Py_Void();
9062 }
9063
9064 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9065 return SWIG_Python_InitShadowInstance(args);
9066 }
9067
9068 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9069 PyObject *resultobj = 0;
9070 wxWindow *arg1 = (wxWindow *) NULL ;
9071 wxWindowDisabler *result = 0 ;
9072 void *argp1 = 0 ;
9073 int res1 = 0 ;
9074 PyObject * obj0 = 0 ;
9075 char * kwnames[] = {
9076 (char *) "winToSkip", NULL
9077 };
9078
9079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9080 if (obj0) {
9081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9082 if (!SWIG_IsOK(res1)) {
9083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9084 }
9085 arg1 = reinterpret_cast< wxWindow * >(argp1);
9086 }
9087 {
9088 if (!wxPyCheckForApp()) SWIG_fail;
9089 PyThreadState* __tstate = wxPyBeginAllowThreads();
9090 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9091 wxPyEndAllowThreads(__tstate);
9092 if (PyErr_Occurred()) SWIG_fail;
9093 }
9094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9095 return resultobj;
9096 fail:
9097 return NULL;
9098 }
9099
9100
9101 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9102 PyObject *resultobj = 0;
9103 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9104 void *argp1 = 0 ;
9105 int res1 = 0 ;
9106 PyObject *swig_obj[1] ;
9107
9108 if (!args) SWIG_fail;
9109 swig_obj[0] = args;
9110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9111 if (!SWIG_IsOK(res1)) {
9112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9113 }
9114 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9115 {
9116 PyThreadState* __tstate = wxPyBeginAllowThreads();
9117 delete arg1;
9118
9119 wxPyEndAllowThreads(__tstate);
9120 if (PyErr_Occurred()) SWIG_fail;
9121 }
9122 resultobj = SWIG_Py_Void();
9123 return resultobj;
9124 fail:
9125 return NULL;
9126 }
9127
9128
9129 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9130 PyObject *obj;
9131 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9132 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9133 return SWIG_Py_Void();
9134 }
9135
9136 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9137 return SWIG_Python_InitShadowInstance(args);
9138 }
9139
9140 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9141 PyObject *resultobj = 0;
9142 wxString *arg1 = 0 ;
9143 wxBusyInfo *result = 0 ;
9144 bool temp1 = false ;
9145 PyObject * obj0 = 0 ;
9146 char * kwnames[] = {
9147 (char *) "message", NULL
9148 };
9149
9150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9151 {
9152 arg1 = wxString_in_helper(obj0);
9153 if (arg1 == NULL) SWIG_fail;
9154 temp1 = true;
9155 }
9156 {
9157 if (!wxPyCheckForApp()) SWIG_fail;
9158 PyThreadState* __tstate = wxPyBeginAllowThreads();
9159 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9160 wxPyEndAllowThreads(__tstate);
9161 if (PyErr_Occurred()) SWIG_fail;
9162 }
9163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9164 {
9165 if (temp1)
9166 delete arg1;
9167 }
9168 return resultobj;
9169 fail:
9170 {
9171 if (temp1)
9172 delete arg1;
9173 }
9174 return NULL;
9175 }
9176
9177
9178 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9179 PyObject *resultobj = 0;
9180 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9181 void *argp1 = 0 ;
9182 int res1 = 0 ;
9183 PyObject *swig_obj[1] ;
9184
9185 if (!args) SWIG_fail;
9186 swig_obj[0] = args;
9187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9188 if (!SWIG_IsOK(res1)) {
9189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9190 }
9191 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9192 {
9193 PyThreadState* __tstate = wxPyBeginAllowThreads();
9194 delete arg1;
9195
9196 wxPyEndAllowThreads(__tstate);
9197 if (PyErr_Occurred()) SWIG_fail;
9198 }
9199 resultobj = SWIG_Py_Void();
9200 return resultobj;
9201 fail:
9202 return NULL;
9203 }
9204
9205
9206 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9207 PyObject *obj;
9208 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9209 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9210 return SWIG_Py_Void();
9211 }
9212
9213 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9214 return SWIG_Python_InitShadowInstance(args);
9215 }
9216
9217 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9218 PyObject *resultobj = 0;
9219 wxStopWatch *result = 0 ;
9220
9221 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9222 {
9223 PyThreadState* __tstate = wxPyBeginAllowThreads();
9224 result = (wxStopWatch *)new wxStopWatch();
9225 wxPyEndAllowThreads(__tstate);
9226 if (PyErr_Occurred()) SWIG_fail;
9227 }
9228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9229 return resultobj;
9230 fail:
9231 return NULL;
9232 }
9233
9234
9235 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9236 PyObject *resultobj = 0;
9237 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9238 long arg2 = (long) 0 ;
9239 void *argp1 = 0 ;
9240 int res1 = 0 ;
9241 long val2 ;
9242 int ecode2 = 0 ;
9243 PyObject * obj0 = 0 ;
9244 PyObject * obj1 = 0 ;
9245 char * kwnames[] = {
9246 (char *) "self",(char *) "t0", NULL
9247 };
9248
9249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9251 if (!SWIG_IsOK(res1)) {
9252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9253 }
9254 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9255 if (obj1) {
9256 ecode2 = SWIG_AsVal_long(obj1, &val2);
9257 if (!SWIG_IsOK(ecode2)) {
9258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9259 }
9260 arg2 = static_cast< long >(val2);
9261 }
9262 {
9263 PyThreadState* __tstate = wxPyBeginAllowThreads();
9264 (arg1)->Start(arg2);
9265 wxPyEndAllowThreads(__tstate);
9266 if (PyErr_Occurred()) SWIG_fail;
9267 }
9268 resultobj = SWIG_Py_Void();
9269 return resultobj;
9270 fail:
9271 return NULL;
9272 }
9273
9274
9275 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9276 PyObject *resultobj = 0;
9277 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9278 void *argp1 = 0 ;
9279 int res1 = 0 ;
9280 PyObject *swig_obj[1] ;
9281
9282 if (!args) SWIG_fail;
9283 swig_obj[0] = args;
9284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9285 if (!SWIG_IsOK(res1)) {
9286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9287 }
9288 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9289 {
9290 PyThreadState* __tstate = wxPyBeginAllowThreads();
9291 (arg1)->Pause();
9292 wxPyEndAllowThreads(__tstate);
9293 if (PyErr_Occurred()) SWIG_fail;
9294 }
9295 resultobj = SWIG_Py_Void();
9296 return resultobj;
9297 fail:
9298 return NULL;
9299 }
9300
9301
9302 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9303 PyObject *resultobj = 0;
9304 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9305 void *argp1 = 0 ;
9306 int res1 = 0 ;
9307 PyObject *swig_obj[1] ;
9308
9309 if (!args) SWIG_fail;
9310 swig_obj[0] = args;
9311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9312 if (!SWIG_IsOK(res1)) {
9313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9314 }
9315 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9316 {
9317 PyThreadState* __tstate = wxPyBeginAllowThreads();
9318 (arg1)->Resume();
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_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9330 PyObject *resultobj = 0;
9331 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9332 long 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_wxStopWatch, 0 | 0 );
9340 if (!SWIG_IsOK(res1)) {
9341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9342 }
9343 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9344 {
9345 PyThreadState* __tstate = wxPyBeginAllowThreads();
9346 result = (long)((wxStopWatch const *)arg1)->Time();
9347 wxPyEndAllowThreads(__tstate);
9348 if (PyErr_Occurred()) SWIG_fail;
9349 }
9350 resultobj = SWIG_From_long(static_cast< long >(result));
9351 return resultobj;
9352 fail:
9353 return NULL;
9354 }
9355
9356
9357 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9358 PyObject *obj;
9359 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9360 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9361 return SWIG_Py_Void();
9362 }
9363
9364 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9365 return SWIG_Python_InitShadowInstance(args);
9366 }
9367
9368 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9369 PyObject *resultobj = 0;
9370 int arg1 = (int) 9 ;
9371 int arg2 = (int) wxID_FILE1 ;
9372 wxFileHistory *result = 0 ;
9373 int val1 ;
9374 int ecode1 = 0 ;
9375 int val2 ;
9376 int ecode2 = 0 ;
9377 PyObject * obj0 = 0 ;
9378 PyObject * obj1 = 0 ;
9379 char * kwnames[] = {
9380 (char *) "maxFiles",(char *) "idBase", NULL
9381 };
9382
9383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9384 if (obj0) {
9385 ecode1 = SWIG_AsVal_int(obj0, &val1);
9386 if (!SWIG_IsOK(ecode1)) {
9387 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9388 }
9389 arg1 = static_cast< int >(val1);
9390 }
9391 if (obj1) {
9392 ecode2 = SWIG_AsVal_int(obj1, &val2);
9393 if (!SWIG_IsOK(ecode2)) {
9394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9395 }
9396 arg2 = static_cast< int >(val2);
9397 }
9398 {
9399 PyThreadState* __tstate = wxPyBeginAllowThreads();
9400 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9401 wxPyEndAllowThreads(__tstate);
9402 if (PyErr_Occurred()) SWIG_fail;
9403 }
9404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9405 return resultobj;
9406 fail:
9407 return NULL;
9408 }
9409
9410
9411 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9412 PyObject *resultobj = 0;
9413 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9414 void *argp1 = 0 ;
9415 int res1 = 0 ;
9416 PyObject *swig_obj[1] ;
9417
9418 if (!args) SWIG_fail;
9419 swig_obj[0] = args;
9420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9421 if (!SWIG_IsOK(res1)) {
9422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9423 }
9424 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9425 {
9426 PyThreadState* __tstate = wxPyBeginAllowThreads();
9427 delete arg1;
9428
9429 wxPyEndAllowThreads(__tstate);
9430 if (PyErr_Occurred()) SWIG_fail;
9431 }
9432 resultobj = SWIG_Py_Void();
9433 return resultobj;
9434 fail:
9435 return NULL;
9436 }
9437
9438
9439 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9440 PyObject *resultobj = 0;
9441 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9442 wxString *arg2 = 0 ;
9443 void *argp1 = 0 ;
9444 int res1 = 0 ;
9445 bool temp2 = false ;
9446 PyObject * obj0 = 0 ;
9447 PyObject * obj1 = 0 ;
9448 char * kwnames[] = {
9449 (char *) "self",(char *) "file", NULL
9450 };
9451
9452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9454 if (!SWIG_IsOK(res1)) {
9455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9456 }
9457 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9458 {
9459 arg2 = wxString_in_helper(obj1);
9460 if (arg2 == NULL) SWIG_fail;
9461 temp2 = true;
9462 }
9463 {
9464 PyThreadState* __tstate = wxPyBeginAllowThreads();
9465 (arg1)->AddFileToHistory((wxString const &)*arg2);
9466 wxPyEndAllowThreads(__tstate);
9467 if (PyErr_Occurred()) SWIG_fail;
9468 }
9469 resultobj = SWIG_Py_Void();
9470 {
9471 if (temp2)
9472 delete arg2;
9473 }
9474 return resultobj;
9475 fail:
9476 {
9477 if (temp2)
9478 delete arg2;
9479 }
9480 return NULL;
9481 }
9482
9483
9484 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9485 PyObject *resultobj = 0;
9486 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9487 int arg2 ;
9488 void *argp1 = 0 ;
9489 int res1 = 0 ;
9490 int val2 ;
9491 int ecode2 = 0 ;
9492 PyObject * obj0 = 0 ;
9493 PyObject * obj1 = 0 ;
9494 char * kwnames[] = {
9495 (char *) "self",(char *) "i", NULL
9496 };
9497
9498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9500 if (!SWIG_IsOK(res1)) {
9501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9502 }
9503 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9504 ecode2 = SWIG_AsVal_int(obj1, &val2);
9505 if (!SWIG_IsOK(ecode2)) {
9506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9507 }
9508 arg2 = static_cast< int >(val2);
9509 {
9510 PyThreadState* __tstate = wxPyBeginAllowThreads();
9511 (arg1)->RemoveFileFromHistory(arg2);
9512 wxPyEndAllowThreads(__tstate);
9513 if (PyErr_Occurred()) SWIG_fail;
9514 }
9515 resultobj = SWIG_Py_Void();
9516 return resultobj;
9517 fail:
9518 return NULL;
9519 }
9520
9521
9522 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9523 PyObject *resultobj = 0;
9524 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9525 int result;
9526 void *argp1 = 0 ;
9527 int res1 = 0 ;
9528 PyObject *swig_obj[1] ;
9529
9530 if (!args) SWIG_fail;
9531 swig_obj[0] = args;
9532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9533 if (!SWIG_IsOK(res1)) {
9534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9535 }
9536 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9537 {
9538 PyThreadState* __tstate = wxPyBeginAllowThreads();
9539 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9540 wxPyEndAllowThreads(__tstate);
9541 if (PyErr_Occurred()) SWIG_fail;
9542 }
9543 resultobj = SWIG_From_int(static_cast< int >(result));
9544 return resultobj;
9545 fail:
9546 return NULL;
9547 }
9548
9549
9550 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9551 PyObject *resultobj = 0;
9552 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9553 wxMenu *arg2 = (wxMenu *) 0 ;
9554 void *argp1 = 0 ;
9555 int res1 = 0 ;
9556 void *argp2 = 0 ;
9557 int res2 = 0 ;
9558 PyObject * obj0 = 0 ;
9559 PyObject * obj1 = 0 ;
9560 char * kwnames[] = {
9561 (char *) "self",(char *) "menu", NULL
9562 };
9563
9564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9566 if (!SWIG_IsOK(res1)) {
9567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9568 }
9569 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9570 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9571 if (!SWIG_IsOK(res2)) {
9572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9573 }
9574 arg2 = reinterpret_cast< wxMenu * >(argp2);
9575 {
9576 PyThreadState* __tstate = wxPyBeginAllowThreads();
9577 (arg1)->UseMenu(arg2);
9578 wxPyEndAllowThreads(__tstate);
9579 if (PyErr_Occurred()) SWIG_fail;
9580 }
9581 resultobj = SWIG_Py_Void();
9582 return resultobj;
9583 fail:
9584 return NULL;
9585 }
9586
9587
9588 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9589 PyObject *resultobj = 0;
9590 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9591 wxMenu *arg2 = (wxMenu *) 0 ;
9592 void *argp1 = 0 ;
9593 int res1 = 0 ;
9594 void *argp2 = 0 ;
9595 int res2 = 0 ;
9596 PyObject * obj0 = 0 ;
9597 PyObject * obj1 = 0 ;
9598 char * kwnames[] = {
9599 (char *) "self",(char *) "menu", NULL
9600 };
9601
9602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9604 if (!SWIG_IsOK(res1)) {
9605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9606 }
9607 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9608 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9609 if (!SWIG_IsOK(res2)) {
9610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9611 }
9612 arg2 = reinterpret_cast< wxMenu * >(argp2);
9613 {
9614 PyThreadState* __tstate = wxPyBeginAllowThreads();
9615 (arg1)->RemoveMenu(arg2);
9616 wxPyEndAllowThreads(__tstate);
9617 if (PyErr_Occurred()) SWIG_fail;
9618 }
9619 resultobj = SWIG_Py_Void();
9620 return resultobj;
9621 fail:
9622 return NULL;
9623 }
9624
9625
9626 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9627 PyObject *resultobj = 0;
9628 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9629 wxConfigBase *arg2 = 0 ;
9630 void *argp1 = 0 ;
9631 int res1 = 0 ;
9632 void *argp2 = 0 ;
9633 int res2 = 0 ;
9634 PyObject * obj0 = 0 ;
9635 PyObject * obj1 = 0 ;
9636 char * kwnames[] = {
9637 (char *) "self",(char *) "config", NULL
9638 };
9639
9640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9642 if (!SWIG_IsOK(res1)) {
9643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9644 }
9645 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9646 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9647 if (!SWIG_IsOK(res2)) {
9648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9649 }
9650 if (!argp2) {
9651 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9652 }
9653 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9654 {
9655 PyThreadState* __tstate = wxPyBeginAllowThreads();
9656 (arg1)->Load(*arg2);
9657 wxPyEndAllowThreads(__tstate);
9658 if (PyErr_Occurred()) SWIG_fail;
9659 }
9660 resultobj = SWIG_Py_Void();
9661 return resultobj;
9662 fail:
9663 return NULL;
9664 }
9665
9666
9667 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9668 PyObject *resultobj = 0;
9669 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9670 wxConfigBase *arg2 = 0 ;
9671 void *argp1 = 0 ;
9672 int res1 = 0 ;
9673 void *argp2 = 0 ;
9674 int res2 = 0 ;
9675 PyObject * obj0 = 0 ;
9676 PyObject * obj1 = 0 ;
9677 char * kwnames[] = {
9678 (char *) "self",(char *) "config", NULL
9679 };
9680
9681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9683 if (!SWIG_IsOK(res1)) {
9684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9685 }
9686 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9687 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9688 if (!SWIG_IsOK(res2)) {
9689 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9690 }
9691 if (!argp2) {
9692 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9693 }
9694 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9695 {
9696 PyThreadState* __tstate = wxPyBeginAllowThreads();
9697 (arg1)->Save(*arg2);
9698 wxPyEndAllowThreads(__tstate);
9699 if (PyErr_Occurred()) SWIG_fail;
9700 }
9701 resultobj = SWIG_Py_Void();
9702 return resultobj;
9703 fail:
9704 return NULL;
9705 }
9706
9707
9708 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9709 PyObject *resultobj = 0;
9710 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9711 void *argp1 = 0 ;
9712 int res1 = 0 ;
9713 PyObject *swig_obj[1] ;
9714
9715 if (!args) SWIG_fail;
9716 swig_obj[0] = args;
9717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9718 if (!SWIG_IsOK(res1)) {
9719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9720 }
9721 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9722 {
9723 PyThreadState* __tstate = wxPyBeginAllowThreads();
9724 (arg1)->AddFilesToMenu();
9725 wxPyEndAllowThreads(__tstate);
9726 if (PyErr_Occurred()) SWIG_fail;
9727 }
9728 resultobj = SWIG_Py_Void();
9729 return resultobj;
9730 fail:
9731 return NULL;
9732 }
9733
9734
9735 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9736 PyObject *resultobj = 0;
9737 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9738 wxMenu *arg2 = (wxMenu *) 0 ;
9739 void *argp1 = 0 ;
9740 int res1 = 0 ;
9741 void *argp2 = 0 ;
9742 int res2 = 0 ;
9743 PyObject * obj0 = 0 ;
9744 PyObject * obj1 = 0 ;
9745 char * kwnames[] = {
9746 (char *) "self",(char *) "menu", NULL
9747 };
9748
9749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9751 if (!SWIG_IsOK(res1)) {
9752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9753 }
9754 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9755 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9756 if (!SWIG_IsOK(res2)) {
9757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9758 }
9759 arg2 = reinterpret_cast< wxMenu * >(argp2);
9760 {
9761 PyThreadState* __tstate = wxPyBeginAllowThreads();
9762 (arg1)->AddFilesToMenu(arg2);
9763 wxPyEndAllowThreads(__tstate);
9764 if (PyErr_Occurred()) SWIG_fail;
9765 }
9766 resultobj = SWIG_Py_Void();
9767 return resultobj;
9768 fail:
9769 return NULL;
9770 }
9771
9772
9773 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9774 PyObject *resultobj = 0;
9775 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9776 int arg2 ;
9777 wxString result;
9778 void *argp1 = 0 ;
9779 int res1 = 0 ;
9780 int val2 ;
9781 int ecode2 = 0 ;
9782 PyObject * obj0 = 0 ;
9783 PyObject * obj1 = 0 ;
9784 char * kwnames[] = {
9785 (char *) "self",(char *) "i", NULL
9786 };
9787
9788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9790 if (!SWIG_IsOK(res1)) {
9791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9792 }
9793 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9794 ecode2 = SWIG_AsVal_int(obj1, &val2);
9795 if (!SWIG_IsOK(ecode2)) {
9796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9797 }
9798 arg2 = static_cast< int >(val2);
9799 {
9800 PyThreadState* __tstate = wxPyBeginAllowThreads();
9801 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9802 wxPyEndAllowThreads(__tstate);
9803 if (PyErr_Occurred()) SWIG_fail;
9804 }
9805 {
9806 #if wxUSE_UNICODE
9807 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9808 #else
9809 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9810 #endif
9811 }
9812 return resultobj;
9813 fail:
9814 return NULL;
9815 }
9816
9817
9818 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9819 PyObject *resultobj = 0;
9820 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9821 int result;
9822 void *argp1 = 0 ;
9823 int res1 = 0 ;
9824 PyObject *swig_obj[1] ;
9825
9826 if (!args) SWIG_fail;
9827 swig_obj[0] = args;
9828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9829 if (!SWIG_IsOK(res1)) {
9830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9831 }
9832 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9833 {
9834 PyThreadState* __tstate = wxPyBeginAllowThreads();
9835 result = (int)((wxFileHistory const *)arg1)->GetCount();
9836 wxPyEndAllowThreads(__tstate);
9837 if (PyErr_Occurred()) SWIG_fail;
9838 }
9839 resultobj = SWIG_From_int(static_cast< int >(result));
9840 return resultobj;
9841 fail:
9842 return NULL;
9843 }
9844
9845
9846 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9847 PyObject *obj;
9848 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9849 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9850 return SWIG_Py_Void();
9851 }
9852
9853 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9854 return SWIG_Python_InitShadowInstance(args);
9855 }
9856
9857 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9858 PyObject *resultobj = 0;
9859 wxString *arg1 = 0 ;
9860 wxString const &arg2_defvalue = wxPyEmptyString ;
9861 wxString *arg2 = (wxString *) &arg2_defvalue ;
9862 wxSingleInstanceChecker *result = 0 ;
9863 bool temp1 = false ;
9864 bool temp2 = false ;
9865 PyObject * obj0 = 0 ;
9866 PyObject * obj1 = 0 ;
9867 char * kwnames[] = {
9868 (char *) "name",(char *) "path", NULL
9869 };
9870
9871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9872 {
9873 arg1 = wxString_in_helper(obj0);
9874 if (arg1 == NULL) SWIG_fail;
9875 temp1 = true;
9876 }
9877 if (obj1) {
9878 {
9879 arg2 = wxString_in_helper(obj1);
9880 if (arg2 == NULL) SWIG_fail;
9881 temp2 = true;
9882 }
9883 }
9884 {
9885 PyThreadState* __tstate = wxPyBeginAllowThreads();
9886 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9887 wxPyEndAllowThreads(__tstate);
9888 if (PyErr_Occurred()) SWIG_fail;
9889 }
9890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9891 {
9892 if (temp1)
9893 delete arg1;
9894 }
9895 {
9896 if (temp2)
9897 delete arg2;
9898 }
9899 return resultobj;
9900 fail:
9901 {
9902 if (temp1)
9903 delete arg1;
9904 }
9905 {
9906 if (temp2)
9907 delete arg2;
9908 }
9909 return NULL;
9910 }
9911
9912
9913 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9914 PyObject *resultobj = 0;
9915 wxSingleInstanceChecker *result = 0 ;
9916
9917 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9918 {
9919 PyThreadState* __tstate = wxPyBeginAllowThreads();
9920 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9921 wxPyEndAllowThreads(__tstate);
9922 if (PyErr_Occurred()) SWIG_fail;
9923 }
9924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9925 return resultobj;
9926 fail:
9927 return NULL;
9928 }
9929
9930
9931 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9932 PyObject *resultobj = 0;
9933 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9934 void *argp1 = 0 ;
9935 int res1 = 0 ;
9936 PyObject *swig_obj[1] ;
9937
9938 if (!args) SWIG_fail;
9939 swig_obj[0] = args;
9940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9941 if (!SWIG_IsOK(res1)) {
9942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9943 }
9944 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9945 {
9946 PyThreadState* __tstate = wxPyBeginAllowThreads();
9947 delete arg1;
9948
9949 wxPyEndAllowThreads(__tstate);
9950 if (PyErr_Occurred()) SWIG_fail;
9951 }
9952 resultobj = SWIG_Py_Void();
9953 return resultobj;
9954 fail:
9955 return NULL;
9956 }
9957
9958
9959 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9960 PyObject *resultobj = 0;
9961 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9962 wxString *arg2 = 0 ;
9963 wxString const &arg3_defvalue = wxPyEmptyString ;
9964 wxString *arg3 = (wxString *) &arg3_defvalue ;
9965 bool result;
9966 void *argp1 = 0 ;
9967 int res1 = 0 ;
9968 bool temp2 = false ;
9969 bool temp3 = false ;
9970 PyObject * obj0 = 0 ;
9971 PyObject * obj1 = 0 ;
9972 PyObject * obj2 = 0 ;
9973 char * kwnames[] = {
9974 (char *) "self",(char *) "name",(char *) "path", NULL
9975 };
9976
9977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9979 if (!SWIG_IsOK(res1)) {
9980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9981 }
9982 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9983 {
9984 arg2 = wxString_in_helper(obj1);
9985 if (arg2 == NULL) SWIG_fail;
9986 temp2 = true;
9987 }
9988 if (obj2) {
9989 {
9990 arg3 = wxString_in_helper(obj2);
9991 if (arg3 == NULL) SWIG_fail;
9992 temp3 = true;
9993 }
9994 }
9995 {
9996 PyThreadState* __tstate = wxPyBeginAllowThreads();
9997 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9998 wxPyEndAllowThreads(__tstate);
9999 if (PyErr_Occurred()) SWIG_fail;
10000 }
10001 {
10002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10003 }
10004 {
10005 if (temp2)
10006 delete arg2;
10007 }
10008 {
10009 if (temp3)
10010 delete arg3;
10011 }
10012 return resultobj;
10013 fail:
10014 {
10015 if (temp2)
10016 delete arg2;
10017 }
10018 {
10019 if (temp3)
10020 delete arg3;
10021 }
10022 return NULL;
10023 }
10024
10025
10026 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10027 PyObject *resultobj = 0;
10028 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10029 bool result;
10030 void *argp1 = 0 ;
10031 int res1 = 0 ;
10032 PyObject *swig_obj[1] ;
10033
10034 if (!args) SWIG_fail;
10035 swig_obj[0] = args;
10036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10037 if (!SWIG_IsOK(res1)) {
10038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10039 }
10040 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10041 {
10042 PyThreadState* __tstate = wxPyBeginAllowThreads();
10043 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10044 wxPyEndAllowThreads(__tstate);
10045 if (PyErr_Occurred()) SWIG_fail;
10046 }
10047 {
10048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10049 }
10050 return resultobj;
10051 fail:
10052 return NULL;
10053 }
10054
10055
10056 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10057 PyObject *obj;
10058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10059 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10060 return SWIG_Py_Void();
10061 }
10062
10063 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10064 return SWIG_Python_InitShadowInstance(args);
10065 }
10066
10067 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10068 PyObject *resultobj = 0;
10069 wxPlatformInfo *result = 0 ;
10070
10071 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10072 {
10073 PyThreadState* __tstate = wxPyBeginAllowThreads();
10074 result = (wxPlatformInfo *)new wxPlatformInfo();
10075 wxPyEndAllowThreads(__tstate);
10076 if (PyErr_Occurred()) SWIG_fail;
10077 }
10078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10079 return resultobj;
10080 fail:
10081 return NULL;
10082 }
10083
10084
10085 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10086 PyObject *resultobj = 0;
10087 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10088 wxPlatformInfo *arg2 = 0 ;
10089 bool result;
10090 void *argp1 = 0 ;
10091 int res1 = 0 ;
10092 void *argp2 = 0 ;
10093 int res2 = 0 ;
10094 PyObject * obj0 = 0 ;
10095 PyObject * obj1 = 0 ;
10096 char * kwnames[] = {
10097 (char *) "self",(char *) "t", NULL
10098 };
10099
10100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10102 if (!SWIG_IsOK(res1)) {
10103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10104 }
10105 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10106 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10107 if (!SWIG_IsOK(res2)) {
10108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10109 }
10110 if (!argp2) {
10111 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10112 }
10113 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10114 {
10115 PyThreadState* __tstate = wxPyBeginAllowThreads();
10116 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10117 wxPyEndAllowThreads(__tstate);
10118 if (PyErr_Occurred()) SWIG_fail;
10119 }
10120 {
10121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10122 }
10123 return resultobj;
10124 fail:
10125 return NULL;
10126 }
10127
10128
10129 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10130 PyObject *resultobj = 0;
10131 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10132 wxPlatformInfo *arg2 = 0 ;
10133 bool result;
10134 void *argp1 = 0 ;
10135 int res1 = 0 ;
10136 void *argp2 = 0 ;
10137 int res2 = 0 ;
10138 PyObject * obj0 = 0 ;
10139 PyObject * obj1 = 0 ;
10140 char * kwnames[] = {
10141 (char *) "self",(char *) "t", NULL
10142 };
10143
10144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10146 if (!SWIG_IsOK(res1)) {
10147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10148 }
10149 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10150 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10151 if (!SWIG_IsOK(res2)) {
10152 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10153 }
10154 if (!argp2) {
10155 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10156 }
10157 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10158 {
10159 PyThreadState* __tstate = wxPyBeginAllowThreads();
10160 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10161 wxPyEndAllowThreads(__tstate);
10162 if (PyErr_Occurred()) SWIG_fail;
10163 }
10164 {
10165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10166 }
10167 return resultobj;
10168 fail:
10169 return NULL;
10170 }
10171
10172
10173 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10174 PyObject *resultobj = 0;
10175 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10176 int result;
10177 void *argp1 = 0 ;
10178 int res1 = 0 ;
10179 PyObject *swig_obj[1] ;
10180
10181 if (!args) SWIG_fail;
10182 swig_obj[0] = args;
10183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10184 if (!SWIG_IsOK(res1)) {
10185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10186 }
10187 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10188 {
10189 PyThreadState* __tstate = wxPyBeginAllowThreads();
10190 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10191 wxPyEndAllowThreads(__tstate);
10192 if (PyErr_Occurred()) SWIG_fail;
10193 }
10194 resultobj = SWIG_From_int(static_cast< int >(result));
10195 return resultobj;
10196 fail:
10197 return NULL;
10198 }
10199
10200
10201 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10202 PyObject *resultobj = 0;
10203 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10204 int result;
10205 void *argp1 = 0 ;
10206 int res1 = 0 ;
10207 PyObject *swig_obj[1] ;
10208
10209 if (!args) SWIG_fail;
10210 swig_obj[0] = args;
10211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10212 if (!SWIG_IsOK(res1)) {
10213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10214 }
10215 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10216 {
10217 PyThreadState* __tstate = wxPyBeginAllowThreads();
10218 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10219 wxPyEndAllowThreads(__tstate);
10220 if (PyErr_Occurred()) SWIG_fail;
10221 }
10222 resultobj = SWIG_From_int(static_cast< int >(result));
10223 return resultobj;
10224 fail:
10225 return NULL;
10226 }
10227
10228
10229 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10230 PyObject *resultobj = 0;
10231 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10232 int result;
10233 void *argp1 = 0 ;
10234 int res1 = 0 ;
10235 PyObject *swig_obj[1] ;
10236
10237 if (!args) SWIG_fail;
10238 swig_obj[0] = args;
10239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10240 if (!SWIG_IsOK(res1)) {
10241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10242 }
10243 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10244 {
10245 PyThreadState* __tstate = wxPyBeginAllowThreads();
10246 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10247 wxPyEndAllowThreads(__tstate);
10248 if (PyErr_Occurred()) SWIG_fail;
10249 }
10250 resultobj = SWIG_From_int(static_cast< int >(result));
10251 return resultobj;
10252 fail:
10253 return NULL;
10254 }
10255
10256
10257 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10258 PyObject *resultobj = 0;
10259 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10260 int result;
10261 void *argp1 = 0 ;
10262 int res1 = 0 ;
10263 PyObject *swig_obj[1] ;
10264
10265 if (!args) SWIG_fail;
10266 swig_obj[0] = args;
10267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10268 if (!SWIG_IsOK(res1)) {
10269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10270 }
10271 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10272 {
10273 PyThreadState* __tstate = wxPyBeginAllowThreads();
10274 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10275 wxPyEndAllowThreads(__tstate);
10276 if (PyErr_Occurred()) SWIG_fail;
10277 }
10278 resultobj = SWIG_From_int(static_cast< int >(result));
10279 return resultobj;
10280 fail:
10281 return NULL;
10282 }
10283
10284
10285 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10286 PyObject *resultobj = 0;
10287 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10288 bool result;
10289 void *argp1 = 0 ;
10290 int res1 = 0 ;
10291 PyObject *swig_obj[1] ;
10292
10293 if (!args) SWIG_fail;
10294 swig_obj[0] = args;
10295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10296 if (!SWIG_IsOK(res1)) {
10297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10298 }
10299 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10300 {
10301 PyThreadState* __tstate = wxPyBeginAllowThreads();
10302 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10303 wxPyEndAllowThreads(__tstate);
10304 if (PyErr_Occurred()) SWIG_fail;
10305 }
10306 {
10307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10308 }
10309 return resultobj;
10310 fail:
10311 return NULL;
10312 }
10313
10314
10315 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10316 PyObject *resultobj = 0;
10317 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10318 wxOperatingSystemId result;
10319 void *argp1 = 0 ;
10320 int res1 = 0 ;
10321 PyObject *swig_obj[1] ;
10322
10323 if (!args) SWIG_fail;
10324 swig_obj[0] = args;
10325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10326 if (!SWIG_IsOK(res1)) {
10327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10328 }
10329 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10330 {
10331 PyThreadState* __tstate = wxPyBeginAllowThreads();
10332 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10333 wxPyEndAllowThreads(__tstate);
10334 if (PyErr_Occurred()) SWIG_fail;
10335 }
10336 resultobj = SWIG_From_int(static_cast< int >(result));
10337 return resultobj;
10338 fail:
10339 return NULL;
10340 }
10341
10342
10343 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10344 PyObject *resultobj = 0;
10345 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10346 wxPortId result;
10347 void *argp1 = 0 ;
10348 int res1 = 0 ;
10349 PyObject *swig_obj[1] ;
10350
10351 if (!args) SWIG_fail;
10352 swig_obj[0] = args;
10353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10354 if (!SWIG_IsOK(res1)) {
10355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10356 }
10357 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10358 {
10359 PyThreadState* __tstate = wxPyBeginAllowThreads();
10360 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10361 wxPyEndAllowThreads(__tstate);
10362 if (PyErr_Occurred()) SWIG_fail;
10363 }
10364 resultobj = SWIG_From_int(static_cast< int >(result));
10365 return resultobj;
10366 fail:
10367 return NULL;
10368 }
10369
10370
10371 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10372 PyObject *resultobj = 0;
10373 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10374 wxArchitecture result;
10375 void *argp1 = 0 ;
10376 int res1 = 0 ;
10377 PyObject *swig_obj[1] ;
10378
10379 if (!args) SWIG_fail;
10380 swig_obj[0] = args;
10381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10382 if (!SWIG_IsOK(res1)) {
10383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10384 }
10385 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10386 {
10387 PyThreadState* __tstate = wxPyBeginAllowThreads();
10388 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10389 wxPyEndAllowThreads(__tstate);
10390 if (PyErr_Occurred()) SWIG_fail;
10391 }
10392 resultobj = SWIG_From_int(static_cast< int >(result));
10393 return resultobj;
10394 fail:
10395 return NULL;
10396 }
10397
10398
10399 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10400 PyObject *resultobj = 0;
10401 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10402 wxEndianness result;
10403 void *argp1 = 0 ;
10404 int res1 = 0 ;
10405 PyObject *swig_obj[1] ;
10406
10407 if (!args) SWIG_fail;
10408 swig_obj[0] = args;
10409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10410 if (!SWIG_IsOK(res1)) {
10411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10412 }
10413 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10414 {
10415 PyThreadState* __tstate = wxPyBeginAllowThreads();
10416 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10417 wxPyEndAllowThreads(__tstate);
10418 if (PyErr_Occurred()) SWIG_fail;
10419 }
10420 resultobj = SWIG_From_int(static_cast< int >(result));
10421 return resultobj;
10422 fail:
10423 return NULL;
10424 }
10425
10426
10427 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10428 PyObject *resultobj = 0;
10429 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10430 wxString result;
10431 void *argp1 = 0 ;
10432 int res1 = 0 ;
10433 PyObject *swig_obj[1] ;
10434
10435 if (!args) SWIG_fail;
10436 swig_obj[0] = args;
10437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10438 if (!SWIG_IsOK(res1)) {
10439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10440 }
10441 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10442 {
10443 PyThreadState* __tstate = wxPyBeginAllowThreads();
10444 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10445 wxPyEndAllowThreads(__tstate);
10446 if (PyErr_Occurred()) SWIG_fail;
10447 }
10448 {
10449 #if wxUSE_UNICODE
10450 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10451 #else
10452 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10453 #endif
10454 }
10455 return resultobj;
10456 fail:
10457 return NULL;
10458 }
10459
10460
10461 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10462 PyObject *resultobj = 0;
10463 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10464 wxString result;
10465 void *argp1 = 0 ;
10466 int res1 = 0 ;
10467 PyObject *swig_obj[1] ;
10468
10469 if (!args) SWIG_fail;
10470 swig_obj[0] = args;
10471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10472 if (!SWIG_IsOK(res1)) {
10473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10474 }
10475 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10476 {
10477 PyThreadState* __tstate = wxPyBeginAllowThreads();
10478 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10479 wxPyEndAllowThreads(__tstate);
10480 if (PyErr_Occurred()) SWIG_fail;
10481 }
10482 {
10483 #if wxUSE_UNICODE
10484 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10485 #else
10486 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10487 #endif
10488 }
10489 return resultobj;
10490 fail:
10491 return NULL;
10492 }
10493
10494
10495 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10496 PyObject *resultobj = 0;
10497 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10498 wxString result;
10499 void *argp1 = 0 ;
10500 int res1 = 0 ;
10501 PyObject *swig_obj[1] ;
10502
10503 if (!args) SWIG_fail;
10504 swig_obj[0] = args;
10505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10506 if (!SWIG_IsOK(res1)) {
10507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10508 }
10509 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10510 {
10511 PyThreadState* __tstate = wxPyBeginAllowThreads();
10512 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10513 wxPyEndAllowThreads(__tstate);
10514 if (PyErr_Occurred()) SWIG_fail;
10515 }
10516 {
10517 #if wxUSE_UNICODE
10518 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10519 #else
10520 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10521 #endif
10522 }
10523 return resultobj;
10524 fail:
10525 return NULL;
10526 }
10527
10528
10529 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10530 PyObject *resultobj = 0;
10531 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10532 wxString result;
10533 void *argp1 = 0 ;
10534 int res1 = 0 ;
10535 PyObject *swig_obj[1] ;
10536
10537 if (!args) SWIG_fail;
10538 swig_obj[0] = args;
10539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10540 if (!SWIG_IsOK(res1)) {
10541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10542 }
10543 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10544 {
10545 PyThreadState* __tstate = wxPyBeginAllowThreads();
10546 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10547 wxPyEndAllowThreads(__tstate);
10548 if (PyErr_Occurred()) SWIG_fail;
10549 }
10550 {
10551 #if wxUSE_UNICODE
10552 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10553 #else
10554 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10555 #endif
10556 }
10557 return resultobj;
10558 fail:
10559 return NULL;
10560 }
10561
10562
10563 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10564 PyObject *resultobj = 0;
10565 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10566 wxString result;
10567 void *argp1 = 0 ;
10568 int res1 = 0 ;
10569 PyObject *swig_obj[1] ;
10570
10571 if (!args) SWIG_fail;
10572 swig_obj[0] = args;
10573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10574 if (!SWIG_IsOK(res1)) {
10575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10576 }
10577 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10578 {
10579 PyThreadState* __tstate = wxPyBeginAllowThreads();
10580 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10581 wxPyEndAllowThreads(__tstate);
10582 if (PyErr_Occurred()) SWIG_fail;
10583 }
10584 {
10585 #if wxUSE_UNICODE
10586 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10587 #else
10588 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10589 #endif
10590 }
10591 return resultobj;
10592 fail:
10593 return NULL;
10594 }
10595
10596
10597 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10598 PyObject *resultobj = 0;
10599 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10600 wxString result;
10601 void *argp1 = 0 ;
10602 int res1 = 0 ;
10603 PyObject *swig_obj[1] ;
10604
10605 if (!args) SWIG_fail;
10606 swig_obj[0] = args;
10607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10608 if (!SWIG_IsOK(res1)) {
10609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10610 }
10611 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10612 {
10613 PyThreadState* __tstate = wxPyBeginAllowThreads();
10614 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10615 wxPyEndAllowThreads(__tstate);
10616 if (PyErr_Occurred()) SWIG_fail;
10617 }
10618 {
10619 #if wxUSE_UNICODE
10620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10621 #else
10622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10623 #endif
10624 }
10625 return resultobj;
10626 fail:
10627 return NULL;
10628 }
10629
10630
10631 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10632 PyObject *resultobj = 0;
10633 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10634 int arg2 ;
10635 int arg3 ;
10636 void *argp1 = 0 ;
10637 int res1 = 0 ;
10638 int val2 ;
10639 int ecode2 = 0 ;
10640 int val3 ;
10641 int ecode3 = 0 ;
10642 PyObject * obj0 = 0 ;
10643 PyObject * obj1 = 0 ;
10644 PyObject * obj2 = 0 ;
10645 char * kwnames[] = {
10646 (char *) "self",(char *) "major",(char *) "minor", NULL
10647 };
10648
10649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10651 if (!SWIG_IsOK(res1)) {
10652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10653 }
10654 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10655 ecode2 = SWIG_AsVal_int(obj1, &val2);
10656 if (!SWIG_IsOK(ecode2)) {
10657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10658 }
10659 arg2 = static_cast< int >(val2);
10660 ecode3 = SWIG_AsVal_int(obj2, &val3);
10661 if (!SWIG_IsOK(ecode3)) {
10662 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10663 }
10664 arg3 = static_cast< int >(val3);
10665 {
10666 PyThreadState* __tstate = wxPyBeginAllowThreads();
10667 (arg1)->SetOSVersion(arg2,arg3);
10668 wxPyEndAllowThreads(__tstate);
10669 if (PyErr_Occurred()) SWIG_fail;
10670 }
10671 resultobj = SWIG_Py_Void();
10672 return resultobj;
10673 fail:
10674 return NULL;
10675 }
10676
10677
10678 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10679 PyObject *resultobj = 0;
10680 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10681 int arg2 ;
10682 int arg3 ;
10683 void *argp1 = 0 ;
10684 int res1 = 0 ;
10685 int val2 ;
10686 int ecode2 = 0 ;
10687 int val3 ;
10688 int ecode3 = 0 ;
10689 PyObject * obj0 = 0 ;
10690 PyObject * obj1 = 0 ;
10691 PyObject * obj2 = 0 ;
10692 char * kwnames[] = {
10693 (char *) "self",(char *) "major",(char *) "minor", NULL
10694 };
10695
10696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10698 if (!SWIG_IsOK(res1)) {
10699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10700 }
10701 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10702 ecode2 = SWIG_AsVal_int(obj1, &val2);
10703 if (!SWIG_IsOK(ecode2)) {
10704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10705 }
10706 arg2 = static_cast< int >(val2);
10707 ecode3 = SWIG_AsVal_int(obj2, &val3);
10708 if (!SWIG_IsOK(ecode3)) {
10709 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10710 }
10711 arg3 = static_cast< int >(val3);
10712 {
10713 PyThreadState* __tstate = wxPyBeginAllowThreads();
10714 (arg1)->SetToolkitVersion(arg2,arg3);
10715 wxPyEndAllowThreads(__tstate);
10716 if (PyErr_Occurred()) SWIG_fail;
10717 }
10718 resultobj = SWIG_Py_Void();
10719 return resultobj;
10720 fail:
10721 return NULL;
10722 }
10723
10724
10725 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10726 PyObject *resultobj = 0;
10727 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10728 wxOperatingSystemId arg2 ;
10729 void *argp1 = 0 ;
10730 int res1 = 0 ;
10731 int val2 ;
10732 int ecode2 = 0 ;
10733 PyObject * obj0 = 0 ;
10734 PyObject * obj1 = 0 ;
10735 char * kwnames[] = {
10736 (char *) "self",(char *) "n", NULL
10737 };
10738
10739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10741 if (!SWIG_IsOK(res1)) {
10742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10743 }
10744 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10745 ecode2 = SWIG_AsVal_int(obj1, &val2);
10746 if (!SWIG_IsOK(ecode2)) {
10747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10748 }
10749 arg2 = static_cast< wxOperatingSystemId >(val2);
10750 {
10751 PyThreadState* __tstate = wxPyBeginAllowThreads();
10752 (arg1)->SetOperatingSystemId(arg2);
10753 wxPyEndAllowThreads(__tstate);
10754 if (PyErr_Occurred()) SWIG_fail;
10755 }
10756 resultobj = SWIG_Py_Void();
10757 return resultobj;
10758 fail:
10759 return NULL;
10760 }
10761
10762
10763 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10764 PyObject *resultobj = 0;
10765 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10766 wxPortId arg2 ;
10767 void *argp1 = 0 ;
10768 int res1 = 0 ;
10769 int val2 ;
10770 int ecode2 = 0 ;
10771 PyObject * obj0 = 0 ;
10772 PyObject * obj1 = 0 ;
10773 char * kwnames[] = {
10774 (char *) "self",(char *) "n", NULL
10775 };
10776
10777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10779 if (!SWIG_IsOK(res1)) {
10780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10781 }
10782 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10783 ecode2 = SWIG_AsVal_int(obj1, &val2);
10784 if (!SWIG_IsOK(ecode2)) {
10785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10786 }
10787 arg2 = static_cast< wxPortId >(val2);
10788 {
10789 PyThreadState* __tstate = wxPyBeginAllowThreads();
10790 (arg1)->SetPortId(arg2);
10791 wxPyEndAllowThreads(__tstate);
10792 if (PyErr_Occurred()) SWIG_fail;
10793 }
10794 resultobj = SWIG_Py_Void();
10795 return resultobj;
10796 fail:
10797 return NULL;
10798 }
10799
10800
10801 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10802 PyObject *resultobj = 0;
10803 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10804 wxArchitecture arg2 ;
10805 void *argp1 = 0 ;
10806 int res1 = 0 ;
10807 int val2 ;
10808 int ecode2 = 0 ;
10809 PyObject * obj0 = 0 ;
10810 PyObject * obj1 = 0 ;
10811 char * kwnames[] = {
10812 (char *) "self",(char *) "n", NULL
10813 };
10814
10815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
10816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10817 if (!SWIG_IsOK(res1)) {
10818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10819 }
10820 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10821 ecode2 = SWIG_AsVal_int(obj1, &val2);
10822 if (!SWIG_IsOK(ecode2)) {
10823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
10824 }
10825 arg2 = static_cast< wxArchitecture >(val2);
10826 {
10827 PyThreadState* __tstate = wxPyBeginAllowThreads();
10828 (arg1)->SetArchitecture(arg2);
10829 wxPyEndAllowThreads(__tstate);
10830 if (PyErr_Occurred()) SWIG_fail;
10831 }
10832 resultobj = SWIG_Py_Void();
10833 return resultobj;
10834 fail:
10835 return NULL;
10836 }
10837
10838
10839 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10840 PyObject *resultobj = 0;
10841 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10842 wxEndianness arg2 ;
10843 void *argp1 = 0 ;
10844 int res1 = 0 ;
10845 int val2 ;
10846 int ecode2 = 0 ;
10847 PyObject * obj0 = 0 ;
10848 PyObject * obj1 = 0 ;
10849 char * kwnames[] = {
10850 (char *) "self",(char *) "n", NULL
10851 };
10852
10853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
10854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10855 if (!SWIG_IsOK(res1)) {
10856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10857 }
10858 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10859 ecode2 = SWIG_AsVal_int(obj1, &val2);
10860 if (!SWIG_IsOK(ecode2)) {
10861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
10862 }
10863 arg2 = static_cast< wxEndianness >(val2);
10864 {
10865 PyThreadState* __tstate = wxPyBeginAllowThreads();
10866 (arg1)->SetEndianness(arg2);
10867 wxPyEndAllowThreads(__tstate);
10868 if (PyErr_Occurred()) SWIG_fail;
10869 }
10870 resultobj = SWIG_Py_Void();
10871 return resultobj;
10872 fail:
10873 return NULL;
10874 }
10875
10876
10877 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10878 PyObject *resultobj = 0;
10879 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10880 bool result;
10881 void *argp1 = 0 ;
10882 int res1 = 0 ;
10883 PyObject *swig_obj[1] ;
10884
10885 if (!args) SWIG_fail;
10886 swig_obj[0] = args;
10887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10888 if (!SWIG_IsOK(res1)) {
10889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10890 }
10891 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10892 {
10893 PyThreadState* __tstate = wxPyBeginAllowThreads();
10894 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
10895 wxPyEndAllowThreads(__tstate);
10896 if (PyErr_Occurred()) SWIG_fail;
10897 }
10898 {
10899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10900 }
10901 return resultobj;
10902 fail:
10903 return NULL;
10904 }
10905
10906
10907 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10908 PyObject *obj;
10909 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10910 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
10911 return SWIG_Py_Void();
10912 }
10913
10914 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10915 return SWIG_Python_InitShadowInstance(args);
10916 }
10917
10918 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10919 PyObject *resultobj = 0;
10920 wxWindow *arg1 = (wxWindow *) 0 ;
10921 wxDC *arg2 = 0 ;
10922 bool result;
10923 void *argp1 = 0 ;
10924 int res1 = 0 ;
10925 void *argp2 = 0 ;
10926 int res2 = 0 ;
10927 PyObject * obj0 = 0 ;
10928 PyObject * obj1 = 0 ;
10929 char * kwnames[] = {
10930 (char *) "window",(char *) "dc", NULL
10931 };
10932
10933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
10934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10935 if (!SWIG_IsOK(res1)) {
10936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
10937 }
10938 arg1 = reinterpret_cast< wxWindow * >(argp1);
10939 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
10940 if (!SWIG_IsOK(res2)) {
10941 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10942 }
10943 if (!argp2) {
10944 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10945 }
10946 arg2 = reinterpret_cast< wxDC * >(argp2);
10947 {
10948 PyThreadState* __tstate = wxPyBeginAllowThreads();
10949 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
10950 wxPyEndAllowThreads(__tstate);
10951 if (PyErr_Occurred()) SWIG_fail;
10952 }
10953 {
10954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10955 }
10956 return resultobj;
10957 fail:
10958 return NULL;
10959 }
10960
10961
10962 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10963 PyObject *resultobj = 0;
10964 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10965 void *argp1 = 0 ;
10966 int res1 = 0 ;
10967 PyObject *swig_obj[1] ;
10968
10969 if (!args) SWIG_fail;
10970 swig_obj[0] = args;
10971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
10972 if (!SWIG_IsOK(res1)) {
10973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10974 }
10975 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10976 {
10977 PyThreadState* __tstate = wxPyBeginAllowThreads();
10978 delete arg1;
10979
10980 wxPyEndAllowThreads(__tstate);
10981 if (PyErr_Occurred()) SWIG_fail;
10982 }
10983 resultobj = SWIG_Py_Void();
10984 return resultobj;
10985 fail:
10986 return NULL;
10987 }
10988
10989
10990 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10991 PyObject *resultobj = 0;
10992 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10993 wxString result;
10994 void *argp1 = 0 ;
10995 int res1 = 0 ;
10996 PyObject *swig_obj[1] ;
10997
10998 if (!args) SWIG_fail;
10999 swig_obj[0] = args;
11000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11001 if (!SWIG_IsOK(res1)) {
11002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11003 }
11004 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11005 {
11006 PyThreadState* __tstate = wxPyBeginAllowThreads();
11007 result = (arg1)->GetTip();
11008 wxPyEndAllowThreads(__tstate);
11009 if (PyErr_Occurred()) SWIG_fail;
11010 }
11011 {
11012 #if wxUSE_UNICODE
11013 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11014 #else
11015 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11016 #endif
11017 }
11018 return resultobj;
11019 fail:
11020 return NULL;
11021 }
11022
11023
11024 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11025 PyObject *resultobj = 0;
11026 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11027 size_t result;
11028 void *argp1 = 0 ;
11029 int res1 = 0 ;
11030 PyObject *swig_obj[1] ;
11031
11032 if (!args) SWIG_fail;
11033 swig_obj[0] = args;
11034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11035 if (!SWIG_IsOK(res1)) {
11036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11037 }
11038 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11039 {
11040 PyThreadState* __tstate = wxPyBeginAllowThreads();
11041 result = (size_t)(arg1)->GetCurrentTip();
11042 wxPyEndAllowThreads(__tstate);
11043 if (PyErr_Occurred()) SWIG_fail;
11044 }
11045 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11046 return resultobj;
11047 fail:
11048 return NULL;
11049 }
11050
11051
11052 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11053 PyObject *resultobj = 0;
11054 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11055 wxString *arg2 = 0 ;
11056 wxString result;
11057 void *argp1 = 0 ;
11058 int res1 = 0 ;
11059 bool temp2 = false ;
11060 PyObject * obj0 = 0 ;
11061 PyObject * obj1 = 0 ;
11062 char * kwnames[] = {
11063 (char *) "self",(char *) "tip", NULL
11064 };
11065
11066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11068 if (!SWIG_IsOK(res1)) {
11069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11070 }
11071 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11072 {
11073 arg2 = wxString_in_helper(obj1);
11074 if (arg2 == NULL) SWIG_fail;
11075 temp2 = true;
11076 }
11077 {
11078 PyThreadState* __tstate = wxPyBeginAllowThreads();
11079 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11080 wxPyEndAllowThreads(__tstate);
11081 if (PyErr_Occurred()) SWIG_fail;
11082 }
11083 {
11084 #if wxUSE_UNICODE
11085 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11086 #else
11087 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11088 #endif
11089 }
11090 {
11091 if (temp2)
11092 delete arg2;
11093 }
11094 return resultobj;
11095 fail:
11096 {
11097 if (temp2)
11098 delete arg2;
11099 }
11100 return NULL;
11101 }
11102
11103
11104 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11105 PyObject *obj;
11106 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11107 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11108 return SWIG_Py_Void();
11109 }
11110
11111 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11112 PyObject *resultobj = 0;
11113 size_t arg1 ;
11114 wxPyTipProvider *result = 0 ;
11115 size_t val1 ;
11116 int ecode1 = 0 ;
11117 PyObject * obj0 = 0 ;
11118 char * kwnames[] = {
11119 (char *) "currentTip", NULL
11120 };
11121
11122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11123 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11124 if (!SWIG_IsOK(ecode1)) {
11125 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11126 }
11127 arg1 = static_cast< size_t >(val1);
11128 {
11129 PyThreadState* __tstate = wxPyBeginAllowThreads();
11130 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11131 wxPyEndAllowThreads(__tstate);
11132 if (PyErr_Occurred()) SWIG_fail;
11133 }
11134 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11135 return resultobj;
11136 fail:
11137 return NULL;
11138 }
11139
11140
11141 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11142 PyObject *resultobj = 0;
11143 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11144 PyObject *arg2 = (PyObject *) 0 ;
11145 PyObject *arg3 = (PyObject *) 0 ;
11146 void *argp1 = 0 ;
11147 int res1 = 0 ;
11148 PyObject * obj0 = 0 ;
11149 PyObject * obj1 = 0 ;
11150 PyObject * obj2 = 0 ;
11151 char * kwnames[] = {
11152 (char *) "self",(char *) "self",(char *) "_class", NULL
11153 };
11154
11155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11157 if (!SWIG_IsOK(res1)) {
11158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11159 }
11160 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11161 arg2 = obj1;
11162 arg3 = obj2;
11163 {
11164 PyThreadState* __tstate = wxPyBeginAllowThreads();
11165 (arg1)->_setCallbackInfo(arg2,arg3);
11166 wxPyEndAllowThreads(__tstate);
11167 if (PyErr_Occurred()) SWIG_fail;
11168 }
11169 resultobj = SWIG_Py_Void();
11170 return resultobj;
11171 fail:
11172 return NULL;
11173 }
11174
11175
11176 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11177 PyObject *obj;
11178 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11179 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11180 return SWIG_Py_Void();
11181 }
11182
11183 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11184 return SWIG_Python_InitShadowInstance(args);
11185 }
11186
11187 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11188 PyObject *resultobj = 0;
11189 wxWindow *arg1 = (wxWindow *) 0 ;
11190 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11191 bool arg3 = (bool) true ;
11192 bool result;
11193 void *argp1 = 0 ;
11194 int res1 = 0 ;
11195 void *argp2 = 0 ;
11196 int res2 = 0 ;
11197 bool val3 ;
11198 int ecode3 = 0 ;
11199 PyObject * obj0 = 0 ;
11200 PyObject * obj1 = 0 ;
11201 PyObject * obj2 = 0 ;
11202 char * kwnames[] = {
11203 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11204 };
11205
11206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11208 if (!SWIG_IsOK(res1)) {
11209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11210 }
11211 arg1 = reinterpret_cast< wxWindow * >(argp1);
11212 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11213 if (!SWIG_IsOK(res2)) {
11214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11215 }
11216 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11217 if (obj2) {
11218 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11219 if (!SWIG_IsOK(ecode3)) {
11220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11221 }
11222 arg3 = static_cast< bool >(val3);
11223 }
11224 {
11225 if (!wxPyCheckForApp()) SWIG_fail;
11226 PyThreadState* __tstate = wxPyBeginAllowThreads();
11227 result = (bool)wxShowTip(arg1,arg2,arg3);
11228 wxPyEndAllowThreads(__tstate);
11229 if (PyErr_Occurred()) SWIG_fail;
11230 }
11231 {
11232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11233 }
11234 return resultobj;
11235 fail:
11236 return NULL;
11237 }
11238
11239
11240 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11241 PyObject *resultobj = 0;
11242 wxString *arg1 = 0 ;
11243 size_t arg2 ;
11244 wxTipProvider *result = 0 ;
11245 bool temp1 = false ;
11246 size_t val2 ;
11247 int ecode2 = 0 ;
11248 PyObject * obj0 = 0 ;
11249 PyObject * obj1 = 0 ;
11250 char * kwnames[] = {
11251 (char *) "filename",(char *) "currentTip", NULL
11252 };
11253
11254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11255 {
11256 arg1 = wxString_in_helper(obj0);
11257 if (arg1 == NULL) SWIG_fail;
11258 temp1 = true;
11259 }
11260 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11261 if (!SWIG_IsOK(ecode2)) {
11262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11263 }
11264 arg2 = static_cast< size_t >(val2);
11265 {
11266 if (!wxPyCheckForApp()) SWIG_fail;
11267 PyThreadState* __tstate = wxPyBeginAllowThreads();
11268 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11269 wxPyEndAllowThreads(__tstate);
11270 if (PyErr_Occurred()) SWIG_fail;
11271 }
11272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11273 {
11274 if (temp1)
11275 delete arg1;
11276 }
11277 return resultobj;
11278 fail:
11279 {
11280 if (temp1)
11281 delete arg1;
11282 }
11283 return NULL;
11284 }
11285
11286
11287 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11288 PyObject *resultobj = 0;
11289 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11290 int arg2 = (int) wxID_ANY ;
11291 wxPyTimer *result = 0 ;
11292 void *argp1 = 0 ;
11293 int res1 = 0 ;
11294 int val2 ;
11295 int ecode2 = 0 ;
11296 PyObject * obj0 = 0 ;
11297 PyObject * obj1 = 0 ;
11298 char * kwnames[] = {
11299 (char *) "owner",(char *) "id", NULL
11300 };
11301
11302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11303 if (obj0) {
11304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11305 if (!SWIG_IsOK(res1)) {
11306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11307 }
11308 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11309 }
11310 if (obj1) {
11311 ecode2 = SWIG_AsVal_int(obj1, &val2);
11312 if (!SWIG_IsOK(ecode2)) {
11313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11314 }
11315 arg2 = static_cast< int >(val2);
11316 }
11317 {
11318 if (!wxPyCheckForApp()) SWIG_fail;
11319 PyThreadState* __tstate = wxPyBeginAllowThreads();
11320 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11321 wxPyEndAllowThreads(__tstate);
11322 if (PyErr_Occurred()) SWIG_fail;
11323 }
11324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11325 return resultobj;
11326 fail:
11327 return NULL;
11328 }
11329
11330
11331 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11332 PyObject *resultobj = 0;
11333 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11334 void *argp1 = 0 ;
11335 int res1 = 0 ;
11336 PyObject *swig_obj[1] ;
11337
11338 if (!args) SWIG_fail;
11339 swig_obj[0] = args;
11340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11341 if (!SWIG_IsOK(res1)) {
11342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11343 }
11344 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11345 {
11346 PyThreadState* __tstate = wxPyBeginAllowThreads();
11347 delete arg1;
11348
11349 wxPyEndAllowThreads(__tstate);
11350 if (PyErr_Occurred()) SWIG_fail;
11351 }
11352 resultobj = SWIG_Py_Void();
11353 return resultobj;
11354 fail:
11355 return NULL;
11356 }
11357
11358
11359 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11360 PyObject *resultobj = 0;
11361 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11362 PyObject *arg2 = (PyObject *) 0 ;
11363 PyObject *arg3 = (PyObject *) 0 ;
11364 int arg4 = (int) 1 ;
11365 void *argp1 = 0 ;
11366 int res1 = 0 ;
11367 int val4 ;
11368 int ecode4 = 0 ;
11369 PyObject * obj0 = 0 ;
11370 PyObject * obj1 = 0 ;
11371 PyObject * obj2 = 0 ;
11372 PyObject * obj3 = 0 ;
11373 char * kwnames[] = {
11374 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11375 };
11376
11377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11379 if (!SWIG_IsOK(res1)) {
11380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11381 }
11382 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11383 arg2 = obj1;
11384 arg3 = obj2;
11385 if (obj3) {
11386 ecode4 = SWIG_AsVal_int(obj3, &val4);
11387 if (!SWIG_IsOK(ecode4)) {
11388 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11389 }
11390 arg4 = static_cast< int >(val4);
11391 }
11392 {
11393 PyThreadState* __tstate = wxPyBeginAllowThreads();
11394 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11395 wxPyEndAllowThreads(__tstate);
11396 if (PyErr_Occurred()) SWIG_fail;
11397 }
11398 resultobj = SWIG_Py_Void();
11399 return resultobj;
11400 fail:
11401 return NULL;
11402 }
11403
11404
11405 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11406 PyObject *resultobj = 0;
11407 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11408 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11409 int arg3 = (int) wxID_ANY ;
11410 void *argp1 = 0 ;
11411 int res1 = 0 ;
11412 void *argp2 = 0 ;
11413 int res2 = 0 ;
11414 int val3 ;
11415 int ecode3 = 0 ;
11416 PyObject * obj0 = 0 ;
11417 PyObject * obj1 = 0 ;
11418 PyObject * obj2 = 0 ;
11419 char * kwnames[] = {
11420 (char *) "self",(char *) "owner",(char *) "id", NULL
11421 };
11422
11423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11425 if (!SWIG_IsOK(res1)) {
11426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11427 }
11428 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11429 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11430 if (!SWIG_IsOK(res2)) {
11431 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11432 }
11433 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11434 if (obj2) {
11435 ecode3 = SWIG_AsVal_int(obj2, &val3);
11436 if (!SWIG_IsOK(ecode3)) {
11437 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11438 }
11439 arg3 = static_cast< int >(val3);
11440 }
11441 {
11442 PyThreadState* __tstate = wxPyBeginAllowThreads();
11443 (arg1)->SetOwner(arg2,arg3);
11444 wxPyEndAllowThreads(__tstate);
11445 if (PyErr_Occurred()) SWIG_fail;
11446 }
11447 resultobj = SWIG_Py_Void();
11448 return resultobj;
11449 fail:
11450 return NULL;
11451 }
11452
11453
11454 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11455 PyObject *resultobj = 0;
11456 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11457 wxEvtHandler *result = 0 ;
11458 void *argp1 = 0 ;
11459 int res1 = 0 ;
11460 PyObject *swig_obj[1] ;
11461
11462 if (!args) SWIG_fail;
11463 swig_obj[0] = args;
11464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11465 if (!SWIG_IsOK(res1)) {
11466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11467 }
11468 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11469 {
11470 PyThreadState* __tstate = wxPyBeginAllowThreads();
11471 result = (wxEvtHandler *)(arg1)->GetOwner();
11472 wxPyEndAllowThreads(__tstate);
11473 if (PyErr_Occurred()) SWIG_fail;
11474 }
11475 {
11476 resultobj = wxPyMake_wxObject(result, 0);
11477 }
11478 return resultobj;
11479 fail:
11480 return NULL;
11481 }
11482
11483
11484 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11485 PyObject *resultobj = 0;
11486 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11487 int arg2 = (int) -1 ;
11488 bool arg3 = (bool) false ;
11489 bool result;
11490 void *argp1 = 0 ;
11491 int res1 = 0 ;
11492 int val2 ;
11493 int ecode2 = 0 ;
11494 bool val3 ;
11495 int ecode3 = 0 ;
11496 PyObject * obj0 = 0 ;
11497 PyObject * obj1 = 0 ;
11498 PyObject * obj2 = 0 ;
11499 char * kwnames[] = {
11500 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11501 };
11502
11503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11505 if (!SWIG_IsOK(res1)) {
11506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11507 }
11508 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11509 if (obj1) {
11510 ecode2 = SWIG_AsVal_int(obj1, &val2);
11511 if (!SWIG_IsOK(ecode2)) {
11512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11513 }
11514 arg2 = static_cast< int >(val2);
11515 }
11516 if (obj2) {
11517 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11518 if (!SWIG_IsOK(ecode3)) {
11519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11520 }
11521 arg3 = static_cast< bool >(val3);
11522 }
11523 {
11524 PyThreadState* __tstate = wxPyBeginAllowThreads();
11525 result = (bool)(arg1)->Start(arg2,arg3);
11526 wxPyEndAllowThreads(__tstate);
11527 if (PyErr_Occurred()) SWIG_fail;
11528 }
11529 {
11530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11531 }
11532 return resultobj;
11533 fail:
11534 return NULL;
11535 }
11536
11537
11538 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11539 PyObject *resultobj = 0;
11540 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11541 void *argp1 = 0 ;
11542 int res1 = 0 ;
11543 PyObject *swig_obj[1] ;
11544
11545 if (!args) SWIG_fail;
11546 swig_obj[0] = args;
11547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11548 if (!SWIG_IsOK(res1)) {
11549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11550 }
11551 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11552 {
11553 PyThreadState* __tstate = wxPyBeginAllowThreads();
11554 (arg1)->Stop();
11555 wxPyEndAllowThreads(__tstate);
11556 if (PyErr_Occurred()) SWIG_fail;
11557 }
11558 resultobj = SWIG_Py_Void();
11559 return resultobj;
11560 fail:
11561 return NULL;
11562 }
11563
11564
11565 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11566 PyObject *resultobj = 0;
11567 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11568 void *argp1 = 0 ;
11569 int res1 = 0 ;
11570 PyObject *swig_obj[1] ;
11571
11572 if (!args) SWIG_fail;
11573 swig_obj[0] = args;
11574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11575 if (!SWIG_IsOK(res1)) {
11576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11577 }
11578 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11579 {
11580 PyThreadState* __tstate = wxPyBeginAllowThreads();
11581 (arg1)->Notify();
11582 wxPyEndAllowThreads(__tstate);
11583 if (PyErr_Occurred()) SWIG_fail;
11584 }
11585 resultobj = SWIG_Py_Void();
11586 return resultobj;
11587 fail:
11588 return NULL;
11589 }
11590
11591
11592 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11593 PyObject *resultobj = 0;
11594 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11595 bool result;
11596 void *argp1 = 0 ;
11597 int res1 = 0 ;
11598 PyObject *swig_obj[1] ;
11599
11600 if (!args) SWIG_fail;
11601 swig_obj[0] = args;
11602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11603 if (!SWIG_IsOK(res1)) {
11604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11605 }
11606 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11607 {
11608 PyThreadState* __tstate = wxPyBeginAllowThreads();
11609 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11610 wxPyEndAllowThreads(__tstate);
11611 if (PyErr_Occurred()) SWIG_fail;
11612 }
11613 {
11614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11615 }
11616 return resultobj;
11617 fail:
11618 return NULL;
11619 }
11620
11621
11622 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11623 PyObject *resultobj = 0;
11624 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11625 int result;
11626 void *argp1 = 0 ;
11627 int res1 = 0 ;
11628 PyObject *swig_obj[1] ;
11629
11630 if (!args) SWIG_fail;
11631 swig_obj[0] = args;
11632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11633 if (!SWIG_IsOK(res1)) {
11634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11635 }
11636 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11637 {
11638 PyThreadState* __tstate = wxPyBeginAllowThreads();
11639 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11640 wxPyEndAllowThreads(__tstate);
11641 if (PyErr_Occurred()) SWIG_fail;
11642 }
11643 resultobj = SWIG_From_int(static_cast< int >(result));
11644 return resultobj;
11645 fail:
11646 return NULL;
11647 }
11648
11649
11650 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11651 PyObject *resultobj = 0;
11652 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11653 int result;
11654 void *argp1 = 0 ;
11655 int res1 = 0 ;
11656 PyObject *swig_obj[1] ;
11657
11658 if (!args) SWIG_fail;
11659 swig_obj[0] = args;
11660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11661 if (!SWIG_IsOK(res1)) {
11662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11663 }
11664 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11665 {
11666 PyThreadState* __tstate = wxPyBeginAllowThreads();
11667 result = (int)((wxPyTimer const *)arg1)->GetId();
11668 wxPyEndAllowThreads(__tstate);
11669 if (PyErr_Occurred()) SWIG_fail;
11670 }
11671 resultobj = SWIG_From_int(static_cast< int >(result));
11672 return resultobj;
11673 fail:
11674 return NULL;
11675 }
11676
11677
11678 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11679 PyObject *resultobj = 0;
11680 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11681 bool result;
11682 void *argp1 = 0 ;
11683 int res1 = 0 ;
11684 PyObject *swig_obj[1] ;
11685
11686 if (!args) SWIG_fail;
11687 swig_obj[0] = args;
11688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11689 if (!SWIG_IsOK(res1)) {
11690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11691 }
11692 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11693 {
11694 PyThreadState* __tstate = wxPyBeginAllowThreads();
11695 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11696 wxPyEndAllowThreads(__tstate);
11697 if (PyErr_Occurred()) SWIG_fail;
11698 }
11699 {
11700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11701 }
11702 return resultobj;
11703 fail:
11704 return NULL;
11705 }
11706
11707
11708 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11709 PyObject *obj;
11710 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11711 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11712 return SWIG_Py_Void();
11713 }
11714
11715 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11716 return SWIG_Python_InitShadowInstance(args);
11717 }
11718
11719 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11720 PyObject *resultobj = 0;
11721 int arg1 = (int) 0 ;
11722 int arg2 = (int) 0 ;
11723 wxTimerEvent *result = 0 ;
11724 int val1 ;
11725 int ecode1 = 0 ;
11726 int val2 ;
11727 int ecode2 = 0 ;
11728 PyObject * obj0 = 0 ;
11729 PyObject * obj1 = 0 ;
11730 char * kwnames[] = {
11731 (char *) "timerid",(char *) "interval", NULL
11732 };
11733
11734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11735 if (obj0) {
11736 ecode1 = SWIG_AsVal_int(obj0, &val1);
11737 if (!SWIG_IsOK(ecode1)) {
11738 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11739 }
11740 arg1 = static_cast< int >(val1);
11741 }
11742 if (obj1) {
11743 ecode2 = SWIG_AsVal_int(obj1, &val2);
11744 if (!SWIG_IsOK(ecode2)) {
11745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11746 }
11747 arg2 = static_cast< int >(val2);
11748 }
11749 {
11750 PyThreadState* __tstate = wxPyBeginAllowThreads();
11751 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11752 wxPyEndAllowThreads(__tstate);
11753 if (PyErr_Occurred()) SWIG_fail;
11754 }
11755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11756 return resultobj;
11757 fail:
11758 return NULL;
11759 }
11760
11761
11762 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11763 PyObject *resultobj = 0;
11764 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11765 int result;
11766 void *argp1 = 0 ;
11767 int res1 = 0 ;
11768 PyObject *swig_obj[1] ;
11769
11770 if (!args) SWIG_fail;
11771 swig_obj[0] = args;
11772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11773 if (!SWIG_IsOK(res1)) {
11774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11775 }
11776 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11777 {
11778 PyThreadState* __tstate = wxPyBeginAllowThreads();
11779 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11780 wxPyEndAllowThreads(__tstate);
11781 if (PyErr_Occurred()) SWIG_fail;
11782 }
11783 resultobj = SWIG_From_int(static_cast< int >(result));
11784 return resultobj;
11785 fail:
11786 return NULL;
11787 }
11788
11789
11790 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11791 PyObject *obj;
11792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11793 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11794 return SWIG_Py_Void();
11795 }
11796
11797 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11798 return SWIG_Python_InitShadowInstance(args);
11799 }
11800
11801 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11802 PyObject *resultobj = 0;
11803 wxTimer *arg1 = 0 ;
11804 wxTimerRunner *result = 0 ;
11805 void *argp1 = 0 ;
11806 int res1 = 0 ;
11807
11808 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11810 if (!SWIG_IsOK(res1)) {
11811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11812 }
11813 if (!argp1) {
11814 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11815 }
11816 arg1 = reinterpret_cast< wxTimer * >(argp1);
11817 {
11818 if (!wxPyCheckForApp()) SWIG_fail;
11819 PyThreadState* __tstate = wxPyBeginAllowThreads();
11820 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
11821 wxPyEndAllowThreads(__tstate);
11822 if (PyErr_Occurred()) SWIG_fail;
11823 }
11824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
11825 return resultobj;
11826 fail:
11827 return NULL;
11828 }
11829
11830
11831 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11832 PyObject *resultobj = 0;
11833 wxTimer *arg1 = 0 ;
11834 int arg2 ;
11835 bool arg3 = (bool) false ;
11836 wxTimerRunner *result = 0 ;
11837 void *argp1 = 0 ;
11838 int res1 = 0 ;
11839 int val2 ;
11840 int ecode2 = 0 ;
11841 bool val3 ;
11842 int ecode3 = 0 ;
11843
11844 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
11845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11846 if (!SWIG_IsOK(res1)) {
11847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11848 }
11849 if (!argp1) {
11850 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11851 }
11852 arg1 = reinterpret_cast< wxTimer * >(argp1);
11853 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11854 if (!SWIG_IsOK(ecode2)) {
11855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
11856 }
11857 arg2 = static_cast< int >(val2);
11858 if (swig_obj[2]) {
11859 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
11860 if (!SWIG_IsOK(ecode3)) {
11861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
11862 }
11863 arg3 = static_cast< bool >(val3);
11864 }
11865 {
11866 if (!wxPyCheckForApp()) SWIG_fail;
11867 PyThreadState* __tstate = wxPyBeginAllowThreads();
11868 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
11869 wxPyEndAllowThreads(__tstate);
11870 if (PyErr_Occurred()) SWIG_fail;
11871 }
11872 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
11873 return resultobj;
11874 fail:
11875 return NULL;
11876 }
11877
11878
11879 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
11880 int argc;
11881 PyObject *argv[4];
11882
11883 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
11884 --argc;
11885 if (argc == 1) {
11886 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
11887 }
11888 if ((argc >= 2) && (argc <= 3)) {
11889 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
11890 }
11891
11892 fail:
11893 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
11894 return NULL;
11895 }
11896
11897
11898 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11899 PyObject *resultobj = 0;
11900 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11901 void *argp1 = 0 ;
11902 int res1 = 0 ;
11903 PyObject *swig_obj[1] ;
11904
11905 if (!args) SWIG_fail;
11906 swig_obj[0] = args;
11907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
11908 if (!SWIG_IsOK(res1)) {
11909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11910 }
11911 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11912 {
11913 PyThreadState* __tstate = wxPyBeginAllowThreads();
11914 delete arg1;
11915
11916 wxPyEndAllowThreads(__tstate);
11917 if (PyErr_Occurred()) SWIG_fail;
11918 }
11919 resultobj = SWIG_Py_Void();
11920 return resultobj;
11921 fail:
11922 return NULL;
11923 }
11924
11925
11926 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11927 PyObject *resultobj = 0;
11928 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11929 int arg2 ;
11930 bool arg3 = (bool) false ;
11931 void *argp1 = 0 ;
11932 int res1 = 0 ;
11933 int val2 ;
11934 int ecode2 = 0 ;
11935 bool val3 ;
11936 int ecode3 = 0 ;
11937 PyObject * obj0 = 0 ;
11938 PyObject * obj1 = 0 ;
11939 PyObject * obj2 = 0 ;
11940 char * kwnames[] = {
11941 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
11942 };
11943
11944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
11946 if (!SWIG_IsOK(res1)) {
11947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11948 }
11949 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11950 ecode2 = SWIG_AsVal_int(obj1, &val2);
11951 if (!SWIG_IsOK(ecode2)) {
11952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
11953 }
11954 arg2 = static_cast< int >(val2);
11955 if (obj2) {
11956 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11957 if (!SWIG_IsOK(ecode3)) {
11958 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
11959 }
11960 arg3 = static_cast< bool >(val3);
11961 }
11962 {
11963 PyThreadState* __tstate = wxPyBeginAllowThreads();
11964 (arg1)->Start(arg2,arg3);
11965 wxPyEndAllowThreads(__tstate);
11966 if (PyErr_Occurred()) SWIG_fail;
11967 }
11968 resultobj = SWIG_Py_Void();
11969 return resultobj;
11970 fail:
11971 return NULL;
11972 }
11973
11974
11975 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11976 PyObject *obj;
11977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11978 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
11979 return SWIG_Py_Void();
11980 }
11981
11982 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11983 return SWIG_Python_InitShadowInstance(args);
11984 }
11985
11986 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11987 PyObject *resultobj = 0;
11988 wxLog *result = 0 ;
11989
11990 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
11991 {
11992 PyThreadState* __tstate = wxPyBeginAllowThreads();
11993 result = (wxLog *)new wxLog();
11994 wxPyEndAllowThreads(__tstate);
11995 if (PyErr_Occurred()) SWIG_fail;
11996 }
11997 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
11998 return resultobj;
11999 fail:
12000 return NULL;
12001 }
12002
12003
12004 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12005 PyObject *resultobj = 0;
12006 wxLog *arg1 = (wxLog *) 0 ;
12007 void *argp1 = 0 ;
12008 int res1 = 0 ;
12009 PyObject *swig_obj[1] ;
12010
12011 if (!args) SWIG_fail;
12012 swig_obj[0] = args;
12013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12014 if (!SWIG_IsOK(res1)) {
12015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12016 }
12017 arg1 = reinterpret_cast< wxLog * >(argp1);
12018 {
12019 PyThreadState* __tstate = wxPyBeginAllowThreads();
12020 delete arg1;
12021
12022 wxPyEndAllowThreads(__tstate);
12023 if (PyErr_Occurred()) SWIG_fail;
12024 }
12025 resultobj = SWIG_Py_Void();
12026 return resultobj;
12027 fail:
12028 return NULL;
12029 }
12030
12031
12032 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12033 PyObject *resultobj = 0;
12034 bool result;
12035
12036 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12037 {
12038 PyThreadState* __tstate = wxPyBeginAllowThreads();
12039 result = (bool)wxLog::IsEnabled();
12040 wxPyEndAllowThreads(__tstate);
12041 if (PyErr_Occurred()) SWIG_fail;
12042 }
12043 {
12044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12045 }
12046 return resultobj;
12047 fail:
12048 return NULL;
12049 }
12050
12051
12052 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12053 PyObject *resultobj = 0;
12054 bool arg1 = (bool) true ;
12055 bool result;
12056 bool val1 ;
12057 int ecode1 = 0 ;
12058 PyObject * obj0 = 0 ;
12059 char * kwnames[] = {
12060 (char *) "doIt", NULL
12061 };
12062
12063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12064 if (obj0) {
12065 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12066 if (!SWIG_IsOK(ecode1)) {
12067 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12068 }
12069 arg1 = static_cast< bool >(val1);
12070 }
12071 {
12072 PyThreadState* __tstate = wxPyBeginAllowThreads();
12073 result = (bool)wxLog::EnableLogging(arg1);
12074 wxPyEndAllowThreads(__tstate);
12075 if (PyErr_Occurred()) SWIG_fail;
12076 }
12077 {
12078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12079 }
12080 return resultobj;
12081 fail:
12082 return NULL;
12083 }
12084
12085
12086 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12087 PyObject *resultobj = 0;
12088 wxLogLevel arg1 ;
12089 wxChar *arg2 = (wxChar *) 0 ;
12090 time_t arg3 ;
12091 unsigned long val1 ;
12092 int ecode1 = 0 ;
12093 void *argp2 = 0 ;
12094 int res2 = 0 ;
12095 unsigned int val3 ;
12096 int ecode3 = 0 ;
12097 PyObject * obj0 = 0 ;
12098 PyObject * obj1 = 0 ;
12099 PyObject * obj2 = 0 ;
12100 char * kwnames[] = {
12101 (char *) "level",(char *) "szString",(char *) "t", NULL
12102 };
12103
12104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12105 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12106 if (!SWIG_IsOK(ecode1)) {
12107 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12108 }
12109 arg1 = static_cast< wxLogLevel >(val1);
12110 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12111 if (!SWIG_IsOK(res2)) {
12112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12113 }
12114 arg2 = reinterpret_cast< wxChar * >(argp2);
12115 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12116 if (!SWIG_IsOK(ecode3)) {
12117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12118 }
12119 arg3 = static_cast< time_t >(val3);
12120 {
12121 PyThreadState* __tstate = wxPyBeginAllowThreads();
12122 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12123 wxPyEndAllowThreads(__tstate);
12124 if (PyErr_Occurred()) SWIG_fail;
12125 }
12126 resultobj = SWIG_Py_Void();
12127 return resultobj;
12128 fail:
12129 return NULL;
12130 }
12131
12132
12133 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12134 PyObject *resultobj = 0;
12135 wxLog *arg1 = (wxLog *) 0 ;
12136 void *argp1 = 0 ;
12137 int res1 = 0 ;
12138 PyObject *swig_obj[1] ;
12139
12140 if (!args) SWIG_fail;
12141 swig_obj[0] = args;
12142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12143 if (!SWIG_IsOK(res1)) {
12144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12145 }
12146 arg1 = reinterpret_cast< wxLog * >(argp1);
12147 {
12148 PyThreadState* __tstate = wxPyBeginAllowThreads();
12149 (arg1)->Flush();
12150 wxPyEndAllowThreads(__tstate);
12151 if (PyErr_Occurred()) SWIG_fail;
12152 }
12153 resultobj = SWIG_Py_Void();
12154 return resultobj;
12155 fail:
12156 return NULL;
12157 }
12158
12159
12160 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12161 PyObject *resultobj = 0;
12162
12163 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12164 {
12165 PyThreadState* __tstate = wxPyBeginAllowThreads();
12166 wxLog::FlushActive();
12167 wxPyEndAllowThreads(__tstate);
12168 if (PyErr_Occurred()) SWIG_fail;
12169 }
12170 resultobj = SWIG_Py_Void();
12171 return resultobj;
12172 fail:
12173 return NULL;
12174 }
12175
12176
12177 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12178 PyObject *resultobj = 0;
12179 wxLog *result = 0 ;
12180
12181 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12182 {
12183 PyThreadState* __tstate = wxPyBeginAllowThreads();
12184 result = (wxLog *)wxLog::GetActiveTarget();
12185 wxPyEndAllowThreads(__tstate);
12186 if (PyErr_Occurred()) SWIG_fail;
12187 }
12188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12189 return resultobj;
12190 fail:
12191 return NULL;
12192 }
12193
12194
12195 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12196 PyObject *resultobj = 0;
12197 wxLog *arg1 = (wxLog *) 0 ;
12198 wxLog *result = 0 ;
12199 int res1 = 0 ;
12200 PyObject * obj0 = 0 ;
12201 char * kwnames[] = {
12202 (char *) "pLogger", NULL
12203 };
12204
12205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12206 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12207 if (!SWIG_IsOK(res1)) {
12208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12209 }
12210 {
12211 PyThreadState* __tstate = wxPyBeginAllowThreads();
12212 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12213 wxPyEndAllowThreads(__tstate);
12214 if (PyErr_Occurred()) SWIG_fail;
12215 }
12216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12217 return resultobj;
12218 fail:
12219 return NULL;
12220 }
12221
12222
12223 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12224 PyObject *resultobj = 0;
12225
12226 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12227 {
12228 PyThreadState* __tstate = wxPyBeginAllowThreads();
12229 wxLog::Suspend();
12230 wxPyEndAllowThreads(__tstate);
12231 if (PyErr_Occurred()) SWIG_fail;
12232 }
12233 resultobj = SWIG_Py_Void();
12234 return resultobj;
12235 fail:
12236 return NULL;
12237 }
12238
12239
12240 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12241 PyObject *resultobj = 0;
12242
12243 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12244 {
12245 PyThreadState* __tstate = wxPyBeginAllowThreads();
12246 wxLog::Resume();
12247 wxPyEndAllowThreads(__tstate);
12248 if (PyErr_Occurred()) SWIG_fail;
12249 }
12250 resultobj = SWIG_Py_Void();
12251 return resultobj;
12252 fail:
12253 return NULL;
12254 }
12255
12256
12257 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12258 PyObject *resultobj = 0;
12259 bool arg1 = (bool) true ;
12260 bool val1 ;
12261 int ecode1 = 0 ;
12262 PyObject * obj0 = 0 ;
12263 char * kwnames[] = {
12264 (char *) "bVerbose", NULL
12265 };
12266
12267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12268 if (obj0) {
12269 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12270 if (!SWIG_IsOK(ecode1)) {
12271 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12272 }
12273 arg1 = static_cast< bool >(val1);
12274 }
12275 {
12276 PyThreadState* __tstate = wxPyBeginAllowThreads();
12277 wxLog::SetVerbose(arg1);
12278 wxPyEndAllowThreads(__tstate);
12279 if (PyErr_Occurred()) SWIG_fail;
12280 }
12281 resultobj = SWIG_Py_Void();
12282 return resultobj;
12283 fail:
12284 return NULL;
12285 }
12286
12287
12288 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12289 PyObject *resultobj = 0;
12290 wxLogLevel arg1 ;
12291 unsigned long val1 ;
12292 int ecode1 = 0 ;
12293 PyObject * obj0 = 0 ;
12294 char * kwnames[] = {
12295 (char *) "logLevel", NULL
12296 };
12297
12298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12299 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12300 if (!SWIG_IsOK(ecode1)) {
12301 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12302 }
12303 arg1 = static_cast< wxLogLevel >(val1);
12304 {
12305 PyThreadState* __tstate = wxPyBeginAllowThreads();
12306 wxLog::SetLogLevel(arg1);
12307 wxPyEndAllowThreads(__tstate);
12308 if (PyErr_Occurred()) SWIG_fail;
12309 }
12310 resultobj = SWIG_Py_Void();
12311 return resultobj;
12312 fail:
12313 return NULL;
12314 }
12315
12316
12317 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12318 PyObject *resultobj = 0;
12319
12320 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12321 {
12322 PyThreadState* __tstate = wxPyBeginAllowThreads();
12323 wxLog::DontCreateOnDemand();
12324 wxPyEndAllowThreads(__tstate);
12325 if (PyErr_Occurred()) SWIG_fail;
12326 }
12327 resultobj = SWIG_Py_Void();
12328 return resultobj;
12329 fail:
12330 return NULL;
12331 }
12332
12333
12334 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12335 PyObject *resultobj = 0;
12336 bool arg1 = (bool) true ;
12337 bool val1 ;
12338 int ecode1 = 0 ;
12339 PyObject * obj0 = 0 ;
12340 char * kwnames[] = {
12341 (char *) "bRepetCounting", NULL
12342 };
12343
12344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12345 if (obj0) {
12346 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12347 if (!SWIG_IsOK(ecode1)) {
12348 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12349 }
12350 arg1 = static_cast< bool >(val1);
12351 }
12352 {
12353 PyThreadState* __tstate = wxPyBeginAllowThreads();
12354 wxLog::SetRepetitionCounting(arg1);
12355 wxPyEndAllowThreads(__tstate);
12356 if (PyErr_Occurred()) SWIG_fail;
12357 }
12358 resultobj = SWIG_Py_Void();
12359 return resultobj;
12360 fail:
12361 return NULL;
12362 }
12363
12364
12365 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12366 PyObject *resultobj = 0;
12367 bool result;
12368
12369 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12370 {
12371 PyThreadState* __tstate = wxPyBeginAllowThreads();
12372 result = (bool)wxLog::GetRepetitionCounting();
12373 wxPyEndAllowThreads(__tstate);
12374 if (PyErr_Occurred()) SWIG_fail;
12375 }
12376 {
12377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12378 }
12379 return resultobj;
12380 fail:
12381 return NULL;
12382 }
12383
12384
12385 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12386 PyObject *resultobj = 0;
12387 wxTraceMask arg1 ;
12388 unsigned long val1 ;
12389 int ecode1 = 0 ;
12390 PyObject * obj0 = 0 ;
12391 char * kwnames[] = {
12392 (char *) "ulMask", NULL
12393 };
12394
12395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12396 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12397 if (!SWIG_IsOK(ecode1)) {
12398 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12399 }
12400 arg1 = static_cast< wxTraceMask >(val1);
12401 {
12402 PyThreadState* __tstate = wxPyBeginAllowThreads();
12403 wxLog::SetTraceMask(arg1);
12404 wxPyEndAllowThreads(__tstate);
12405 if (PyErr_Occurred()) SWIG_fail;
12406 }
12407 resultobj = SWIG_Py_Void();
12408 return resultobj;
12409 fail:
12410 return NULL;
12411 }
12412
12413
12414 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12415 PyObject *resultobj = 0;
12416 wxString *arg1 = 0 ;
12417 bool temp1 = false ;
12418 PyObject * obj0 = 0 ;
12419 char * kwnames[] = {
12420 (char *) "str", NULL
12421 };
12422
12423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12424 {
12425 arg1 = wxString_in_helper(obj0);
12426 if (arg1 == NULL) SWIG_fail;
12427 temp1 = true;
12428 }
12429 {
12430 PyThreadState* __tstate = wxPyBeginAllowThreads();
12431 wxLog::AddTraceMask((wxString const &)*arg1);
12432 wxPyEndAllowThreads(__tstate);
12433 if (PyErr_Occurred()) SWIG_fail;
12434 }
12435 resultobj = SWIG_Py_Void();
12436 {
12437 if (temp1)
12438 delete arg1;
12439 }
12440 return resultobj;
12441 fail:
12442 {
12443 if (temp1)
12444 delete arg1;
12445 }
12446 return NULL;
12447 }
12448
12449
12450 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12451 PyObject *resultobj = 0;
12452 wxString *arg1 = 0 ;
12453 bool temp1 = false ;
12454 PyObject * obj0 = 0 ;
12455 char * kwnames[] = {
12456 (char *) "str", NULL
12457 };
12458
12459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12460 {
12461 arg1 = wxString_in_helper(obj0);
12462 if (arg1 == NULL) SWIG_fail;
12463 temp1 = true;
12464 }
12465 {
12466 PyThreadState* __tstate = wxPyBeginAllowThreads();
12467 wxLog::RemoveTraceMask((wxString const &)*arg1);
12468 wxPyEndAllowThreads(__tstate);
12469 if (PyErr_Occurred()) SWIG_fail;
12470 }
12471 resultobj = SWIG_Py_Void();
12472 {
12473 if (temp1)
12474 delete arg1;
12475 }
12476 return resultobj;
12477 fail:
12478 {
12479 if (temp1)
12480 delete arg1;
12481 }
12482 return NULL;
12483 }
12484
12485
12486 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12487 PyObject *resultobj = 0;
12488
12489 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12490 {
12491 PyThreadState* __tstate = wxPyBeginAllowThreads();
12492 wxLog::ClearTraceMasks();
12493 wxPyEndAllowThreads(__tstate);
12494 if (PyErr_Occurred()) SWIG_fail;
12495 }
12496 resultobj = SWIG_Py_Void();
12497 return resultobj;
12498 fail:
12499 return NULL;
12500 }
12501
12502
12503 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12504 PyObject *resultobj = 0;
12505 wxArrayString *result = 0 ;
12506
12507 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12508 {
12509 PyThreadState* __tstate = wxPyBeginAllowThreads();
12510 {
12511 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12512 result = (wxArrayString *) &_result_ref;
12513 }
12514 wxPyEndAllowThreads(__tstate);
12515 if (PyErr_Occurred()) SWIG_fail;
12516 }
12517 {
12518 resultobj = wxArrayString2PyList_helper(*result);
12519 }
12520 return resultobj;
12521 fail:
12522 return NULL;
12523 }
12524
12525
12526 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12527 PyObject *resultobj = 0;
12528 wxChar *arg1 = (wxChar *) 0 ;
12529 void *argp1 = 0 ;
12530 int res1 = 0 ;
12531 PyObject * obj0 = 0 ;
12532 char * kwnames[] = {
12533 (char *) "ts", NULL
12534 };
12535
12536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12538 if (!SWIG_IsOK(res1)) {
12539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12540 }
12541 arg1 = reinterpret_cast< wxChar * >(argp1);
12542 {
12543 PyThreadState* __tstate = wxPyBeginAllowThreads();
12544 wxLog::SetTimestamp((wxChar const *)arg1);
12545 wxPyEndAllowThreads(__tstate);
12546 if (PyErr_Occurred()) SWIG_fail;
12547 }
12548 resultobj = SWIG_Py_Void();
12549 return resultobj;
12550 fail:
12551 return NULL;
12552 }
12553
12554
12555 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12556 PyObject *resultobj = 0;
12557 bool result;
12558
12559 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12560 {
12561 PyThreadState* __tstate = wxPyBeginAllowThreads();
12562 result = (bool)wxLog::GetVerbose();
12563 wxPyEndAllowThreads(__tstate);
12564 if (PyErr_Occurred()) SWIG_fail;
12565 }
12566 {
12567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12568 }
12569 return resultobj;
12570 fail:
12571 return NULL;
12572 }
12573
12574
12575 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12576 PyObject *resultobj = 0;
12577 wxTraceMask result;
12578
12579 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12580 {
12581 PyThreadState* __tstate = wxPyBeginAllowThreads();
12582 result = (wxTraceMask)wxLog::GetTraceMask();
12583 wxPyEndAllowThreads(__tstate);
12584 if (PyErr_Occurred()) SWIG_fail;
12585 }
12586 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12587 return resultobj;
12588 fail:
12589 return NULL;
12590 }
12591
12592
12593 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12594 PyObject *resultobj = 0;
12595 wxChar *arg1 = (wxChar *) 0 ;
12596 bool result;
12597 void *argp1 = 0 ;
12598 int res1 = 0 ;
12599 PyObject * obj0 = 0 ;
12600 char * kwnames[] = {
12601 (char *) "mask", NULL
12602 };
12603
12604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12606 if (!SWIG_IsOK(res1)) {
12607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12608 }
12609 arg1 = reinterpret_cast< wxChar * >(argp1);
12610 {
12611 PyThreadState* __tstate = wxPyBeginAllowThreads();
12612 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12613 wxPyEndAllowThreads(__tstate);
12614 if (PyErr_Occurred()) SWIG_fail;
12615 }
12616 {
12617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12618 }
12619 return resultobj;
12620 fail:
12621 return NULL;
12622 }
12623
12624
12625 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12626 PyObject *resultobj = 0;
12627 wxLogLevel result;
12628
12629 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12630 {
12631 PyThreadState* __tstate = wxPyBeginAllowThreads();
12632 result = (wxLogLevel)wxLog::GetLogLevel();
12633 wxPyEndAllowThreads(__tstate);
12634 if (PyErr_Occurred()) SWIG_fail;
12635 }
12636 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12637 return resultobj;
12638 fail:
12639 return NULL;
12640 }
12641
12642
12643 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12644 PyObject *resultobj = 0;
12645 wxChar *result = 0 ;
12646
12647 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12648 {
12649 PyThreadState* __tstate = wxPyBeginAllowThreads();
12650 result = (wxChar *)wxLog::GetTimestamp();
12651 wxPyEndAllowThreads(__tstate);
12652 if (PyErr_Occurred()) SWIG_fail;
12653 }
12654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12655 return resultobj;
12656 fail:
12657 return NULL;
12658 }
12659
12660
12661 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12662 PyObject *resultobj = 0;
12663 wxString result;
12664
12665 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12666 {
12667 PyThreadState* __tstate = wxPyBeginAllowThreads();
12668 result = wxLog_TimeStamp();
12669 wxPyEndAllowThreads(__tstate);
12670 if (PyErr_Occurred()) SWIG_fail;
12671 }
12672 {
12673 #if wxUSE_UNICODE
12674 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12675 #else
12676 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12677 #endif
12678 }
12679 return resultobj;
12680 fail:
12681 return NULL;
12682 }
12683
12684
12685 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12686 PyObject *resultobj = 0;
12687 wxLog *arg1 = (wxLog *) 0 ;
12688 void *argp1 = 0 ;
12689 int res1 = 0 ;
12690 PyObject *swig_obj[1] ;
12691
12692 if (!args) SWIG_fail;
12693 swig_obj[0] = args;
12694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12695 if (!SWIG_IsOK(res1)) {
12696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12697 }
12698 arg1 = reinterpret_cast< wxLog * >(argp1);
12699 {
12700 PyThreadState* __tstate = wxPyBeginAllowThreads();
12701 wxLog_Destroy(arg1);
12702 wxPyEndAllowThreads(__tstate);
12703 if (PyErr_Occurred()) SWIG_fail;
12704 }
12705 resultobj = SWIG_Py_Void();
12706 return resultobj;
12707 fail:
12708 return NULL;
12709 }
12710
12711
12712 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12713 PyObject *obj;
12714 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12715 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12716 return SWIG_Py_Void();
12717 }
12718
12719 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12720 return SWIG_Python_InitShadowInstance(args);
12721 }
12722
12723 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12724 PyObject *resultobj = 0;
12725 wxLogStderr *result = 0 ;
12726
12727 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12728 {
12729 PyThreadState* __tstate = wxPyBeginAllowThreads();
12730 result = (wxLogStderr *)new wxLogStderr();
12731 wxPyEndAllowThreads(__tstate);
12732 if (PyErr_Occurred()) SWIG_fail;
12733 }
12734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12735 return resultobj;
12736 fail:
12737 return NULL;
12738 }
12739
12740
12741 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12742 PyObject *obj;
12743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12744 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12745 return SWIG_Py_Void();
12746 }
12747
12748 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12749 return SWIG_Python_InitShadowInstance(args);
12750 }
12751
12752 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12753 PyObject *resultobj = 0;
12754 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12755 wxLogTextCtrl *result = 0 ;
12756 void *argp1 = 0 ;
12757 int res1 = 0 ;
12758 PyObject * obj0 = 0 ;
12759 char * kwnames[] = {
12760 (char *) "pTextCtrl", NULL
12761 };
12762
12763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12765 if (!SWIG_IsOK(res1)) {
12766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12767 }
12768 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12769 {
12770 PyThreadState* __tstate = wxPyBeginAllowThreads();
12771 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12772 wxPyEndAllowThreads(__tstate);
12773 if (PyErr_Occurred()) SWIG_fail;
12774 }
12775 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12776 return resultobj;
12777 fail:
12778 return NULL;
12779 }
12780
12781
12782 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12783 PyObject *obj;
12784 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12785 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12786 return SWIG_Py_Void();
12787 }
12788
12789 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12790 return SWIG_Python_InitShadowInstance(args);
12791 }
12792
12793 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12794 PyObject *resultobj = 0;
12795 wxLogGui *result = 0 ;
12796
12797 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12798 {
12799 PyThreadState* __tstate = wxPyBeginAllowThreads();
12800 result = (wxLogGui *)new wxLogGui();
12801 wxPyEndAllowThreads(__tstate);
12802 if (PyErr_Occurred()) SWIG_fail;
12803 }
12804 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12805 return resultobj;
12806 fail:
12807 return NULL;
12808 }
12809
12810
12811 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12812 PyObject *obj;
12813 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12814 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12815 return SWIG_Py_Void();
12816 }
12817
12818 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12819 return SWIG_Python_InitShadowInstance(args);
12820 }
12821
12822 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12823 PyObject *resultobj = 0;
12824 wxFrame *arg1 = (wxFrame *) 0 ;
12825 wxString *arg2 = 0 ;
12826 bool arg3 = (bool) true ;
12827 bool arg4 = (bool) true ;
12828 wxLogWindow *result = 0 ;
12829 void *argp1 = 0 ;
12830 int res1 = 0 ;
12831 bool temp2 = false ;
12832 bool val3 ;
12833 int ecode3 = 0 ;
12834 bool val4 ;
12835 int ecode4 = 0 ;
12836 PyObject * obj0 = 0 ;
12837 PyObject * obj1 = 0 ;
12838 PyObject * obj2 = 0 ;
12839 PyObject * obj3 = 0 ;
12840 char * kwnames[] = {
12841 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
12842 };
12843
12844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12846 if (!SWIG_IsOK(res1)) {
12847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
12848 }
12849 arg1 = reinterpret_cast< wxFrame * >(argp1);
12850 {
12851 arg2 = wxString_in_helper(obj1);
12852 if (arg2 == NULL) SWIG_fail;
12853 temp2 = true;
12854 }
12855 if (obj2) {
12856 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12857 if (!SWIG_IsOK(ecode3)) {
12858 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
12859 }
12860 arg3 = static_cast< bool >(val3);
12861 }
12862 if (obj3) {
12863 ecode4 = SWIG_AsVal_bool(obj3, &val4);
12864 if (!SWIG_IsOK(ecode4)) {
12865 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
12866 }
12867 arg4 = static_cast< bool >(val4);
12868 }
12869 {
12870 PyThreadState* __tstate = wxPyBeginAllowThreads();
12871 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
12872 wxPyEndAllowThreads(__tstate);
12873 if (PyErr_Occurred()) SWIG_fail;
12874 }
12875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
12876 {
12877 if (temp2)
12878 delete arg2;
12879 }
12880 return resultobj;
12881 fail:
12882 {
12883 if (temp2)
12884 delete arg2;
12885 }
12886 return NULL;
12887 }
12888
12889
12890 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12891 PyObject *resultobj = 0;
12892 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12893 bool arg2 = (bool) true ;
12894 void *argp1 = 0 ;
12895 int res1 = 0 ;
12896 bool val2 ;
12897 int ecode2 = 0 ;
12898 PyObject * obj0 = 0 ;
12899 PyObject * obj1 = 0 ;
12900 char * kwnames[] = {
12901 (char *) "self",(char *) "bShow", NULL
12902 };
12903
12904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
12905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12906 if (!SWIG_IsOK(res1)) {
12907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
12908 }
12909 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12910 if (obj1) {
12911 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12912 if (!SWIG_IsOK(ecode2)) {
12913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
12914 }
12915 arg2 = static_cast< bool >(val2);
12916 }
12917 {
12918 PyThreadState* __tstate = wxPyBeginAllowThreads();
12919 (arg1)->Show(arg2);
12920 wxPyEndAllowThreads(__tstate);
12921 if (PyErr_Occurred()) SWIG_fail;
12922 }
12923 resultobj = SWIG_Py_Void();
12924 return resultobj;
12925 fail:
12926 return NULL;
12927 }
12928
12929
12930 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12931 PyObject *resultobj = 0;
12932 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12933 wxFrame *result = 0 ;
12934 void *argp1 = 0 ;
12935 int res1 = 0 ;
12936 PyObject *swig_obj[1] ;
12937
12938 if (!args) SWIG_fail;
12939 swig_obj[0] = args;
12940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12941 if (!SWIG_IsOK(res1)) {
12942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12943 }
12944 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12945 {
12946 PyThreadState* __tstate = wxPyBeginAllowThreads();
12947 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
12948 wxPyEndAllowThreads(__tstate);
12949 if (PyErr_Occurred()) SWIG_fail;
12950 }
12951 {
12952 resultobj = wxPyMake_wxObject(result, (bool)0);
12953 }
12954 return resultobj;
12955 fail:
12956 return NULL;
12957 }
12958
12959
12960 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12961 PyObject *resultobj = 0;
12962 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12963 wxLog *result = 0 ;
12964 void *argp1 = 0 ;
12965 int res1 = 0 ;
12966 PyObject *swig_obj[1] ;
12967
12968 if (!args) SWIG_fail;
12969 swig_obj[0] = args;
12970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12971 if (!SWIG_IsOK(res1)) {
12972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12973 }
12974 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12975 {
12976 PyThreadState* __tstate = wxPyBeginAllowThreads();
12977 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
12978 wxPyEndAllowThreads(__tstate);
12979 if (PyErr_Occurred()) SWIG_fail;
12980 }
12981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12982 return resultobj;
12983 fail:
12984 return NULL;
12985 }
12986
12987
12988 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12989 PyObject *resultobj = 0;
12990 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12991 bool result;
12992 void *argp1 = 0 ;
12993 int res1 = 0 ;
12994 PyObject *swig_obj[1] ;
12995
12996 if (!args) SWIG_fail;
12997 swig_obj[0] = args;
12998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12999 if (!SWIG_IsOK(res1)) {
13000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13001 }
13002 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13003 {
13004 PyThreadState* __tstate = wxPyBeginAllowThreads();
13005 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13006 wxPyEndAllowThreads(__tstate);
13007 if (PyErr_Occurred()) SWIG_fail;
13008 }
13009 {
13010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13011 }
13012 return resultobj;
13013 fail:
13014 return NULL;
13015 }
13016
13017
13018 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13019 PyObject *resultobj = 0;
13020 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13021 bool arg2 ;
13022 void *argp1 = 0 ;
13023 int res1 = 0 ;
13024 bool val2 ;
13025 int ecode2 = 0 ;
13026 PyObject * obj0 = 0 ;
13027 PyObject * obj1 = 0 ;
13028 char * kwnames[] = {
13029 (char *) "self",(char *) "bDoPass", NULL
13030 };
13031
13032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13034 if (!SWIG_IsOK(res1)) {
13035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13036 }
13037 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13038 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13039 if (!SWIG_IsOK(ecode2)) {
13040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13041 }
13042 arg2 = static_cast< bool >(val2);
13043 {
13044 PyThreadState* __tstate = wxPyBeginAllowThreads();
13045 (arg1)->PassMessages(arg2);
13046 wxPyEndAllowThreads(__tstate);
13047 if (PyErr_Occurred()) SWIG_fail;
13048 }
13049 resultobj = SWIG_Py_Void();
13050 return resultobj;
13051 fail:
13052 return NULL;
13053 }
13054
13055
13056 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13057 PyObject *obj;
13058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13059 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13060 return SWIG_Py_Void();
13061 }
13062
13063 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13064 return SWIG_Python_InitShadowInstance(args);
13065 }
13066
13067 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13068 PyObject *resultobj = 0;
13069 wxLog *arg1 = (wxLog *) 0 ;
13070 wxLogChain *result = 0 ;
13071 void *argp1 = 0 ;
13072 int res1 = 0 ;
13073 PyObject * obj0 = 0 ;
13074 char * kwnames[] = {
13075 (char *) "logger", NULL
13076 };
13077
13078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13080 if (!SWIG_IsOK(res1)) {
13081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13082 }
13083 arg1 = reinterpret_cast< wxLog * >(argp1);
13084 {
13085 PyThreadState* __tstate = wxPyBeginAllowThreads();
13086 result = (wxLogChain *)new wxLogChain(arg1);
13087 wxPyEndAllowThreads(__tstate);
13088 if (PyErr_Occurred()) SWIG_fail;
13089 }
13090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13091 return resultobj;
13092 fail:
13093 return NULL;
13094 }
13095
13096
13097 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13098 PyObject *resultobj = 0;
13099 wxLogChain *arg1 = (wxLogChain *) 0 ;
13100 wxLog *arg2 = (wxLog *) 0 ;
13101 void *argp1 = 0 ;
13102 int res1 = 0 ;
13103 void *argp2 = 0 ;
13104 int res2 = 0 ;
13105 PyObject * obj0 = 0 ;
13106 PyObject * obj1 = 0 ;
13107 char * kwnames[] = {
13108 (char *) "self",(char *) "logger", NULL
13109 };
13110
13111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13113 if (!SWIG_IsOK(res1)) {
13114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13115 }
13116 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13117 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13118 if (!SWIG_IsOK(res2)) {
13119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13120 }
13121 arg2 = reinterpret_cast< wxLog * >(argp2);
13122 {
13123 PyThreadState* __tstate = wxPyBeginAllowThreads();
13124 (arg1)->SetLog(arg2);
13125 wxPyEndAllowThreads(__tstate);
13126 if (PyErr_Occurred()) SWIG_fail;
13127 }
13128 resultobj = SWIG_Py_Void();
13129 return resultobj;
13130 fail:
13131 return NULL;
13132 }
13133
13134
13135 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13136 PyObject *resultobj = 0;
13137 wxLogChain *arg1 = (wxLogChain *) 0 ;
13138 bool arg2 ;
13139 void *argp1 = 0 ;
13140 int res1 = 0 ;
13141 bool val2 ;
13142 int ecode2 = 0 ;
13143 PyObject * obj0 = 0 ;
13144 PyObject * obj1 = 0 ;
13145 char * kwnames[] = {
13146 (char *) "self",(char *) "bDoPass", NULL
13147 };
13148
13149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13151 if (!SWIG_IsOK(res1)) {
13152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13153 }
13154 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13155 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13156 if (!SWIG_IsOK(ecode2)) {
13157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13158 }
13159 arg2 = static_cast< bool >(val2);
13160 {
13161 PyThreadState* __tstate = wxPyBeginAllowThreads();
13162 (arg1)->PassMessages(arg2);
13163 wxPyEndAllowThreads(__tstate);
13164 if (PyErr_Occurred()) SWIG_fail;
13165 }
13166 resultobj = SWIG_Py_Void();
13167 return resultobj;
13168 fail:
13169 return NULL;
13170 }
13171
13172
13173 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13174 PyObject *resultobj = 0;
13175 wxLogChain *arg1 = (wxLogChain *) 0 ;
13176 bool result;
13177 void *argp1 = 0 ;
13178 int res1 = 0 ;
13179 PyObject *swig_obj[1] ;
13180
13181 if (!args) SWIG_fail;
13182 swig_obj[0] = args;
13183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13184 if (!SWIG_IsOK(res1)) {
13185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13186 }
13187 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13188 {
13189 PyThreadState* __tstate = wxPyBeginAllowThreads();
13190 result = (bool)(arg1)->IsPassingMessages();
13191 wxPyEndAllowThreads(__tstate);
13192 if (PyErr_Occurred()) SWIG_fail;
13193 }
13194 {
13195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13196 }
13197 return resultobj;
13198 fail:
13199 return NULL;
13200 }
13201
13202
13203 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13204 PyObject *resultobj = 0;
13205 wxLogChain *arg1 = (wxLogChain *) 0 ;
13206 wxLog *result = 0 ;
13207 void *argp1 = 0 ;
13208 int res1 = 0 ;
13209 PyObject *swig_obj[1] ;
13210
13211 if (!args) SWIG_fail;
13212 swig_obj[0] = args;
13213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13214 if (!SWIG_IsOK(res1)) {
13215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13216 }
13217 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13218 {
13219 PyThreadState* __tstate = wxPyBeginAllowThreads();
13220 result = (wxLog *)(arg1)->GetOldLog();
13221 wxPyEndAllowThreads(__tstate);
13222 if (PyErr_Occurred()) SWIG_fail;
13223 }
13224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13225 return resultobj;
13226 fail:
13227 return NULL;
13228 }
13229
13230
13231 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13232 PyObject *obj;
13233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13234 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13235 return SWIG_Py_Void();
13236 }
13237
13238 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13239 return SWIG_Python_InitShadowInstance(args);
13240 }
13241
13242 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13243 PyObject *resultobj = 0;
13244 wxLogBuffer *result = 0 ;
13245
13246 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13247 {
13248 PyThreadState* __tstate = wxPyBeginAllowThreads();
13249 result = (wxLogBuffer *)new wxLogBuffer();
13250 wxPyEndAllowThreads(__tstate);
13251 if (PyErr_Occurred()) SWIG_fail;
13252 }
13253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13254 return resultobj;
13255 fail:
13256 return NULL;
13257 }
13258
13259
13260 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13261 PyObject *resultobj = 0;
13262 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13263 wxString *result = 0 ;
13264 void *argp1 = 0 ;
13265 int res1 = 0 ;
13266 PyObject *swig_obj[1] ;
13267
13268 if (!args) SWIG_fail;
13269 swig_obj[0] = args;
13270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13271 if (!SWIG_IsOK(res1)) {
13272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13273 }
13274 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13275 {
13276 PyThreadState* __tstate = wxPyBeginAllowThreads();
13277 {
13278 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13279 result = (wxString *) &_result_ref;
13280 }
13281 wxPyEndAllowThreads(__tstate);
13282 if (PyErr_Occurred()) SWIG_fail;
13283 }
13284 {
13285 #if wxUSE_UNICODE
13286 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13287 #else
13288 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13289 #endif
13290 }
13291 return resultobj;
13292 fail:
13293 return NULL;
13294 }
13295
13296
13297 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13298 PyObject *obj;
13299 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13300 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13301 return SWIG_Py_Void();
13302 }
13303
13304 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13305 return SWIG_Python_InitShadowInstance(args);
13306 }
13307
13308 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13309 PyObject *resultobj = 0;
13310 unsigned long result;
13311
13312 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13313 {
13314 PyThreadState* __tstate = wxPyBeginAllowThreads();
13315 result = (unsigned long)wxSysErrorCode();
13316 wxPyEndAllowThreads(__tstate);
13317 if (PyErr_Occurred()) SWIG_fail;
13318 }
13319 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13320 return resultobj;
13321 fail:
13322 return NULL;
13323 }
13324
13325
13326 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13327 PyObject *resultobj = 0;
13328 unsigned long arg1 = (unsigned long) 0 ;
13329 wxString result;
13330 unsigned long val1 ;
13331 int ecode1 = 0 ;
13332 PyObject * obj0 = 0 ;
13333 char * kwnames[] = {
13334 (char *) "nErrCode", NULL
13335 };
13336
13337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13338 if (obj0) {
13339 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13340 if (!SWIG_IsOK(ecode1)) {
13341 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13342 }
13343 arg1 = static_cast< unsigned long >(val1);
13344 }
13345 {
13346 PyThreadState* __tstate = wxPyBeginAllowThreads();
13347 result = wxSysErrorMsg(arg1);
13348 wxPyEndAllowThreads(__tstate);
13349 if (PyErr_Occurred()) SWIG_fail;
13350 }
13351 {
13352 #if wxUSE_UNICODE
13353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13354 #else
13355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13356 #endif
13357 }
13358 return resultobj;
13359 fail:
13360 return NULL;
13361 }
13362
13363
13364 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13365 PyObject *resultobj = 0;
13366 wxString *arg1 = 0 ;
13367 bool temp1 = false ;
13368 PyObject * obj0 = 0 ;
13369 char * kwnames[] = {
13370 (char *) "msg", NULL
13371 };
13372
13373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13374 {
13375 arg1 = wxString_in_helper(obj0);
13376 if (arg1 == NULL) SWIG_fail;
13377 temp1 = true;
13378 }
13379 {
13380 PyThreadState* __tstate = wxPyBeginAllowThreads();
13381 wxPyLogFatalError((wxString const &)*arg1);
13382 wxPyEndAllowThreads(__tstate);
13383 if (PyErr_Occurred()) SWIG_fail;
13384 }
13385 resultobj = SWIG_Py_Void();
13386 {
13387 if (temp1)
13388 delete arg1;
13389 }
13390 return resultobj;
13391 fail:
13392 {
13393 if (temp1)
13394 delete arg1;
13395 }
13396 return NULL;
13397 }
13398
13399
13400 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13401 PyObject *resultobj = 0;
13402 wxString *arg1 = 0 ;
13403 bool temp1 = false ;
13404 PyObject * obj0 = 0 ;
13405 char * kwnames[] = {
13406 (char *) "msg", NULL
13407 };
13408
13409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13410 {
13411 arg1 = wxString_in_helper(obj0);
13412 if (arg1 == NULL) SWIG_fail;
13413 temp1 = true;
13414 }
13415 {
13416 PyThreadState* __tstate = wxPyBeginAllowThreads();
13417 wxPyLogError((wxString const &)*arg1);
13418 wxPyEndAllowThreads(__tstate);
13419 if (PyErr_Occurred()) SWIG_fail;
13420 }
13421 resultobj = SWIG_Py_Void();
13422 {
13423 if (temp1)
13424 delete arg1;
13425 }
13426 return resultobj;
13427 fail:
13428 {
13429 if (temp1)
13430 delete arg1;
13431 }
13432 return NULL;
13433 }
13434
13435
13436 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13437 PyObject *resultobj = 0;
13438 wxString *arg1 = 0 ;
13439 bool temp1 = false ;
13440 PyObject * obj0 = 0 ;
13441 char * kwnames[] = {
13442 (char *) "msg", NULL
13443 };
13444
13445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13446 {
13447 arg1 = wxString_in_helper(obj0);
13448 if (arg1 == NULL) SWIG_fail;
13449 temp1 = true;
13450 }
13451 {
13452 PyThreadState* __tstate = wxPyBeginAllowThreads();
13453 wxPyLogWarning((wxString const &)*arg1);
13454 wxPyEndAllowThreads(__tstate);
13455 if (PyErr_Occurred()) SWIG_fail;
13456 }
13457 resultobj = SWIG_Py_Void();
13458 {
13459 if (temp1)
13460 delete arg1;
13461 }
13462 return resultobj;
13463 fail:
13464 {
13465 if (temp1)
13466 delete arg1;
13467 }
13468 return NULL;
13469 }
13470
13471
13472 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13473 PyObject *resultobj = 0;
13474 wxString *arg1 = 0 ;
13475 bool temp1 = false ;
13476 PyObject * obj0 = 0 ;
13477 char * kwnames[] = {
13478 (char *) "msg", NULL
13479 };
13480
13481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13482 {
13483 arg1 = wxString_in_helper(obj0);
13484 if (arg1 == NULL) SWIG_fail;
13485 temp1 = true;
13486 }
13487 {
13488 PyThreadState* __tstate = wxPyBeginAllowThreads();
13489 wxPyLogMessage((wxString const &)*arg1);
13490 wxPyEndAllowThreads(__tstate);
13491 if (PyErr_Occurred()) SWIG_fail;
13492 }
13493 resultobj = SWIG_Py_Void();
13494 {
13495 if (temp1)
13496 delete arg1;
13497 }
13498 return resultobj;
13499 fail:
13500 {
13501 if (temp1)
13502 delete arg1;
13503 }
13504 return NULL;
13505 }
13506
13507
13508 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13509 PyObject *resultobj = 0;
13510 wxString *arg1 = 0 ;
13511 bool temp1 = false ;
13512 PyObject * obj0 = 0 ;
13513 char * kwnames[] = {
13514 (char *) "msg", NULL
13515 };
13516
13517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13518 {
13519 arg1 = wxString_in_helper(obj0);
13520 if (arg1 == NULL) SWIG_fail;
13521 temp1 = true;
13522 }
13523 {
13524 PyThreadState* __tstate = wxPyBeginAllowThreads();
13525 wxPyLogInfo((wxString const &)*arg1);
13526 wxPyEndAllowThreads(__tstate);
13527 if (PyErr_Occurred()) SWIG_fail;
13528 }
13529 resultobj = SWIG_Py_Void();
13530 {
13531 if (temp1)
13532 delete arg1;
13533 }
13534 return resultobj;
13535 fail:
13536 {
13537 if (temp1)
13538 delete arg1;
13539 }
13540 return NULL;
13541 }
13542
13543
13544 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13545 PyObject *resultobj = 0;
13546 wxString *arg1 = 0 ;
13547 bool temp1 = false ;
13548 PyObject * obj0 = 0 ;
13549 char * kwnames[] = {
13550 (char *) "msg", NULL
13551 };
13552
13553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13554 {
13555 arg1 = wxString_in_helper(obj0);
13556 if (arg1 == NULL) SWIG_fail;
13557 temp1 = true;
13558 }
13559 {
13560 PyThreadState* __tstate = wxPyBeginAllowThreads();
13561 wxPyLogDebug((wxString const &)*arg1);
13562 wxPyEndAllowThreads(__tstate);
13563 if (PyErr_Occurred()) SWIG_fail;
13564 }
13565 resultobj = SWIG_Py_Void();
13566 {
13567 if (temp1)
13568 delete arg1;
13569 }
13570 return resultobj;
13571 fail:
13572 {
13573 if (temp1)
13574 delete arg1;
13575 }
13576 return NULL;
13577 }
13578
13579
13580 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13581 PyObject *resultobj = 0;
13582 wxString *arg1 = 0 ;
13583 bool temp1 = false ;
13584 PyObject * obj0 = 0 ;
13585 char * kwnames[] = {
13586 (char *) "msg", NULL
13587 };
13588
13589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13590 {
13591 arg1 = wxString_in_helper(obj0);
13592 if (arg1 == NULL) SWIG_fail;
13593 temp1 = true;
13594 }
13595 {
13596 PyThreadState* __tstate = wxPyBeginAllowThreads();
13597 wxPyLogVerbose((wxString const &)*arg1);
13598 wxPyEndAllowThreads(__tstate);
13599 if (PyErr_Occurred()) SWIG_fail;
13600 }
13601 resultobj = SWIG_Py_Void();
13602 {
13603 if (temp1)
13604 delete arg1;
13605 }
13606 return resultobj;
13607 fail:
13608 {
13609 if (temp1)
13610 delete arg1;
13611 }
13612 return NULL;
13613 }
13614
13615
13616 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13617 PyObject *resultobj = 0;
13618 wxString *arg1 = 0 ;
13619 bool temp1 = false ;
13620 PyObject * obj0 = 0 ;
13621 char * kwnames[] = {
13622 (char *) "msg", NULL
13623 };
13624
13625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13626 {
13627 arg1 = wxString_in_helper(obj0);
13628 if (arg1 == NULL) SWIG_fail;
13629 temp1 = true;
13630 }
13631 {
13632 PyThreadState* __tstate = wxPyBeginAllowThreads();
13633 wxPyLogStatus((wxString const &)*arg1);
13634 wxPyEndAllowThreads(__tstate);
13635 if (PyErr_Occurred()) SWIG_fail;
13636 }
13637 resultobj = SWIG_Py_Void();
13638 {
13639 if (temp1)
13640 delete arg1;
13641 }
13642 return resultobj;
13643 fail:
13644 {
13645 if (temp1)
13646 delete arg1;
13647 }
13648 return NULL;
13649 }
13650
13651
13652 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13653 PyObject *resultobj = 0;
13654 wxFrame *arg1 = (wxFrame *) 0 ;
13655 wxString *arg2 = 0 ;
13656 void *argp1 = 0 ;
13657 int res1 = 0 ;
13658 bool temp2 = false ;
13659 PyObject * obj0 = 0 ;
13660 PyObject * obj1 = 0 ;
13661 char * kwnames[] = {
13662 (char *) "pFrame",(char *) "msg", NULL
13663 };
13664
13665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13667 if (!SWIG_IsOK(res1)) {
13668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13669 }
13670 arg1 = reinterpret_cast< wxFrame * >(argp1);
13671 {
13672 arg2 = wxString_in_helper(obj1);
13673 if (arg2 == NULL) SWIG_fail;
13674 temp2 = true;
13675 }
13676 {
13677 PyThreadState* __tstate = wxPyBeginAllowThreads();
13678 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13679 wxPyEndAllowThreads(__tstate);
13680 if (PyErr_Occurred()) SWIG_fail;
13681 }
13682 resultobj = SWIG_Py_Void();
13683 {
13684 if (temp2)
13685 delete arg2;
13686 }
13687 return resultobj;
13688 fail:
13689 {
13690 if (temp2)
13691 delete arg2;
13692 }
13693 return NULL;
13694 }
13695
13696
13697 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13698 PyObject *resultobj = 0;
13699 wxString *arg1 = 0 ;
13700 bool temp1 = false ;
13701 PyObject * obj0 = 0 ;
13702 char * kwnames[] = {
13703 (char *) "msg", NULL
13704 };
13705
13706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13707 {
13708 arg1 = wxString_in_helper(obj0);
13709 if (arg1 == NULL) SWIG_fail;
13710 temp1 = true;
13711 }
13712 {
13713 PyThreadState* __tstate = wxPyBeginAllowThreads();
13714 wxPyLogSysError((wxString const &)*arg1);
13715 wxPyEndAllowThreads(__tstate);
13716 if (PyErr_Occurred()) SWIG_fail;
13717 }
13718 resultobj = SWIG_Py_Void();
13719 {
13720 if (temp1)
13721 delete arg1;
13722 }
13723 return resultobj;
13724 fail:
13725 {
13726 if (temp1)
13727 delete arg1;
13728 }
13729 return NULL;
13730 }
13731
13732
13733 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13734 PyObject *resultobj = 0;
13735 unsigned long arg1 ;
13736 wxString *arg2 = 0 ;
13737 unsigned long val1 ;
13738 int ecode1 = 0 ;
13739 bool temp2 = false ;
13740 PyObject * obj0 = 0 ;
13741 PyObject * obj1 = 0 ;
13742 char * kwnames[] = {
13743 (char *) "level",(char *) "msg", NULL
13744 };
13745
13746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13747 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13748 if (!SWIG_IsOK(ecode1)) {
13749 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13750 }
13751 arg1 = static_cast< unsigned long >(val1);
13752 {
13753 arg2 = wxString_in_helper(obj1);
13754 if (arg2 == NULL) SWIG_fail;
13755 temp2 = true;
13756 }
13757 {
13758 PyThreadState* __tstate = wxPyBeginAllowThreads();
13759 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13760 wxPyEndAllowThreads(__tstate);
13761 if (PyErr_Occurred()) SWIG_fail;
13762 }
13763 resultobj = SWIG_Py_Void();
13764 {
13765 if (temp2)
13766 delete arg2;
13767 }
13768 return resultobj;
13769 fail:
13770 {
13771 if (temp2)
13772 delete arg2;
13773 }
13774 return NULL;
13775 }
13776
13777
13778 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13779 PyObject *resultobj = 0;
13780 unsigned long arg1 ;
13781 wxString *arg2 = 0 ;
13782 unsigned long val1 ;
13783 int ecode1 = 0 ;
13784 bool temp2 = false ;
13785
13786 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13787 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13788 if (!SWIG_IsOK(ecode1)) {
13789 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13790 }
13791 arg1 = static_cast< unsigned long >(val1);
13792 {
13793 arg2 = wxString_in_helper(swig_obj[1]);
13794 if (arg2 == NULL) SWIG_fail;
13795 temp2 = true;
13796 }
13797 {
13798 PyThreadState* __tstate = wxPyBeginAllowThreads();
13799 wxPyLogTrace(arg1,(wxString const &)*arg2);
13800 wxPyEndAllowThreads(__tstate);
13801 if (PyErr_Occurred()) SWIG_fail;
13802 }
13803 resultobj = SWIG_Py_Void();
13804 {
13805 if (temp2)
13806 delete arg2;
13807 }
13808 return resultobj;
13809 fail:
13810 {
13811 if (temp2)
13812 delete arg2;
13813 }
13814 return NULL;
13815 }
13816
13817
13818 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13819 PyObject *resultobj = 0;
13820 wxString *arg1 = 0 ;
13821 wxString *arg2 = 0 ;
13822 bool temp1 = false ;
13823 bool temp2 = false ;
13824
13825 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13826 {
13827 arg1 = wxString_in_helper(swig_obj[0]);
13828 if (arg1 == NULL) SWIG_fail;
13829 temp1 = true;
13830 }
13831 {
13832 arg2 = wxString_in_helper(swig_obj[1]);
13833 if (arg2 == NULL) SWIG_fail;
13834 temp2 = true;
13835 }
13836 {
13837 PyThreadState* __tstate = wxPyBeginAllowThreads();
13838 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
13839 wxPyEndAllowThreads(__tstate);
13840 if (PyErr_Occurred()) SWIG_fail;
13841 }
13842 resultobj = SWIG_Py_Void();
13843 {
13844 if (temp1)
13845 delete arg1;
13846 }
13847 {
13848 if (temp2)
13849 delete arg2;
13850 }
13851 return resultobj;
13852 fail:
13853 {
13854 if (temp1)
13855 delete arg1;
13856 }
13857 {
13858 if (temp2)
13859 delete arg2;
13860 }
13861 return NULL;
13862 }
13863
13864
13865 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
13866 int argc;
13867 PyObject *argv[3];
13868
13869 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
13870 --argc;
13871 if (argc == 2) {
13872 int _v = 0;
13873 {
13874 {
13875 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
13876 }
13877 }
13878 if (!_v) goto check_1;
13879 return _wrap_LogTrace__SWIG_1(self, argc, argv);
13880 }
13881 check_1:
13882
13883 if (argc == 2) {
13884 return _wrap_LogTrace__SWIG_0(self, argc, argv);
13885 }
13886
13887 fail:
13888 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
13889 return NULL;
13890 }
13891
13892
13893 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13894 PyObject *resultobj = 0;
13895 wxString *arg1 = 0 ;
13896 wxString *arg2 = 0 ;
13897 bool temp1 = false ;
13898 bool temp2 = false ;
13899 PyObject * obj0 = 0 ;
13900 PyObject * obj1 = 0 ;
13901 char * kwnames[] = {
13902 (char *) "title",(char *) "text", NULL
13903 };
13904
13905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
13906 {
13907 arg1 = wxString_in_helper(obj0);
13908 if (arg1 == NULL) SWIG_fail;
13909 temp1 = true;
13910 }
13911 {
13912 arg2 = wxString_in_helper(obj1);
13913 if (arg2 == NULL) SWIG_fail;
13914 temp2 = true;
13915 }
13916 {
13917 PyThreadState* __tstate = wxPyBeginAllowThreads();
13918 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
13919 wxPyEndAllowThreads(__tstate);
13920 if (PyErr_Occurred()) SWIG_fail;
13921 }
13922 resultobj = SWIG_Py_Void();
13923 {
13924 if (temp1)
13925 delete arg1;
13926 }
13927 {
13928 if (temp2)
13929 delete arg2;
13930 }
13931 return resultobj;
13932 fail:
13933 {
13934 if (temp1)
13935 delete arg1;
13936 }
13937 {
13938 if (temp2)
13939 delete arg2;
13940 }
13941 return NULL;
13942 }
13943
13944
13945 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13946 PyObject *resultobj = 0;
13947 wxLogNull *result = 0 ;
13948
13949 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
13950 {
13951 PyThreadState* __tstate = wxPyBeginAllowThreads();
13952 result = (wxLogNull *)new wxLogNull();
13953 wxPyEndAllowThreads(__tstate);
13954 if (PyErr_Occurred()) SWIG_fail;
13955 }
13956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
13957 return resultobj;
13958 fail:
13959 return NULL;
13960 }
13961
13962
13963 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13964 PyObject *resultobj = 0;
13965 wxLogNull *arg1 = (wxLogNull *) 0 ;
13966 void *argp1 = 0 ;
13967 int res1 = 0 ;
13968 PyObject *swig_obj[1] ;
13969
13970 if (!args) SWIG_fail;
13971 swig_obj[0] = args;
13972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
13973 if (!SWIG_IsOK(res1)) {
13974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
13975 }
13976 arg1 = reinterpret_cast< wxLogNull * >(argp1);
13977 {
13978 PyThreadState* __tstate = wxPyBeginAllowThreads();
13979 delete arg1;
13980
13981 wxPyEndAllowThreads(__tstate);
13982 if (PyErr_Occurred()) SWIG_fail;
13983 }
13984 resultobj = SWIG_Py_Void();
13985 return resultobj;
13986 fail:
13987 return NULL;
13988 }
13989
13990
13991 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13992 PyObject *obj;
13993 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13994 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
13995 return SWIG_Py_Void();
13996 }
13997
13998 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13999 return SWIG_Python_InitShadowInstance(args);
14000 }
14001
14002 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14003 PyObject *resultobj = 0;
14004 wxPyLog *result = 0 ;
14005
14006 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14007 {
14008 PyThreadState* __tstate = wxPyBeginAllowThreads();
14009 result = (wxPyLog *)new wxPyLog();
14010 wxPyEndAllowThreads(__tstate);
14011 if (PyErr_Occurred()) SWIG_fail;
14012 }
14013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14014 return resultobj;
14015 fail:
14016 return NULL;
14017 }
14018
14019
14020 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14021 PyObject *resultobj = 0;
14022 wxPyLog *arg1 = (wxPyLog *) 0 ;
14023 PyObject *arg2 = (PyObject *) 0 ;
14024 PyObject *arg3 = (PyObject *) 0 ;
14025 void *argp1 = 0 ;
14026 int res1 = 0 ;
14027 PyObject * obj0 = 0 ;
14028 PyObject * obj1 = 0 ;
14029 PyObject * obj2 = 0 ;
14030 char * kwnames[] = {
14031 (char *) "self",(char *) "self",(char *) "_class", NULL
14032 };
14033
14034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14036 if (!SWIG_IsOK(res1)) {
14037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14038 }
14039 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14040 arg2 = obj1;
14041 arg3 = obj2;
14042 {
14043 PyThreadState* __tstate = wxPyBeginAllowThreads();
14044 (arg1)->_setCallbackInfo(arg2,arg3);
14045 wxPyEndAllowThreads(__tstate);
14046 if (PyErr_Occurred()) SWIG_fail;
14047 }
14048 resultobj = SWIG_Py_Void();
14049 return resultobj;
14050 fail:
14051 return NULL;
14052 }
14053
14054
14055 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14056 PyObject *obj;
14057 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14058 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14059 return SWIG_Py_Void();
14060 }
14061
14062 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14063 return SWIG_Python_InitShadowInstance(args);
14064 }
14065
14066 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14067 PyObject *resultobj = 0;
14068 int arg1 ;
14069 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14070 int arg3 = (int) wxKILL_NOCHILDREN ;
14071 wxKillError result;
14072 int val1 ;
14073 int ecode1 = 0 ;
14074 int val2 ;
14075 int ecode2 = 0 ;
14076 int val3 ;
14077 int ecode3 = 0 ;
14078 PyObject * obj0 = 0 ;
14079 PyObject * obj1 = 0 ;
14080 PyObject * obj2 = 0 ;
14081 char * kwnames[] = {
14082 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14083 };
14084
14085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14086 ecode1 = SWIG_AsVal_int(obj0, &val1);
14087 if (!SWIG_IsOK(ecode1)) {
14088 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14089 }
14090 arg1 = static_cast< int >(val1);
14091 if (obj1) {
14092 ecode2 = SWIG_AsVal_int(obj1, &val2);
14093 if (!SWIG_IsOK(ecode2)) {
14094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14095 }
14096 arg2 = static_cast< wxSignal >(val2);
14097 }
14098 if (obj2) {
14099 ecode3 = SWIG_AsVal_int(obj2, &val3);
14100 if (!SWIG_IsOK(ecode3)) {
14101 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14102 }
14103 arg3 = static_cast< int >(val3);
14104 }
14105 {
14106 PyThreadState* __tstate = wxPyBeginAllowThreads();
14107 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14108 wxPyEndAllowThreads(__tstate);
14109 if (PyErr_Occurred()) SWIG_fail;
14110 }
14111 resultobj = SWIG_From_int(static_cast< int >(result));
14112 return resultobj;
14113 fail:
14114 return NULL;
14115 }
14116
14117
14118 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14119 PyObject *resultobj = 0;
14120 int arg1 ;
14121 bool result;
14122 int val1 ;
14123 int ecode1 = 0 ;
14124 PyObject * obj0 = 0 ;
14125 char * kwnames[] = {
14126 (char *) "pid", NULL
14127 };
14128
14129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14130 ecode1 = SWIG_AsVal_int(obj0, &val1);
14131 if (!SWIG_IsOK(ecode1)) {
14132 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14133 }
14134 arg1 = static_cast< int >(val1);
14135 {
14136 PyThreadState* __tstate = wxPyBeginAllowThreads();
14137 result = (bool)wxPyProcess::Exists(arg1);
14138 wxPyEndAllowThreads(__tstate);
14139 if (PyErr_Occurred()) SWIG_fail;
14140 }
14141 {
14142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14143 }
14144 return resultobj;
14145 fail:
14146 return NULL;
14147 }
14148
14149
14150 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14151 PyObject *resultobj = 0;
14152 wxString *arg1 = 0 ;
14153 int arg2 = (int) wxEXEC_ASYNC ;
14154 wxPyProcess *result = 0 ;
14155 bool temp1 = false ;
14156 int val2 ;
14157 int ecode2 = 0 ;
14158 PyObject * obj0 = 0 ;
14159 PyObject * obj1 = 0 ;
14160 char * kwnames[] = {
14161 (char *) "cmd",(char *) "flags", NULL
14162 };
14163
14164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14165 {
14166 arg1 = wxString_in_helper(obj0);
14167 if (arg1 == NULL) SWIG_fail;
14168 temp1 = true;
14169 }
14170 if (obj1) {
14171 ecode2 = SWIG_AsVal_int(obj1, &val2);
14172 if (!SWIG_IsOK(ecode2)) {
14173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14174 }
14175 arg2 = static_cast< int >(val2);
14176 }
14177 {
14178 PyThreadState* __tstate = wxPyBeginAllowThreads();
14179 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14180 wxPyEndAllowThreads(__tstate);
14181 if (PyErr_Occurred()) SWIG_fail;
14182 }
14183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14184 {
14185 if (temp1)
14186 delete arg1;
14187 }
14188 return resultobj;
14189 fail:
14190 {
14191 if (temp1)
14192 delete arg1;
14193 }
14194 return NULL;
14195 }
14196
14197
14198 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14199 PyObject *resultobj = 0;
14200 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14201 int arg2 = (int) -1 ;
14202 wxPyProcess *result = 0 ;
14203 void *argp1 = 0 ;
14204 int res1 = 0 ;
14205 int val2 ;
14206 int ecode2 = 0 ;
14207 PyObject * obj0 = 0 ;
14208 PyObject * obj1 = 0 ;
14209 char * kwnames[] = {
14210 (char *) "parent",(char *) "id", NULL
14211 };
14212
14213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14214 if (obj0) {
14215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14216 if (!SWIG_IsOK(res1)) {
14217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14218 }
14219 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14220 }
14221 if (obj1) {
14222 ecode2 = SWIG_AsVal_int(obj1, &val2);
14223 if (!SWIG_IsOK(ecode2)) {
14224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14225 }
14226 arg2 = static_cast< int >(val2);
14227 }
14228 {
14229 PyThreadState* __tstate = wxPyBeginAllowThreads();
14230 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14231 wxPyEndAllowThreads(__tstate);
14232 if (PyErr_Occurred()) SWIG_fail;
14233 }
14234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14235 return resultobj;
14236 fail:
14237 return NULL;
14238 }
14239
14240
14241 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14242 PyObject *resultobj = 0;
14243 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14244 PyObject *arg2 = (PyObject *) 0 ;
14245 PyObject *arg3 = (PyObject *) 0 ;
14246 void *argp1 = 0 ;
14247 int res1 = 0 ;
14248 PyObject * obj0 = 0 ;
14249 PyObject * obj1 = 0 ;
14250 PyObject * obj2 = 0 ;
14251 char * kwnames[] = {
14252 (char *) "self",(char *) "self",(char *) "_class", NULL
14253 };
14254
14255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14257 if (!SWIG_IsOK(res1)) {
14258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14259 }
14260 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14261 arg2 = obj1;
14262 arg3 = obj2;
14263 {
14264 PyThreadState* __tstate = wxPyBeginAllowThreads();
14265 (arg1)->_setCallbackInfo(arg2,arg3);
14266 wxPyEndAllowThreads(__tstate);
14267 if (PyErr_Occurred()) SWIG_fail;
14268 }
14269 resultobj = SWIG_Py_Void();
14270 return resultobj;
14271 fail:
14272 return NULL;
14273 }
14274
14275
14276 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14277 PyObject *resultobj = 0;
14278 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14279 int arg2 ;
14280 int arg3 ;
14281 void *argp1 = 0 ;
14282 int res1 = 0 ;
14283 int val2 ;
14284 int ecode2 = 0 ;
14285 int val3 ;
14286 int ecode3 = 0 ;
14287 PyObject * obj0 = 0 ;
14288 PyObject * obj1 = 0 ;
14289 PyObject * obj2 = 0 ;
14290 char * kwnames[] = {
14291 (char *) "self",(char *) "pid",(char *) "status", NULL
14292 };
14293
14294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14296 if (!SWIG_IsOK(res1)) {
14297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14298 }
14299 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14300 ecode2 = SWIG_AsVal_int(obj1, &val2);
14301 if (!SWIG_IsOK(ecode2)) {
14302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14303 }
14304 arg2 = static_cast< int >(val2);
14305 ecode3 = SWIG_AsVal_int(obj2, &val3);
14306 if (!SWIG_IsOK(ecode3)) {
14307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14308 }
14309 arg3 = static_cast< int >(val3);
14310 {
14311 PyThreadState* __tstate = wxPyBeginAllowThreads();
14312 (arg1)->OnTerminate(arg2,arg3);
14313 wxPyEndAllowThreads(__tstate);
14314 if (PyErr_Occurred()) SWIG_fail;
14315 }
14316 resultobj = SWIG_Py_Void();
14317 return resultobj;
14318 fail:
14319 return NULL;
14320 }
14321
14322
14323 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14324 PyObject *resultobj = 0;
14325 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14326 void *argp1 = 0 ;
14327 int res1 = 0 ;
14328 PyObject *swig_obj[1] ;
14329
14330 if (!args) SWIG_fail;
14331 swig_obj[0] = args;
14332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14333 if (!SWIG_IsOK(res1)) {
14334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14335 }
14336 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14337 {
14338 PyThreadState* __tstate = wxPyBeginAllowThreads();
14339 (arg1)->Redirect();
14340 wxPyEndAllowThreads(__tstate);
14341 if (PyErr_Occurred()) SWIG_fail;
14342 }
14343 resultobj = SWIG_Py_Void();
14344 return resultobj;
14345 fail:
14346 return NULL;
14347 }
14348
14349
14350 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14351 PyObject *resultobj = 0;
14352 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14353 bool result;
14354 void *argp1 = 0 ;
14355 int res1 = 0 ;
14356 PyObject *swig_obj[1] ;
14357
14358 if (!args) SWIG_fail;
14359 swig_obj[0] = args;
14360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14361 if (!SWIG_IsOK(res1)) {
14362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14363 }
14364 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14365 {
14366 PyThreadState* __tstate = wxPyBeginAllowThreads();
14367 result = (bool)(arg1)->IsRedirected();
14368 wxPyEndAllowThreads(__tstate);
14369 if (PyErr_Occurred()) SWIG_fail;
14370 }
14371 {
14372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14373 }
14374 return resultobj;
14375 fail:
14376 return NULL;
14377 }
14378
14379
14380 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14381 PyObject *resultobj = 0;
14382 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14383 void *argp1 = 0 ;
14384 int res1 = 0 ;
14385 PyObject *swig_obj[1] ;
14386
14387 if (!args) SWIG_fail;
14388 swig_obj[0] = args;
14389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14390 if (!SWIG_IsOK(res1)) {
14391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14392 }
14393 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14394 {
14395 PyThreadState* __tstate = wxPyBeginAllowThreads();
14396 (arg1)->Detach();
14397 wxPyEndAllowThreads(__tstate);
14398 if (PyErr_Occurred()) SWIG_fail;
14399 }
14400 resultobj = SWIG_Py_Void();
14401 return resultobj;
14402 fail:
14403 return NULL;
14404 }
14405
14406
14407 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14408 PyObject *resultobj = 0;
14409 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14410 wxInputStream *result = 0 ;
14411 void *argp1 = 0 ;
14412 int res1 = 0 ;
14413 PyObject *swig_obj[1] ;
14414
14415 if (!args) SWIG_fail;
14416 swig_obj[0] = args;
14417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14418 if (!SWIG_IsOK(res1)) {
14419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14420 }
14421 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14422 {
14423 PyThreadState* __tstate = wxPyBeginAllowThreads();
14424 result = (wxInputStream *)(arg1)->GetInputStream();
14425 wxPyEndAllowThreads(__tstate);
14426 if (PyErr_Occurred()) SWIG_fail;
14427 }
14428 {
14429 wxPyInputStream * _ptr = NULL;
14430
14431 if (result) {
14432 _ptr = new wxPyInputStream(result);
14433 }
14434 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14435 }
14436 return resultobj;
14437 fail:
14438 return NULL;
14439 }
14440
14441
14442 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14443 PyObject *resultobj = 0;
14444 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14445 wxInputStream *result = 0 ;
14446 void *argp1 = 0 ;
14447 int res1 = 0 ;
14448 PyObject *swig_obj[1] ;
14449
14450 if (!args) SWIG_fail;
14451 swig_obj[0] = args;
14452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14453 if (!SWIG_IsOK(res1)) {
14454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14455 }
14456 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14457 {
14458 PyThreadState* __tstate = wxPyBeginAllowThreads();
14459 result = (wxInputStream *)(arg1)->GetErrorStream();
14460 wxPyEndAllowThreads(__tstate);
14461 if (PyErr_Occurred()) SWIG_fail;
14462 }
14463 {
14464 wxPyInputStream * _ptr = NULL;
14465
14466 if (result) {
14467 _ptr = new wxPyInputStream(result);
14468 }
14469 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14470 }
14471 return resultobj;
14472 fail:
14473 return NULL;
14474 }
14475
14476
14477 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14478 PyObject *resultobj = 0;
14479 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14480 wxOutputStream *result = 0 ;
14481 void *argp1 = 0 ;
14482 int res1 = 0 ;
14483 PyObject *swig_obj[1] ;
14484
14485 if (!args) SWIG_fail;
14486 swig_obj[0] = args;
14487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14488 if (!SWIG_IsOK(res1)) {
14489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14490 }
14491 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14492 {
14493 PyThreadState* __tstate = wxPyBeginAllowThreads();
14494 result = (wxOutputStream *)(arg1)->GetOutputStream();
14495 wxPyEndAllowThreads(__tstate);
14496 if (PyErr_Occurred()) SWIG_fail;
14497 }
14498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14499 return resultobj;
14500 fail:
14501 return NULL;
14502 }
14503
14504
14505 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14506 PyObject *resultobj = 0;
14507 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14508 void *argp1 = 0 ;
14509 int res1 = 0 ;
14510 PyObject *swig_obj[1] ;
14511
14512 if (!args) SWIG_fail;
14513 swig_obj[0] = args;
14514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14515 if (!SWIG_IsOK(res1)) {
14516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14517 }
14518 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14519 {
14520 PyThreadState* __tstate = wxPyBeginAllowThreads();
14521 (arg1)->CloseOutput();
14522 wxPyEndAllowThreads(__tstate);
14523 if (PyErr_Occurred()) SWIG_fail;
14524 }
14525 resultobj = SWIG_Py_Void();
14526 return resultobj;
14527 fail:
14528 return NULL;
14529 }
14530
14531
14532 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14533 PyObject *resultobj = 0;
14534 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14535 bool result;
14536 void *argp1 = 0 ;
14537 int res1 = 0 ;
14538 PyObject *swig_obj[1] ;
14539
14540 if (!args) SWIG_fail;
14541 swig_obj[0] = args;
14542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14543 if (!SWIG_IsOK(res1)) {
14544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14545 }
14546 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14547 {
14548 PyThreadState* __tstate = wxPyBeginAllowThreads();
14549 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14550 wxPyEndAllowThreads(__tstate);
14551 if (PyErr_Occurred()) SWIG_fail;
14552 }
14553 {
14554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14555 }
14556 return resultobj;
14557 fail:
14558 return NULL;
14559 }
14560
14561
14562 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14563 PyObject *resultobj = 0;
14564 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14565 bool result;
14566 void *argp1 = 0 ;
14567 int res1 = 0 ;
14568 PyObject *swig_obj[1] ;
14569
14570 if (!args) SWIG_fail;
14571 swig_obj[0] = args;
14572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14573 if (!SWIG_IsOK(res1)) {
14574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14575 }
14576 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14577 {
14578 PyThreadState* __tstate = wxPyBeginAllowThreads();
14579 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14580 wxPyEndAllowThreads(__tstate);
14581 if (PyErr_Occurred()) SWIG_fail;
14582 }
14583 {
14584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14585 }
14586 return resultobj;
14587 fail:
14588 return NULL;
14589 }
14590
14591
14592 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14593 PyObject *resultobj = 0;
14594 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14595 bool result;
14596 void *argp1 = 0 ;
14597 int res1 = 0 ;
14598 PyObject *swig_obj[1] ;
14599
14600 if (!args) SWIG_fail;
14601 swig_obj[0] = args;
14602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14603 if (!SWIG_IsOK(res1)) {
14604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14605 }
14606 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14607 {
14608 PyThreadState* __tstate = wxPyBeginAllowThreads();
14609 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14610 wxPyEndAllowThreads(__tstate);
14611 if (PyErr_Occurred()) SWIG_fail;
14612 }
14613 {
14614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14615 }
14616 return resultobj;
14617 fail:
14618 return NULL;
14619 }
14620
14621
14622 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14623 PyObject *obj;
14624 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14625 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14626 return SWIG_Py_Void();
14627 }
14628
14629 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14630 return SWIG_Python_InitShadowInstance(args);
14631 }
14632
14633 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14634 PyObject *resultobj = 0;
14635 int arg1 = (int) 0 ;
14636 int arg2 = (int) 0 ;
14637 int arg3 = (int) 0 ;
14638 wxProcessEvent *result = 0 ;
14639 int val1 ;
14640 int ecode1 = 0 ;
14641 int val2 ;
14642 int ecode2 = 0 ;
14643 int val3 ;
14644 int ecode3 = 0 ;
14645 PyObject * obj0 = 0 ;
14646 PyObject * obj1 = 0 ;
14647 PyObject * obj2 = 0 ;
14648 char * kwnames[] = {
14649 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14650 };
14651
14652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14653 if (obj0) {
14654 ecode1 = SWIG_AsVal_int(obj0, &val1);
14655 if (!SWIG_IsOK(ecode1)) {
14656 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14657 }
14658 arg1 = static_cast< int >(val1);
14659 }
14660 if (obj1) {
14661 ecode2 = SWIG_AsVal_int(obj1, &val2);
14662 if (!SWIG_IsOK(ecode2)) {
14663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14664 }
14665 arg2 = static_cast< int >(val2);
14666 }
14667 if (obj2) {
14668 ecode3 = SWIG_AsVal_int(obj2, &val3);
14669 if (!SWIG_IsOK(ecode3)) {
14670 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14671 }
14672 arg3 = static_cast< int >(val3);
14673 }
14674 {
14675 PyThreadState* __tstate = wxPyBeginAllowThreads();
14676 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14677 wxPyEndAllowThreads(__tstate);
14678 if (PyErr_Occurred()) SWIG_fail;
14679 }
14680 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14681 return resultobj;
14682 fail:
14683 return NULL;
14684 }
14685
14686
14687 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14688 PyObject *resultobj = 0;
14689 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14690 int result;
14691 void *argp1 = 0 ;
14692 int res1 = 0 ;
14693 PyObject *swig_obj[1] ;
14694
14695 if (!args) SWIG_fail;
14696 swig_obj[0] = args;
14697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14698 if (!SWIG_IsOK(res1)) {
14699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14700 }
14701 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14702 {
14703 PyThreadState* __tstate = wxPyBeginAllowThreads();
14704 result = (int)(arg1)->GetPid();
14705 wxPyEndAllowThreads(__tstate);
14706 if (PyErr_Occurred()) SWIG_fail;
14707 }
14708 resultobj = SWIG_From_int(static_cast< int >(result));
14709 return resultobj;
14710 fail:
14711 return NULL;
14712 }
14713
14714
14715 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14716 PyObject *resultobj = 0;
14717 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14718 int result;
14719 void *argp1 = 0 ;
14720 int res1 = 0 ;
14721 PyObject *swig_obj[1] ;
14722
14723 if (!args) SWIG_fail;
14724 swig_obj[0] = args;
14725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14726 if (!SWIG_IsOK(res1)) {
14727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14728 }
14729 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14730 {
14731 PyThreadState* __tstate = wxPyBeginAllowThreads();
14732 result = (int)(arg1)->GetExitCode();
14733 wxPyEndAllowThreads(__tstate);
14734 if (PyErr_Occurred()) SWIG_fail;
14735 }
14736 resultobj = SWIG_From_int(static_cast< int >(result));
14737 return resultobj;
14738 fail:
14739 return NULL;
14740 }
14741
14742
14743 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14744 PyObject *resultobj = 0;
14745 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14746 int arg2 ;
14747 void *argp1 = 0 ;
14748 int res1 = 0 ;
14749 int val2 ;
14750 int ecode2 = 0 ;
14751 PyObject *swig_obj[2] ;
14752
14753 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14755 if (!SWIG_IsOK(res1)) {
14756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14757 }
14758 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14759 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14760 if (!SWIG_IsOK(ecode2)) {
14761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
14762 }
14763 arg2 = static_cast< int >(val2);
14764 if (arg1) (arg1)->m_pid = arg2;
14765
14766 resultobj = SWIG_Py_Void();
14767 return resultobj;
14768 fail:
14769 return NULL;
14770 }
14771
14772
14773 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14774 PyObject *resultobj = 0;
14775 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14776 int result;
14777 void *argp1 = 0 ;
14778 int res1 = 0 ;
14779 PyObject *swig_obj[1] ;
14780
14781 if (!args) SWIG_fail;
14782 swig_obj[0] = args;
14783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14784 if (!SWIG_IsOK(res1)) {
14785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14786 }
14787 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14788 result = (int) ((arg1)->m_pid);
14789 resultobj = SWIG_From_int(static_cast< int >(result));
14790 return resultobj;
14791 fail:
14792 return NULL;
14793 }
14794
14795
14796 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14797 PyObject *resultobj = 0;
14798 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14799 int arg2 ;
14800 void *argp1 = 0 ;
14801 int res1 = 0 ;
14802 int val2 ;
14803 int ecode2 = 0 ;
14804 PyObject *swig_obj[2] ;
14805
14806 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
14807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14808 if (!SWIG_IsOK(res1)) {
14809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14810 }
14811 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14812 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14813 if (!SWIG_IsOK(ecode2)) {
14814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
14815 }
14816 arg2 = static_cast< int >(val2);
14817 if (arg1) (arg1)->m_exitcode = arg2;
14818
14819 resultobj = SWIG_Py_Void();
14820 return resultobj;
14821 fail:
14822 return NULL;
14823 }
14824
14825
14826 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14827 PyObject *resultobj = 0;
14828 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14829 int result;
14830 void *argp1 = 0 ;
14831 int res1 = 0 ;
14832 PyObject *swig_obj[1] ;
14833
14834 if (!args) SWIG_fail;
14835 swig_obj[0] = args;
14836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14837 if (!SWIG_IsOK(res1)) {
14838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14839 }
14840 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14841 result = (int) ((arg1)->m_exitcode);
14842 resultobj = SWIG_From_int(static_cast< int >(result));
14843 return resultobj;
14844 fail:
14845 return NULL;
14846 }
14847
14848
14849 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14850 PyObject *obj;
14851 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14852 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
14853 return SWIG_Py_Void();
14854 }
14855
14856 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14857 return SWIG_Python_InitShadowInstance(args);
14858 }
14859
14860 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14861 PyObject *resultobj = 0;
14862 wxString *arg1 = 0 ;
14863 int arg2 = (int) wxEXEC_ASYNC ;
14864 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
14865 long result;
14866 bool temp1 = false ;
14867 int val2 ;
14868 int ecode2 = 0 ;
14869 void *argp3 = 0 ;
14870 int res3 = 0 ;
14871 PyObject * obj0 = 0 ;
14872 PyObject * obj1 = 0 ;
14873 PyObject * obj2 = 0 ;
14874 char * kwnames[] = {
14875 (char *) "command",(char *) "flags",(char *) "process", NULL
14876 };
14877
14878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14879 {
14880 arg1 = wxString_in_helper(obj0);
14881 if (arg1 == NULL) SWIG_fail;
14882 temp1 = true;
14883 }
14884 if (obj1) {
14885 ecode2 = SWIG_AsVal_int(obj1, &val2);
14886 if (!SWIG_IsOK(ecode2)) {
14887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
14888 }
14889 arg2 = static_cast< int >(val2);
14890 }
14891 if (obj2) {
14892 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14893 if (!SWIG_IsOK(res3)) {
14894 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
14895 }
14896 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
14897 }
14898 {
14899 if (!wxPyCheckForApp()) SWIG_fail;
14900 PyThreadState* __tstate = wxPyBeginAllowThreads();
14901 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
14902 wxPyEndAllowThreads(__tstate);
14903 if (PyErr_Occurred()) SWIG_fail;
14904 }
14905 resultobj = SWIG_From_long(static_cast< long >(result));
14906 {
14907 if (temp1)
14908 delete arg1;
14909 }
14910 return resultobj;
14911 fail:
14912 {
14913 if (temp1)
14914 delete arg1;
14915 }
14916 return NULL;
14917 }
14918
14919
14920 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14921 PyObject *resultobj = 0;
14922 long arg1 ;
14923 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14924 wxKillError *arg3 = (wxKillError *) 0 ;
14925 int arg4 = (int) wxKILL_NOCHILDREN ;
14926 int result;
14927 long val1 ;
14928 int ecode1 = 0 ;
14929 int val2 ;
14930 int ecode2 = 0 ;
14931 wxKillError temp3 ;
14932 int val4 ;
14933 int ecode4 = 0 ;
14934 PyObject * obj0 = 0 ;
14935 PyObject * obj1 = 0 ;
14936 PyObject * obj2 = 0 ;
14937 char * kwnames[] = {
14938 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14939 };
14940
14941 {
14942 arg3 = &temp3;
14943 }
14944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14945 ecode1 = SWIG_AsVal_long(obj0, &val1);
14946 if (!SWIG_IsOK(ecode1)) {
14947 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
14948 }
14949 arg1 = static_cast< long >(val1);
14950 if (obj1) {
14951 ecode2 = SWIG_AsVal_int(obj1, &val2);
14952 if (!SWIG_IsOK(ecode2)) {
14953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14954 }
14955 arg2 = static_cast< wxSignal >(val2);
14956 }
14957 if (obj2) {
14958 ecode4 = SWIG_AsVal_int(obj2, &val4);
14959 if (!SWIG_IsOK(ecode4)) {
14960 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
14961 }
14962 arg4 = static_cast< int >(val4);
14963 }
14964 {
14965 PyThreadState* __tstate = wxPyBeginAllowThreads();
14966 result = (int)wxKill(arg1,arg2,arg3,arg4);
14967 wxPyEndAllowThreads(__tstate);
14968 if (PyErr_Occurred()) SWIG_fail;
14969 }
14970 resultobj = SWIG_From_int(static_cast< int >(result));
14971 {
14972 PyObject* o;
14973 o = PyInt_FromLong((long) (*arg3));
14974
14975
14976
14977 resultobj = SWIG_Python_AppendOutput(resultobj, o);
14978
14979 }
14980 return resultobj;
14981 fail:
14982 return NULL;
14983 }
14984
14985
14986 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14987 PyObject *resultobj = 0;
14988 int arg1 = (int) wxJOYSTICK1 ;
14989 wxJoystick *result = 0 ;
14990 int val1 ;
14991 int ecode1 = 0 ;
14992 PyObject * obj0 = 0 ;
14993 char * kwnames[] = {
14994 (char *) "joystick", NULL
14995 };
14996
14997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
14998 if (obj0) {
14999 ecode1 = SWIG_AsVal_int(obj0, &val1);
15000 if (!SWIG_IsOK(ecode1)) {
15001 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15002 }
15003 arg1 = static_cast< int >(val1);
15004 }
15005 {
15006 if (!wxPyCheckForApp()) SWIG_fail;
15007 PyThreadState* __tstate = wxPyBeginAllowThreads();
15008 result = (wxJoystick *)new wxJoystick(arg1);
15009 wxPyEndAllowThreads(__tstate);
15010 if (PyErr_Occurred()) SWIG_fail;
15011 }
15012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15013 return resultobj;
15014 fail:
15015 return NULL;
15016 }
15017
15018
15019 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15020 PyObject *resultobj = 0;
15021 wxJoystick *arg1 = (wxJoystick *) 0 ;
15022 void *argp1 = 0 ;
15023 int res1 = 0 ;
15024 PyObject *swig_obj[1] ;
15025
15026 if (!args) SWIG_fail;
15027 swig_obj[0] = args;
15028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15029 if (!SWIG_IsOK(res1)) {
15030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15031 }
15032 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15033 {
15034 PyThreadState* __tstate = wxPyBeginAllowThreads();
15035 delete arg1;
15036
15037 wxPyEndAllowThreads(__tstate);
15038 if (PyErr_Occurred()) SWIG_fail;
15039 }
15040 resultobj = SWIG_Py_Void();
15041 return resultobj;
15042 fail:
15043 return NULL;
15044 }
15045
15046
15047 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15048 PyObject *resultobj = 0;
15049 wxJoystick *arg1 = (wxJoystick *) 0 ;
15050 wxPoint result;
15051 void *argp1 = 0 ;
15052 int res1 = 0 ;
15053 PyObject *swig_obj[1] ;
15054
15055 if (!args) SWIG_fail;
15056 swig_obj[0] = args;
15057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15058 if (!SWIG_IsOK(res1)) {
15059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15060 }
15061 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15062 {
15063 PyThreadState* __tstate = wxPyBeginAllowThreads();
15064 result = (arg1)->GetPosition();
15065 wxPyEndAllowThreads(__tstate);
15066 if (PyErr_Occurred()) SWIG_fail;
15067 }
15068 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15069 return resultobj;
15070 fail:
15071 return NULL;
15072 }
15073
15074
15075 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15076 PyObject *resultobj = 0;
15077 wxJoystick *arg1 = (wxJoystick *) 0 ;
15078 int result;
15079 void *argp1 = 0 ;
15080 int res1 = 0 ;
15081 PyObject *swig_obj[1] ;
15082
15083 if (!args) SWIG_fail;
15084 swig_obj[0] = args;
15085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15086 if (!SWIG_IsOK(res1)) {
15087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15088 }
15089 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15090 {
15091 PyThreadState* __tstate = wxPyBeginAllowThreads();
15092 result = (int)(arg1)->GetZPosition();
15093 wxPyEndAllowThreads(__tstate);
15094 if (PyErr_Occurred()) SWIG_fail;
15095 }
15096 resultobj = SWIG_From_int(static_cast< int >(result));
15097 return resultobj;
15098 fail:
15099 return NULL;
15100 }
15101
15102
15103 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15104 PyObject *resultobj = 0;
15105 wxJoystick *arg1 = (wxJoystick *) 0 ;
15106 int result;
15107 void *argp1 = 0 ;
15108 int res1 = 0 ;
15109 PyObject *swig_obj[1] ;
15110
15111 if (!args) SWIG_fail;
15112 swig_obj[0] = args;
15113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15114 if (!SWIG_IsOK(res1)) {
15115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15116 }
15117 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15118 {
15119 PyThreadState* __tstate = wxPyBeginAllowThreads();
15120 result = (int)(arg1)->GetButtonState();
15121 wxPyEndAllowThreads(__tstate);
15122 if (PyErr_Occurred()) SWIG_fail;
15123 }
15124 resultobj = SWIG_From_int(static_cast< int >(result));
15125 return resultobj;
15126 fail:
15127 return NULL;
15128 }
15129
15130
15131 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15132 PyObject *resultobj = 0;
15133 wxJoystick *arg1 = (wxJoystick *) 0 ;
15134 int result;
15135 void *argp1 = 0 ;
15136 int res1 = 0 ;
15137 PyObject *swig_obj[1] ;
15138
15139 if (!args) SWIG_fail;
15140 swig_obj[0] = args;
15141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15142 if (!SWIG_IsOK(res1)) {
15143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15144 }
15145 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15146 {
15147 PyThreadState* __tstate = wxPyBeginAllowThreads();
15148 result = (int)(arg1)->GetPOVPosition();
15149 wxPyEndAllowThreads(__tstate);
15150 if (PyErr_Occurred()) SWIG_fail;
15151 }
15152 resultobj = SWIG_From_int(static_cast< int >(result));
15153 return resultobj;
15154 fail:
15155 return NULL;
15156 }
15157
15158
15159 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15160 PyObject *resultobj = 0;
15161 wxJoystick *arg1 = (wxJoystick *) 0 ;
15162 int result;
15163 void *argp1 = 0 ;
15164 int res1 = 0 ;
15165 PyObject *swig_obj[1] ;
15166
15167 if (!args) SWIG_fail;
15168 swig_obj[0] = args;
15169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15170 if (!SWIG_IsOK(res1)) {
15171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15172 }
15173 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15174 {
15175 PyThreadState* __tstate = wxPyBeginAllowThreads();
15176 result = (int)(arg1)->GetPOVCTSPosition();
15177 wxPyEndAllowThreads(__tstate);
15178 if (PyErr_Occurred()) SWIG_fail;
15179 }
15180 resultobj = SWIG_From_int(static_cast< int >(result));
15181 return resultobj;
15182 fail:
15183 return NULL;
15184 }
15185
15186
15187 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15188 PyObject *resultobj = 0;
15189 wxJoystick *arg1 = (wxJoystick *) 0 ;
15190 int result;
15191 void *argp1 = 0 ;
15192 int res1 = 0 ;
15193 PyObject *swig_obj[1] ;
15194
15195 if (!args) SWIG_fail;
15196 swig_obj[0] = args;
15197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15198 if (!SWIG_IsOK(res1)) {
15199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15200 }
15201 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15202 {
15203 PyThreadState* __tstate = wxPyBeginAllowThreads();
15204 result = (int)(arg1)->GetRudderPosition();
15205 wxPyEndAllowThreads(__tstate);
15206 if (PyErr_Occurred()) SWIG_fail;
15207 }
15208 resultobj = SWIG_From_int(static_cast< int >(result));
15209 return resultobj;
15210 fail:
15211 return NULL;
15212 }
15213
15214
15215 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15216 PyObject *resultobj = 0;
15217 wxJoystick *arg1 = (wxJoystick *) 0 ;
15218 int result;
15219 void *argp1 = 0 ;
15220 int res1 = 0 ;
15221 PyObject *swig_obj[1] ;
15222
15223 if (!args) SWIG_fail;
15224 swig_obj[0] = args;
15225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15226 if (!SWIG_IsOK(res1)) {
15227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15228 }
15229 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15230 {
15231 PyThreadState* __tstate = wxPyBeginAllowThreads();
15232 result = (int)(arg1)->GetUPosition();
15233 wxPyEndAllowThreads(__tstate);
15234 if (PyErr_Occurred()) SWIG_fail;
15235 }
15236 resultobj = SWIG_From_int(static_cast< int >(result));
15237 return resultobj;
15238 fail:
15239 return NULL;
15240 }
15241
15242
15243 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15244 PyObject *resultobj = 0;
15245 wxJoystick *arg1 = (wxJoystick *) 0 ;
15246 int result;
15247 void *argp1 = 0 ;
15248 int res1 = 0 ;
15249 PyObject *swig_obj[1] ;
15250
15251 if (!args) SWIG_fail;
15252 swig_obj[0] = args;
15253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15254 if (!SWIG_IsOK(res1)) {
15255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15256 }
15257 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15258 {
15259 PyThreadState* __tstate = wxPyBeginAllowThreads();
15260 result = (int)(arg1)->GetVPosition();
15261 wxPyEndAllowThreads(__tstate);
15262 if (PyErr_Occurred()) SWIG_fail;
15263 }
15264 resultobj = SWIG_From_int(static_cast< int >(result));
15265 return resultobj;
15266 fail:
15267 return NULL;
15268 }
15269
15270
15271 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15272 PyObject *resultobj = 0;
15273 wxJoystick *arg1 = (wxJoystick *) 0 ;
15274 int result;
15275 void *argp1 = 0 ;
15276 int res1 = 0 ;
15277 PyObject *swig_obj[1] ;
15278
15279 if (!args) SWIG_fail;
15280 swig_obj[0] = args;
15281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15282 if (!SWIG_IsOK(res1)) {
15283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15284 }
15285 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15286 {
15287 PyThreadState* __tstate = wxPyBeginAllowThreads();
15288 result = (int)(arg1)->GetMovementThreshold();
15289 wxPyEndAllowThreads(__tstate);
15290 if (PyErr_Occurred()) SWIG_fail;
15291 }
15292 resultobj = SWIG_From_int(static_cast< int >(result));
15293 return resultobj;
15294 fail:
15295 return NULL;
15296 }
15297
15298
15299 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15300 PyObject *resultobj = 0;
15301 wxJoystick *arg1 = (wxJoystick *) 0 ;
15302 int arg2 ;
15303 void *argp1 = 0 ;
15304 int res1 = 0 ;
15305 int val2 ;
15306 int ecode2 = 0 ;
15307 PyObject * obj0 = 0 ;
15308 PyObject * obj1 = 0 ;
15309 char * kwnames[] = {
15310 (char *) "self",(char *) "threshold", NULL
15311 };
15312
15313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15315 if (!SWIG_IsOK(res1)) {
15316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15317 }
15318 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15319 ecode2 = SWIG_AsVal_int(obj1, &val2);
15320 if (!SWIG_IsOK(ecode2)) {
15321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15322 }
15323 arg2 = static_cast< int >(val2);
15324 {
15325 PyThreadState* __tstate = wxPyBeginAllowThreads();
15326 (arg1)->SetMovementThreshold(arg2);
15327 wxPyEndAllowThreads(__tstate);
15328 if (PyErr_Occurred()) SWIG_fail;
15329 }
15330 resultobj = SWIG_Py_Void();
15331 return resultobj;
15332 fail:
15333 return NULL;
15334 }
15335
15336
15337 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15338 PyObject *resultobj = 0;
15339 wxJoystick *arg1 = (wxJoystick *) 0 ;
15340 bool result;
15341 void *argp1 = 0 ;
15342 int res1 = 0 ;
15343 PyObject *swig_obj[1] ;
15344
15345 if (!args) SWIG_fail;
15346 swig_obj[0] = args;
15347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15348 if (!SWIG_IsOK(res1)) {
15349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15350 }
15351 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15352 {
15353 PyThreadState* __tstate = wxPyBeginAllowThreads();
15354 result = (bool)(arg1)->IsOk();
15355 wxPyEndAllowThreads(__tstate);
15356 if (PyErr_Occurred()) SWIG_fail;
15357 }
15358 {
15359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15360 }
15361 return resultobj;
15362 fail:
15363 return NULL;
15364 }
15365
15366
15367 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15368 PyObject *resultobj = 0;
15369 wxJoystick *arg1 = (wxJoystick *) 0 ;
15370 int result;
15371 void *argp1 = 0 ;
15372 int res1 = 0 ;
15373 PyObject *swig_obj[1] ;
15374
15375 if (!args) SWIG_fail;
15376 swig_obj[0] = args;
15377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15378 if (!SWIG_IsOK(res1)) {
15379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15380 }
15381 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15382 {
15383 PyThreadState* __tstate = wxPyBeginAllowThreads();
15384 result = (int)(arg1)->GetNumberJoysticks();
15385 wxPyEndAllowThreads(__tstate);
15386 if (PyErr_Occurred()) SWIG_fail;
15387 }
15388 resultobj = SWIG_From_int(static_cast< int >(result));
15389 return resultobj;
15390 fail:
15391 return NULL;
15392 }
15393
15394
15395 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15396 PyObject *resultobj = 0;
15397 wxJoystick *arg1 = (wxJoystick *) 0 ;
15398 int result;
15399 void *argp1 = 0 ;
15400 int res1 = 0 ;
15401 PyObject *swig_obj[1] ;
15402
15403 if (!args) SWIG_fail;
15404 swig_obj[0] = args;
15405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15406 if (!SWIG_IsOK(res1)) {
15407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15408 }
15409 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15410 {
15411 PyThreadState* __tstate = wxPyBeginAllowThreads();
15412 result = (int)(arg1)->GetManufacturerId();
15413 wxPyEndAllowThreads(__tstate);
15414 if (PyErr_Occurred()) SWIG_fail;
15415 }
15416 resultobj = SWIG_From_int(static_cast< int >(result));
15417 return resultobj;
15418 fail:
15419 return NULL;
15420 }
15421
15422
15423 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15424 PyObject *resultobj = 0;
15425 wxJoystick *arg1 = (wxJoystick *) 0 ;
15426 int result;
15427 void *argp1 = 0 ;
15428 int res1 = 0 ;
15429 PyObject *swig_obj[1] ;
15430
15431 if (!args) SWIG_fail;
15432 swig_obj[0] = args;
15433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15434 if (!SWIG_IsOK(res1)) {
15435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15436 }
15437 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15438 {
15439 PyThreadState* __tstate = wxPyBeginAllowThreads();
15440 result = (int)(arg1)->GetProductId();
15441 wxPyEndAllowThreads(__tstate);
15442 if (PyErr_Occurred()) SWIG_fail;
15443 }
15444 resultobj = SWIG_From_int(static_cast< int >(result));
15445 return resultobj;
15446 fail:
15447 return NULL;
15448 }
15449
15450
15451 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15452 PyObject *resultobj = 0;
15453 wxJoystick *arg1 = (wxJoystick *) 0 ;
15454 wxString result;
15455 void *argp1 = 0 ;
15456 int res1 = 0 ;
15457 PyObject *swig_obj[1] ;
15458
15459 if (!args) SWIG_fail;
15460 swig_obj[0] = args;
15461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15462 if (!SWIG_IsOK(res1)) {
15463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15464 }
15465 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15466 {
15467 PyThreadState* __tstate = wxPyBeginAllowThreads();
15468 result = (arg1)->GetProductName();
15469 wxPyEndAllowThreads(__tstate);
15470 if (PyErr_Occurred()) SWIG_fail;
15471 }
15472 {
15473 #if wxUSE_UNICODE
15474 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15475 #else
15476 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15477 #endif
15478 }
15479 return resultobj;
15480 fail:
15481 return NULL;
15482 }
15483
15484
15485 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15486 PyObject *resultobj = 0;
15487 wxJoystick *arg1 = (wxJoystick *) 0 ;
15488 int result;
15489 void *argp1 = 0 ;
15490 int res1 = 0 ;
15491 PyObject *swig_obj[1] ;
15492
15493 if (!args) SWIG_fail;
15494 swig_obj[0] = args;
15495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15496 if (!SWIG_IsOK(res1)) {
15497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15498 }
15499 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15500 {
15501 PyThreadState* __tstate = wxPyBeginAllowThreads();
15502 result = (int)(arg1)->GetXMin();
15503 wxPyEndAllowThreads(__tstate);
15504 if (PyErr_Occurred()) SWIG_fail;
15505 }
15506 resultobj = SWIG_From_int(static_cast< int >(result));
15507 return resultobj;
15508 fail:
15509 return NULL;
15510 }
15511
15512
15513 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15514 PyObject *resultobj = 0;
15515 wxJoystick *arg1 = (wxJoystick *) 0 ;
15516 int result;
15517 void *argp1 = 0 ;
15518 int res1 = 0 ;
15519 PyObject *swig_obj[1] ;
15520
15521 if (!args) SWIG_fail;
15522 swig_obj[0] = args;
15523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15524 if (!SWIG_IsOK(res1)) {
15525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15526 }
15527 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15528 {
15529 PyThreadState* __tstate = wxPyBeginAllowThreads();
15530 result = (int)(arg1)->GetYMin();
15531 wxPyEndAllowThreads(__tstate);
15532 if (PyErr_Occurred()) SWIG_fail;
15533 }
15534 resultobj = SWIG_From_int(static_cast< int >(result));
15535 return resultobj;
15536 fail:
15537 return NULL;
15538 }
15539
15540
15541 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15542 PyObject *resultobj = 0;
15543 wxJoystick *arg1 = (wxJoystick *) 0 ;
15544 int result;
15545 void *argp1 = 0 ;
15546 int res1 = 0 ;
15547 PyObject *swig_obj[1] ;
15548
15549 if (!args) SWIG_fail;
15550 swig_obj[0] = args;
15551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15552 if (!SWIG_IsOK(res1)) {
15553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15554 }
15555 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15556 {
15557 PyThreadState* __tstate = wxPyBeginAllowThreads();
15558 result = (int)(arg1)->GetZMin();
15559 wxPyEndAllowThreads(__tstate);
15560 if (PyErr_Occurred()) SWIG_fail;
15561 }
15562 resultobj = SWIG_From_int(static_cast< int >(result));
15563 return resultobj;
15564 fail:
15565 return NULL;
15566 }
15567
15568
15569 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15570 PyObject *resultobj = 0;
15571 wxJoystick *arg1 = (wxJoystick *) 0 ;
15572 int result;
15573 void *argp1 = 0 ;
15574 int res1 = 0 ;
15575 PyObject *swig_obj[1] ;
15576
15577 if (!args) SWIG_fail;
15578 swig_obj[0] = args;
15579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15580 if (!SWIG_IsOK(res1)) {
15581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15582 }
15583 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15584 {
15585 PyThreadState* __tstate = wxPyBeginAllowThreads();
15586 result = (int)(arg1)->GetXMax();
15587 wxPyEndAllowThreads(__tstate);
15588 if (PyErr_Occurred()) SWIG_fail;
15589 }
15590 resultobj = SWIG_From_int(static_cast< int >(result));
15591 return resultobj;
15592 fail:
15593 return NULL;
15594 }
15595
15596
15597 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15598 PyObject *resultobj = 0;
15599 wxJoystick *arg1 = (wxJoystick *) 0 ;
15600 int result;
15601 void *argp1 = 0 ;
15602 int res1 = 0 ;
15603 PyObject *swig_obj[1] ;
15604
15605 if (!args) SWIG_fail;
15606 swig_obj[0] = args;
15607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15608 if (!SWIG_IsOK(res1)) {
15609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15610 }
15611 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15612 {
15613 PyThreadState* __tstate = wxPyBeginAllowThreads();
15614 result = (int)(arg1)->GetYMax();
15615 wxPyEndAllowThreads(__tstate);
15616 if (PyErr_Occurred()) SWIG_fail;
15617 }
15618 resultobj = SWIG_From_int(static_cast< int >(result));
15619 return resultobj;
15620 fail:
15621 return NULL;
15622 }
15623
15624
15625 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15626 PyObject *resultobj = 0;
15627 wxJoystick *arg1 = (wxJoystick *) 0 ;
15628 int result;
15629 void *argp1 = 0 ;
15630 int res1 = 0 ;
15631 PyObject *swig_obj[1] ;
15632
15633 if (!args) SWIG_fail;
15634 swig_obj[0] = args;
15635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15636 if (!SWIG_IsOK(res1)) {
15637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15638 }
15639 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15640 {
15641 PyThreadState* __tstate = wxPyBeginAllowThreads();
15642 result = (int)(arg1)->GetZMax();
15643 wxPyEndAllowThreads(__tstate);
15644 if (PyErr_Occurred()) SWIG_fail;
15645 }
15646 resultobj = SWIG_From_int(static_cast< int >(result));
15647 return resultobj;
15648 fail:
15649 return NULL;
15650 }
15651
15652
15653 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15654 PyObject *resultobj = 0;
15655 wxJoystick *arg1 = (wxJoystick *) 0 ;
15656 int result;
15657 void *argp1 = 0 ;
15658 int res1 = 0 ;
15659 PyObject *swig_obj[1] ;
15660
15661 if (!args) SWIG_fail;
15662 swig_obj[0] = args;
15663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15664 if (!SWIG_IsOK(res1)) {
15665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15666 }
15667 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15668 {
15669 PyThreadState* __tstate = wxPyBeginAllowThreads();
15670 result = (int)(arg1)->GetNumberButtons();
15671 wxPyEndAllowThreads(__tstate);
15672 if (PyErr_Occurred()) SWIG_fail;
15673 }
15674 resultobj = SWIG_From_int(static_cast< int >(result));
15675 return resultobj;
15676 fail:
15677 return NULL;
15678 }
15679
15680
15681 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15682 PyObject *resultobj = 0;
15683 wxJoystick *arg1 = (wxJoystick *) 0 ;
15684 int result;
15685 void *argp1 = 0 ;
15686 int res1 = 0 ;
15687 PyObject *swig_obj[1] ;
15688
15689 if (!args) SWIG_fail;
15690 swig_obj[0] = args;
15691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15692 if (!SWIG_IsOK(res1)) {
15693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15694 }
15695 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15696 {
15697 PyThreadState* __tstate = wxPyBeginAllowThreads();
15698 result = (int)(arg1)->GetNumberAxes();
15699 wxPyEndAllowThreads(__tstate);
15700 if (PyErr_Occurred()) SWIG_fail;
15701 }
15702 resultobj = SWIG_From_int(static_cast< int >(result));
15703 return resultobj;
15704 fail:
15705 return NULL;
15706 }
15707
15708
15709 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15710 PyObject *resultobj = 0;
15711 wxJoystick *arg1 = (wxJoystick *) 0 ;
15712 int result;
15713 void *argp1 = 0 ;
15714 int res1 = 0 ;
15715 PyObject *swig_obj[1] ;
15716
15717 if (!args) SWIG_fail;
15718 swig_obj[0] = args;
15719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15720 if (!SWIG_IsOK(res1)) {
15721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15722 }
15723 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15724 {
15725 PyThreadState* __tstate = wxPyBeginAllowThreads();
15726 result = (int)(arg1)->GetMaxButtons();
15727 wxPyEndAllowThreads(__tstate);
15728 if (PyErr_Occurred()) SWIG_fail;
15729 }
15730 resultobj = SWIG_From_int(static_cast< int >(result));
15731 return resultobj;
15732 fail:
15733 return NULL;
15734 }
15735
15736
15737 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15738 PyObject *resultobj = 0;
15739 wxJoystick *arg1 = (wxJoystick *) 0 ;
15740 int result;
15741 void *argp1 = 0 ;
15742 int res1 = 0 ;
15743 PyObject *swig_obj[1] ;
15744
15745 if (!args) SWIG_fail;
15746 swig_obj[0] = args;
15747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15748 if (!SWIG_IsOK(res1)) {
15749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15750 }
15751 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15752 {
15753 PyThreadState* __tstate = wxPyBeginAllowThreads();
15754 result = (int)(arg1)->GetMaxAxes();
15755 wxPyEndAllowThreads(__tstate);
15756 if (PyErr_Occurred()) SWIG_fail;
15757 }
15758 resultobj = SWIG_From_int(static_cast< int >(result));
15759 return resultobj;
15760 fail:
15761 return NULL;
15762 }
15763
15764
15765 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15766 PyObject *resultobj = 0;
15767 wxJoystick *arg1 = (wxJoystick *) 0 ;
15768 int result;
15769 void *argp1 = 0 ;
15770 int res1 = 0 ;
15771 PyObject *swig_obj[1] ;
15772
15773 if (!args) SWIG_fail;
15774 swig_obj[0] = args;
15775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15776 if (!SWIG_IsOK(res1)) {
15777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15778 }
15779 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15780 {
15781 PyThreadState* __tstate = wxPyBeginAllowThreads();
15782 result = (int)(arg1)->GetPollingMin();
15783 wxPyEndAllowThreads(__tstate);
15784 if (PyErr_Occurred()) SWIG_fail;
15785 }
15786 resultobj = SWIG_From_int(static_cast< int >(result));
15787 return resultobj;
15788 fail:
15789 return NULL;
15790 }
15791
15792
15793 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15794 PyObject *resultobj = 0;
15795 wxJoystick *arg1 = (wxJoystick *) 0 ;
15796 int result;
15797 void *argp1 = 0 ;
15798 int res1 = 0 ;
15799 PyObject *swig_obj[1] ;
15800
15801 if (!args) SWIG_fail;
15802 swig_obj[0] = args;
15803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15804 if (!SWIG_IsOK(res1)) {
15805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15806 }
15807 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15808 {
15809 PyThreadState* __tstate = wxPyBeginAllowThreads();
15810 result = (int)(arg1)->GetPollingMax();
15811 wxPyEndAllowThreads(__tstate);
15812 if (PyErr_Occurred()) SWIG_fail;
15813 }
15814 resultobj = SWIG_From_int(static_cast< int >(result));
15815 return resultobj;
15816 fail:
15817 return NULL;
15818 }
15819
15820
15821 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15822 PyObject *resultobj = 0;
15823 wxJoystick *arg1 = (wxJoystick *) 0 ;
15824 int result;
15825 void *argp1 = 0 ;
15826 int res1 = 0 ;
15827 PyObject *swig_obj[1] ;
15828
15829 if (!args) SWIG_fail;
15830 swig_obj[0] = args;
15831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15832 if (!SWIG_IsOK(res1)) {
15833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15834 }
15835 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15836 {
15837 PyThreadState* __tstate = wxPyBeginAllowThreads();
15838 result = (int)(arg1)->GetRudderMin();
15839 wxPyEndAllowThreads(__tstate);
15840 if (PyErr_Occurred()) SWIG_fail;
15841 }
15842 resultobj = SWIG_From_int(static_cast< int >(result));
15843 return resultobj;
15844 fail:
15845 return NULL;
15846 }
15847
15848
15849 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15850 PyObject *resultobj = 0;
15851 wxJoystick *arg1 = (wxJoystick *) 0 ;
15852 int result;
15853 void *argp1 = 0 ;
15854 int res1 = 0 ;
15855 PyObject *swig_obj[1] ;
15856
15857 if (!args) SWIG_fail;
15858 swig_obj[0] = args;
15859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15860 if (!SWIG_IsOK(res1)) {
15861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15862 }
15863 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15864 {
15865 PyThreadState* __tstate = wxPyBeginAllowThreads();
15866 result = (int)(arg1)->GetRudderMax();
15867 wxPyEndAllowThreads(__tstate);
15868 if (PyErr_Occurred()) SWIG_fail;
15869 }
15870 resultobj = SWIG_From_int(static_cast< int >(result));
15871 return resultobj;
15872 fail:
15873 return NULL;
15874 }
15875
15876
15877 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15878 PyObject *resultobj = 0;
15879 wxJoystick *arg1 = (wxJoystick *) 0 ;
15880 int result;
15881 void *argp1 = 0 ;
15882 int res1 = 0 ;
15883 PyObject *swig_obj[1] ;
15884
15885 if (!args) SWIG_fail;
15886 swig_obj[0] = args;
15887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15888 if (!SWIG_IsOK(res1)) {
15889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15890 }
15891 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15892 {
15893 PyThreadState* __tstate = wxPyBeginAllowThreads();
15894 result = (int)(arg1)->GetUMin();
15895 wxPyEndAllowThreads(__tstate);
15896 if (PyErr_Occurred()) SWIG_fail;
15897 }
15898 resultobj = SWIG_From_int(static_cast< int >(result));
15899 return resultobj;
15900 fail:
15901 return NULL;
15902 }
15903
15904
15905 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15906 PyObject *resultobj = 0;
15907 wxJoystick *arg1 = (wxJoystick *) 0 ;
15908 int result;
15909 void *argp1 = 0 ;
15910 int res1 = 0 ;
15911 PyObject *swig_obj[1] ;
15912
15913 if (!args) SWIG_fail;
15914 swig_obj[0] = args;
15915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15916 if (!SWIG_IsOK(res1)) {
15917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15918 }
15919 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15920 {
15921 PyThreadState* __tstate = wxPyBeginAllowThreads();
15922 result = (int)(arg1)->GetUMax();
15923 wxPyEndAllowThreads(__tstate);
15924 if (PyErr_Occurred()) SWIG_fail;
15925 }
15926 resultobj = SWIG_From_int(static_cast< int >(result));
15927 return resultobj;
15928 fail:
15929 return NULL;
15930 }
15931
15932
15933 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15934 PyObject *resultobj = 0;
15935 wxJoystick *arg1 = (wxJoystick *) 0 ;
15936 int result;
15937 void *argp1 = 0 ;
15938 int res1 = 0 ;
15939 PyObject *swig_obj[1] ;
15940
15941 if (!args) SWIG_fail;
15942 swig_obj[0] = args;
15943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15944 if (!SWIG_IsOK(res1)) {
15945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15946 }
15947 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15948 {
15949 PyThreadState* __tstate = wxPyBeginAllowThreads();
15950 result = (int)(arg1)->GetVMin();
15951 wxPyEndAllowThreads(__tstate);
15952 if (PyErr_Occurred()) SWIG_fail;
15953 }
15954 resultobj = SWIG_From_int(static_cast< int >(result));
15955 return resultobj;
15956 fail:
15957 return NULL;
15958 }
15959
15960
15961 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15962 PyObject *resultobj = 0;
15963 wxJoystick *arg1 = (wxJoystick *) 0 ;
15964 int result;
15965 void *argp1 = 0 ;
15966 int res1 = 0 ;
15967 PyObject *swig_obj[1] ;
15968
15969 if (!args) SWIG_fail;
15970 swig_obj[0] = args;
15971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15972 if (!SWIG_IsOK(res1)) {
15973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15974 }
15975 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15976 {
15977 PyThreadState* __tstate = wxPyBeginAllowThreads();
15978 result = (int)(arg1)->GetVMax();
15979 wxPyEndAllowThreads(__tstate);
15980 if (PyErr_Occurred()) SWIG_fail;
15981 }
15982 resultobj = SWIG_From_int(static_cast< int >(result));
15983 return resultobj;
15984 fail:
15985 return NULL;
15986 }
15987
15988
15989 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15990 PyObject *resultobj = 0;
15991 wxJoystick *arg1 = (wxJoystick *) 0 ;
15992 bool result;
15993 void *argp1 = 0 ;
15994 int res1 = 0 ;
15995 PyObject *swig_obj[1] ;
15996
15997 if (!args) SWIG_fail;
15998 swig_obj[0] = args;
15999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16000 if (!SWIG_IsOK(res1)) {
16001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16002 }
16003 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16004 {
16005 PyThreadState* __tstate = wxPyBeginAllowThreads();
16006 result = (bool)(arg1)->HasRudder();
16007 wxPyEndAllowThreads(__tstate);
16008 if (PyErr_Occurred()) SWIG_fail;
16009 }
16010 {
16011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16012 }
16013 return resultobj;
16014 fail:
16015 return NULL;
16016 }
16017
16018
16019 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16020 PyObject *resultobj = 0;
16021 wxJoystick *arg1 = (wxJoystick *) 0 ;
16022 bool result;
16023 void *argp1 = 0 ;
16024 int res1 = 0 ;
16025 PyObject *swig_obj[1] ;
16026
16027 if (!args) SWIG_fail;
16028 swig_obj[0] = args;
16029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16030 if (!SWIG_IsOK(res1)) {
16031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16032 }
16033 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16034 {
16035 PyThreadState* __tstate = wxPyBeginAllowThreads();
16036 result = (bool)(arg1)->HasZ();
16037 wxPyEndAllowThreads(__tstate);
16038 if (PyErr_Occurred()) SWIG_fail;
16039 }
16040 {
16041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16042 }
16043 return resultobj;
16044 fail:
16045 return NULL;
16046 }
16047
16048
16049 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16050 PyObject *resultobj = 0;
16051 wxJoystick *arg1 = (wxJoystick *) 0 ;
16052 bool result;
16053 void *argp1 = 0 ;
16054 int res1 = 0 ;
16055 PyObject *swig_obj[1] ;
16056
16057 if (!args) SWIG_fail;
16058 swig_obj[0] = args;
16059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16060 if (!SWIG_IsOK(res1)) {
16061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16062 }
16063 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16064 {
16065 PyThreadState* __tstate = wxPyBeginAllowThreads();
16066 result = (bool)(arg1)->HasU();
16067 wxPyEndAllowThreads(__tstate);
16068 if (PyErr_Occurred()) SWIG_fail;
16069 }
16070 {
16071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16072 }
16073 return resultobj;
16074 fail:
16075 return NULL;
16076 }
16077
16078
16079 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16080 PyObject *resultobj = 0;
16081 wxJoystick *arg1 = (wxJoystick *) 0 ;
16082 bool result;
16083 void *argp1 = 0 ;
16084 int res1 = 0 ;
16085 PyObject *swig_obj[1] ;
16086
16087 if (!args) SWIG_fail;
16088 swig_obj[0] = args;
16089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16090 if (!SWIG_IsOK(res1)) {
16091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16092 }
16093 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16094 {
16095 PyThreadState* __tstate = wxPyBeginAllowThreads();
16096 result = (bool)(arg1)->HasV();
16097 wxPyEndAllowThreads(__tstate);
16098 if (PyErr_Occurred()) SWIG_fail;
16099 }
16100 {
16101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16102 }
16103 return resultobj;
16104 fail:
16105 return NULL;
16106 }
16107
16108
16109 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16110 PyObject *resultobj = 0;
16111 wxJoystick *arg1 = (wxJoystick *) 0 ;
16112 bool result;
16113 void *argp1 = 0 ;
16114 int res1 = 0 ;
16115 PyObject *swig_obj[1] ;
16116
16117 if (!args) SWIG_fail;
16118 swig_obj[0] = args;
16119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16120 if (!SWIG_IsOK(res1)) {
16121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16122 }
16123 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16124 {
16125 PyThreadState* __tstate = wxPyBeginAllowThreads();
16126 result = (bool)(arg1)->HasPOV();
16127 wxPyEndAllowThreads(__tstate);
16128 if (PyErr_Occurred()) SWIG_fail;
16129 }
16130 {
16131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16132 }
16133 return resultobj;
16134 fail:
16135 return NULL;
16136 }
16137
16138
16139 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16140 PyObject *resultobj = 0;
16141 wxJoystick *arg1 = (wxJoystick *) 0 ;
16142 bool result;
16143 void *argp1 = 0 ;
16144 int res1 = 0 ;
16145 PyObject *swig_obj[1] ;
16146
16147 if (!args) SWIG_fail;
16148 swig_obj[0] = args;
16149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16150 if (!SWIG_IsOK(res1)) {
16151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16152 }
16153 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16154 {
16155 PyThreadState* __tstate = wxPyBeginAllowThreads();
16156 result = (bool)(arg1)->HasPOV4Dir();
16157 wxPyEndAllowThreads(__tstate);
16158 if (PyErr_Occurred()) SWIG_fail;
16159 }
16160 {
16161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16162 }
16163 return resultobj;
16164 fail:
16165 return NULL;
16166 }
16167
16168
16169 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16170 PyObject *resultobj = 0;
16171 wxJoystick *arg1 = (wxJoystick *) 0 ;
16172 bool result;
16173 void *argp1 = 0 ;
16174 int res1 = 0 ;
16175 PyObject *swig_obj[1] ;
16176
16177 if (!args) SWIG_fail;
16178 swig_obj[0] = args;
16179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16180 if (!SWIG_IsOK(res1)) {
16181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16182 }
16183 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16184 {
16185 PyThreadState* __tstate = wxPyBeginAllowThreads();
16186 result = (bool)(arg1)->HasPOVCTS();
16187 wxPyEndAllowThreads(__tstate);
16188 if (PyErr_Occurred()) SWIG_fail;
16189 }
16190 {
16191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16192 }
16193 return resultobj;
16194 fail:
16195 return NULL;
16196 }
16197
16198
16199 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16200 PyObject *resultobj = 0;
16201 wxJoystick *arg1 = (wxJoystick *) 0 ;
16202 wxWindow *arg2 = (wxWindow *) 0 ;
16203 int arg3 = (int) 0 ;
16204 bool result;
16205 void *argp1 = 0 ;
16206 int res1 = 0 ;
16207 void *argp2 = 0 ;
16208 int res2 = 0 ;
16209 int val3 ;
16210 int ecode3 = 0 ;
16211 PyObject * obj0 = 0 ;
16212 PyObject * obj1 = 0 ;
16213 PyObject * obj2 = 0 ;
16214 char * kwnames[] = {
16215 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16216 };
16217
16218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16220 if (!SWIG_IsOK(res1)) {
16221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16222 }
16223 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16224 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16225 if (!SWIG_IsOK(res2)) {
16226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16227 }
16228 arg2 = reinterpret_cast< wxWindow * >(argp2);
16229 if (obj2) {
16230 ecode3 = SWIG_AsVal_int(obj2, &val3);
16231 if (!SWIG_IsOK(ecode3)) {
16232 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16233 }
16234 arg3 = static_cast< int >(val3);
16235 }
16236 {
16237 PyThreadState* __tstate = wxPyBeginAllowThreads();
16238 result = (bool)(arg1)->SetCapture(arg2,arg3);
16239 wxPyEndAllowThreads(__tstate);
16240 if (PyErr_Occurred()) SWIG_fail;
16241 }
16242 {
16243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16244 }
16245 return resultobj;
16246 fail:
16247 return NULL;
16248 }
16249
16250
16251 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16252 PyObject *resultobj = 0;
16253 wxJoystick *arg1 = (wxJoystick *) 0 ;
16254 bool result;
16255 void *argp1 = 0 ;
16256 int res1 = 0 ;
16257 PyObject *swig_obj[1] ;
16258
16259 if (!args) SWIG_fail;
16260 swig_obj[0] = args;
16261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16262 if (!SWIG_IsOK(res1)) {
16263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16264 }
16265 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16266 {
16267 PyThreadState* __tstate = wxPyBeginAllowThreads();
16268 result = (bool)(arg1)->ReleaseCapture();
16269 wxPyEndAllowThreads(__tstate);
16270 if (PyErr_Occurred()) SWIG_fail;
16271 }
16272 {
16273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16274 }
16275 return resultobj;
16276 fail:
16277 return NULL;
16278 }
16279
16280
16281 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16282 PyObject *obj;
16283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16284 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16285 return SWIG_Py_Void();
16286 }
16287
16288 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16289 return SWIG_Python_InitShadowInstance(args);
16290 }
16291
16292 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16293 PyObject *resultobj = 0;
16294 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16295 int arg2 = (int) 0 ;
16296 int arg3 = (int) wxJOYSTICK1 ;
16297 int arg4 = (int) 0 ;
16298 wxJoystickEvent *result = 0 ;
16299 int val1 ;
16300 int ecode1 = 0 ;
16301 int val2 ;
16302 int ecode2 = 0 ;
16303 int val3 ;
16304 int ecode3 = 0 ;
16305 int val4 ;
16306 int ecode4 = 0 ;
16307 PyObject * obj0 = 0 ;
16308 PyObject * obj1 = 0 ;
16309 PyObject * obj2 = 0 ;
16310 PyObject * obj3 = 0 ;
16311 char * kwnames[] = {
16312 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16313 };
16314
16315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16316 if (obj0) {
16317 ecode1 = SWIG_AsVal_int(obj0, &val1);
16318 if (!SWIG_IsOK(ecode1)) {
16319 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16320 }
16321 arg1 = static_cast< wxEventType >(val1);
16322 }
16323 if (obj1) {
16324 ecode2 = SWIG_AsVal_int(obj1, &val2);
16325 if (!SWIG_IsOK(ecode2)) {
16326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16327 }
16328 arg2 = static_cast< int >(val2);
16329 }
16330 if (obj2) {
16331 ecode3 = SWIG_AsVal_int(obj2, &val3);
16332 if (!SWIG_IsOK(ecode3)) {
16333 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16334 }
16335 arg3 = static_cast< int >(val3);
16336 }
16337 if (obj3) {
16338 ecode4 = SWIG_AsVal_int(obj3, &val4);
16339 if (!SWIG_IsOK(ecode4)) {
16340 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16341 }
16342 arg4 = static_cast< int >(val4);
16343 }
16344 {
16345 PyThreadState* __tstate = wxPyBeginAllowThreads();
16346 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16347 wxPyEndAllowThreads(__tstate);
16348 if (PyErr_Occurred()) SWIG_fail;
16349 }
16350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16351 return resultobj;
16352 fail:
16353 return NULL;
16354 }
16355
16356
16357 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16358 PyObject *resultobj = 0;
16359 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16360 wxPoint result;
16361 void *argp1 = 0 ;
16362 int res1 = 0 ;
16363 PyObject *swig_obj[1] ;
16364
16365 if (!args) SWIG_fail;
16366 swig_obj[0] = args;
16367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16368 if (!SWIG_IsOK(res1)) {
16369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16370 }
16371 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16372 {
16373 PyThreadState* __tstate = wxPyBeginAllowThreads();
16374 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16375 wxPyEndAllowThreads(__tstate);
16376 if (PyErr_Occurred()) SWIG_fail;
16377 }
16378 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16379 return resultobj;
16380 fail:
16381 return NULL;
16382 }
16383
16384
16385 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16386 PyObject *resultobj = 0;
16387 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16388 int result;
16389 void *argp1 = 0 ;
16390 int res1 = 0 ;
16391 PyObject *swig_obj[1] ;
16392
16393 if (!args) SWIG_fail;
16394 swig_obj[0] = args;
16395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16396 if (!SWIG_IsOK(res1)) {
16397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16398 }
16399 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16400 {
16401 PyThreadState* __tstate = wxPyBeginAllowThreads();
16402 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16403 wxPyEndAllowThreads(__tstate);
16404 if (PyErr_Occurred()) SWIG_fail;
16405 }
16406 resultobj = SWIG_From_int(static_cast< int >(result));
16407 return resultobj;
16408 fail:
16409 return NULL;
16410 }
16411
16412
16413 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16414 PyObject *resultobj = 0;
16415 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16416 int result;
16417 void *argp1 = 0 ;
16418 int res1 = 0 ;
16419 PyObject *swig_obj[1] ;
16420
16421 if (!args) SWIG_fail;
16422 swig_obj[0] = args;
16423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16424 if (!SWIG_IsOK(res1)) {
16425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16426 }
16427 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16428 {
16429 PyThreadState* __tstate = wxPyBeginAllowThreads();
16430 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16431 wxPyEndAllowThreads(__tstate);
16432 if (PyErr_Occurred()) SWIG_fail;
16433 }
16434 resultobj = SWIG_From_int(static_cast< int >(result));
16435 return resultobj;
16436 fail:
16437 return NULL;
16438 }
16439
16440
16441 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16442 PyObject *resultobj = 0;
16443 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16444 int result;
16445 void *argp1 = 0 ;
16446 int res1 = 0 ;
16447 PyObject *swig_obj[1] ;
16448
16449 if (!args) SWIG_fail;
16450 swig_obj[0] = args;
16451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16452 if (!SWIG_IsOK(res1)) {
16453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16454 }
16455 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16456 {
16457 PyThreadState* __tstate = wxPyBeginAllowThreads();
16458 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16459 wxPyEndAllowThreads(__tstate);
16460 if (PyErr_Occurred()) SWIG_fail;
16461 }
16462 resultobj = SWIG_From_int(static_cast< int >(result));
16463 return resultobj;
16464 fail:
16465 return NULL;
16466 }
16467
16468
16469 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16470 PyObject *resultobj = 0;
16471 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16472 int result;
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_wxJoystickEvent, 0 | 0 );
16480 if (!SWIG_IsOK(res1)) {
16481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16482 }
16483 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16484 {
16485 PyThreadState* __tstate = wxPyBeginAllowThreads();
16486 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16487 wxPyEndAllowThreads(__tstate);
16488 if (PyErr_Occurred()) SWIG_fail;
16489 }
16490 resultobj = SWIG_From_int(static_cast< int >(result));
16491 return resultobj;
16492 fail:
16493 return NULL;
16494 }
16495
16496
16497 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16498 PyObject *resultobj = 0;
16499 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16500 int arg2 ;
16501 void *argp1 = 0 ;
16502 int res1 = 0 ;
16503 int val2 ;
16504 int ecode2 = 0 ;
16505 PyObject * obj0 = 0 ;
16506 PyObject * obj1 = 0 ;
16507 char * kwnames[] = {
16508 (char *) "self",(char *) "stick", NULL
16509 };
16510
16511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16513 if (!SWIG_IsOK(res1)) {
16514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16515 }
16516 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16517 ecode2 = SWIG_AsVal_int(obj1, &val2);
16518 if (!SWIG_IsOK(ecode2)) {
16519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16520 }
16521 arg2 = static_cast< int >(val2);
16522 {
16523 PyThreadState* __tstate = wxPyBeginAllowThreads();
16524 (arg1)->SetJoystick(arg2);
16525 wxPyEndAllowThreads(__tstate);
16526 if (PyErr_Occurred()) SWIG_fail;
16527 }
16528 resultobj = SWIG_Py_Void();
16529 return resultobj;
16530 fail:
16531 return NULL;
16532 }
16533
16534
16535 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16536 PyObject *resultobj = 0;
16537 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16538 int arg2 ;
16539 void *argp1 = 0 ;
16540 int res1 = 0 ;
16541 int val2 ;
16542 int ecode2 = 0 ;
16543 PyObject * obj0 = 0 ;
16544 PyObject * obj1 = 0 ;
16545 char * kwnames[] = {
16546 (char *) "self",(char *) "state", NULL
16547 };
16548
16549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16551 if (!SWIG_IsOK(res1)) {
16552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16553 }
16554 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16555 ecode2 = SWIG_AsVal_int(obj1, &val2);
16556 if (!SWIG_IsOK(ecode2)) {
16557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16558 }
16559 arg2 = static_cast< int >(val2);
16560 {
16561 PyThreadState* __tstate = wxPyBeginAllowThreads();
16562 (arg1)->SetButtonState(arg2);
16563 wxPyEndAllowThreads(__tstate);
16564 if (PyErr_Occurred()) SWIG_fail;
16565 }
16566 resultobj = SWIG_Py_Void();
16567 return resultobj;
16568 fail:
16569 return NULL;
16570 }
16571
16572
16573 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16574 PyObject *resultobj = 0;
16575 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16576 int arg2 ;
16577 void *argp1 = 0 ;
16578 int res1 = 0 ;
16579 int val2 ;
16580 int ecode2 = 0 ;
16581 PyObject * obj0 = 0 ;
16582 PyObject * obj1 = 0 ;
16583 char * kwnames[] = {
16584 (char *) "self",(char *) "change", NULL
16585 };
16586
16587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16589 if (!SWIG_IsOK(res1)) {
16590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16591 }
16592 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16593 ecode2 = SWIG_AsVal_int(obj1, &val2);
16594 if (!SWIG_IsOK(ecode2)) {
16595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16596 }
16597 arg2 = static_cast< int >(val2);
16598 {
16599 PyThreadState* __tstate = wxPyBeginAllowThreads();
16600 (arg1)->SetButtonChange(arg2);
16601 wxPyEndAllowThreads(__tstate);
16602 if (PyErr_Occurred()) SWIG_fail;
16603 }
16604 resultobj = SWIG_Py_Void();
16605 return resultobj;
16606 fail:
16607 return NULL;
16608 }
16609
16610
16611 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16612 PyObject *resultobj = 0;
16613 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16614 wxPoint *arg2 = 0 ;
16615 void *argp1 = 0 ;
16616 int res1 = 0 ;
16617 wxPoint temp2 ;
16618 PyObject * obj0 = 0 ;
16619 PyObject * obj1 = 0 ;
16620 char * kwnames[] = {
16621 (char *) "self",(char *) "pos", NULL
16622 };
16623
16624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16626 if (!SWIG_IsOK(res1)) {
16627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16628 }
16629 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16630 {
16631 arg2 = &temp2;
16632 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16633 }
16634 {
16635 PyThreadState* __tstate = wxPyBeginAllowThreads();
16636 (arg1)->SetPosition((wxPoint const &)*arg2);
16637 wxPyEndAllowThreads(__tstate);
16638 if (PyErr_Occurred()) SWIG_fail;
16639 }
16640 resultobj = SWIG_Py_Void();
16641 return resultobj;
16642 fail:
16643 return NULL;
16644 }
16645
16646
16647 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16648 PyObject *resultobj = 0;
16649 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16650 int arg2 ;
16651 void *argp1 = 0 ;
16652 int res1 = 0 ;
16653 int val2 ;
16654 int ecode2 = 0 ;
16655 PyObject * obj0 = 0 ;
16656 PyObject * obj1 = 0 ;
16657 char * kwnames[] = {
16658 (char *) "self",(char *) "zPos", NULL
16659 };
16660
16661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16663 if (!SWIG_IsOK(res1)) {
16664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16665 }
16666 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16667 ecode2 = SWIG_AsVal_int(obj1, &val2);
16668 if (!SWIG_IsOK(ecode2)) {
16669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16670 }
16671 arg2 = static_cast< int >(val2);
16672 {
16673 PyThreadState* __tstate = wxPyBeginAllowThreads();
16674 (arg1)->SetZPosition(arg2);
16675 wxPyEndAllowThreads(__tstate);
16676 if (PyErr_Occurred()) SWIG_fail;
16677 }
16678 resultobj = SWIG_Py_Void();
16679 return resultobj;
16680 fail:
16681 return NULL;
16682 }
16683
16684
16685 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16686 PyObject *resultobj = 0;
16687 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16688 bool result;
16689 void *argp1 = 0 ;
16690 int res1 = 0 ;
16691 PyObject *swig_obj[1] ;
16692
16693 if (!args) SWIG_fail;
16694 swig_obj[0] = args;
16695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16696 if (!SWIG_IsOK(res1)) {
16697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16698 }
16699 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16700 {
16701 PyThreadState* __tstate = wxPyBeginAllowThreads();
16702 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16703 wxPyEndAllowThreads(__tstate);
16704 if (PyErr_Occurred()) SWIG_fail;
16705 }
16706 {
16707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16708 }
16709 return resultobj;
16710 fail:
16711 return NULL;
16712 }
16713
16714
16715 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16716 PyObject *resultobj = 0;
16717 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16718 bool 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_wxJoystickEvent, 0 | 0 );
16726 if (!SWIG_IsOK(res1)) {
16727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16728 }
16729 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16730 {
16731 PyThreadState* __tstate = wxPyBeginAllowThreads();
16732 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16733 wxPyEndAllowThreads(__tstate);
16734 if (PyErr_Occurred()) SWIG_fail;
16735 }
16736 {
16737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16738 }
16739 return resultobj;
16740 fail:
16741 return NULL;
16742 }
16743
16744
16745 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16746 PyObject *resultobj = 0;
16747 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16748 bool result;
16749 void *argp1 = 0 ;
16750 int res1 = 0 ;
16751 PyObject *swig_obj[1] ;
16752
16753 if (!args) SWIG_fail;
16754 swig_obj[0] = args;
16755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16756 if (!SWIG_IsOK(res1)) {
16757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16758 }
16759 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16760 {
16761 PyThreadState* __tstate = wxPyBeginAllowThreads();
16762 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
16763 wxPyEndAllowThreads(__tstate);
16764 if (PyErr_Occurred()) SWIG_fail;
16765 }
16766 {
16767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16768 }
16769 return resultobj;
16770 fail:
16771 return NULL;
16772 }
16773
16774
16775 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16776 PyObject *resultobj = 0;
16777 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16778 int arg2 = (int) wxJOY_BUTTON_ANY ;
16779 bool result;
16780 void *argp1 = 0 ;
16781 int res1 = 0 ;
16782 int val2 ;
16783 int ecode2 = 0 ;
16784 PyObject * obj0 = 0 ;
16785 PyObject * obj1 = 0 ;
16786 char * kwnames[] = {
16787 (char *) "self",(char *) "but", NULL
16788 };
16789
16790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
16791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16792 if (!SWIG_IsOK(res1)) {
16793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16794 }
16795 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16796 if (obj1) {
16797 ecode2 = SWIG_AsVal_int(obj1, &val2);
16798 if (!SWIG_IsOK(ecode2)) {
16799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
16800 }
16801 arg2 = static_cast< int >(val2);
16802 }
16803 {
16804 PyThreadState* __tstate = wxPyBeginAllowThreads();
16805 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
16806 wxPyEndAllowThreads(__tstate);
16807 if (PyErr_Occurred()) SWIG_fail;
16808 }
16809 {
16810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16811 }
16812 return resultobj;
16813 fail:
16814 return NULL;
16815 }
16816
16817
16818 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16819 PyObject *resultobj = 0;
16820 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16821 int arg2 = (int) wxJOY_BUTTON_ANY ;
16822 bool result;
16823 void *argp1 = 0 ;
16824 int res1 = 0 ;
16825 int val2 ;
16826 int ecode2 = 0 ;
16827 PyObject * obj0 = 0 ;
16828 PyObject * obj1 = 0 ;
16829 char * kwnames[] = {
16830 (char *) "self",(char *) "but", NULL
16831 };
16832
16833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
16834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16835 if (!SWIG_IsOK(res1)) {
16836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16837 }
16838 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16839 if (obj1) {
16840 ecode2 = SWIG_AsVal_int(obj1, &val2);
16841 if (!SWIG_IsOK(ecode2)) {
16842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
16843 }
16844 arg2 = static_cast< int >(val2);
16845 }
16846 {
16847 PyThreadState* __tstate = wxPyBeginAllowThreads();
16848 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
16849 wxPyEndAllowThreads(__tstate);
16850 if (PyErr_Occurred()) SWIG_fail;
16851 }
16852 {
16853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16854 }
16855 return resultobj;
16856 fail:
16857 return NULL;
16858 }
16859
16860
16861 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16862 PyObject *resultobj = 0;
16863 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16864 int arg2 = (int) wxJOY_BUTTON_ANY ;
16865 bool result;
16866 void *argp1 = 0 ;
16867 int res1 = 0 ;
16868 int val2 ;
16869 int ecode2 = 0 ;
16870 PyObject * obj0 = 0 ;
16871 PyObject * obj1 = 0 ;
16872 char * kwnames[] = {
16873 (char *) "self",(char *) "but", NULL
16874 };
16875
16876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
16877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16878 if (!SWIG_IsOK(res1)) {
16879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16880 }
16881 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16882 if (obj1) {
16883 ecode2 = SWIG_AsVal_int(obj1, &val2);
16884 if (!SWIG_IsOK(ecode2)) {
16885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
16886 }
16887 arg2 = static_cast< int >(val2);
16888 }
16889 {
16890 PyThreadState* __tstate = wxPyBeginAllowThreads();
16891 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
16892 wxPyEndAllowThreads(__tstate);
16893 if (PyErr_Occurred()) SWIG_fail;
16894 }
16895 {
16896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16897 }
16898 return resultobj;
16899 fail:
16900 return NULL;
16901 }
16902
16903
16904 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16905 PyObject *obj;
16906 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16907 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
16908 return SWIG_Py_Void();
16909 }
16910
16911 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16912 return SWIG_Python_InitShadowInstance(args);
16913 }
16914
16915 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16916 PyObject *resultobj = 0;
16917 wxString const &arg1_defvalue = wxPyEmptyString ;
16918 wxString *arg1 = (wxString *) &arg1_defvalue ;
16919 wxSound *result = 0 ;
16920 bool temp1 = false ;
16921 PyObject * obj0 = 0 ;
16922 char * kwnames[] = {
16923 (char *) "fileName", NULL
16924 };
16925
16926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
16927 if (obj0) {
16928 {
16929 arg1 = wxString_in_helper(obj0);
16930 if (arg1 == NULL) SWIG_fail;
16931 temp1 = true;
16932 }
16933 }
16934 {
16935 if (!wxPyCheckForApp()) SWIG_fail;
16936 PyThreadState* __tstate = wxPyBeginAllowThreads();
16937 result = (wxSound *)new_wxSound((wxString const &)*arg1);
16938 wxPyEndAllowThreads(__tstate);
16939 if (PyErr_Occurred()) SWIG_fail;
16940 }
16941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
16942 {
16943 if (temp1)
16944 delete arg1;
16945 }
16946 return resultobj;
16947 fail:
16948 {
16949 if (temp1)
16950 delete arg1;
16951 }
16952 return NULL;
16953 }
16954
16955
16956 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16957 PyObject *resultobj = 0;
16958 PyObject *arg1 = (PyObject *) 0 ;
16959 wxSound *result = 0 ;
16960 PyObject * obj0 = 0 ;
16961 char * kwnames[] = {
16962 (char *) "data", NULL
16963 };
16964
16965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
16966 arg1 = obj0;
16967 {
16968 if (!wxPyCheckForApp()) SWIG_fail;
16969 PyThreadState* __tstate = wxPyBeginAllowThreads();
16970 result = (wxSound *)new_wxSound(arg1);
16971 wxPyEndAllowThreads(__tstate);
16972 if (PyErr_Occurred()) SWIG_fail;
16973 }
16974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
16975 return resultobj;
16976 fail:
16977 return NULL;
16978 }
16979
16980
16981 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16982 PyObject *resultobj = 0;
16983 wxSound *arg1 = (wxSound *) 0 ;
16984 void *argp1 = 0 ;
16985 int res1 = 0 ;
16986 PyObject *swig_obj[1] ;
16987
16988 if (!args) SWIG_fail;
16989 swig_obj[0] = args;
16990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
16991 if (!SWIG_IsOK(res1)) {
16992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
16993 }
16994 arg1 = reinterpret_cast< wxSound * >(argp1);
16995 {
16996 PyThreadState* __tstate = wxPyBeginAllowThreads();
16997 delete arg1;
16998
16999 wxPyEndAllowThreads(__tstate);
17000 if (PyErr_Occurred()) SWIG_fail;
17001 }
17002 resultobj = SWIG_Py_Void();
17003 return resultobj;
17004 fail:
17005 return NULL;
17006 }
17007
17008
17009 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17010 PyObject *resultobj = 0;
17011 wxSound *arg1 = (wxSound *) 0 ;
17012 wxString *arg2 = 0 ;
17013 bool result;
17014 void *argp1 = 0 ;
17015 int res1 = 0 ;
17016 bool temp2 = false ;
17017 PyObject * obj0 = 0 ;
17018 PyObject * obj1 = 0 ;
17019 char * kwnames[] = {
17020 (char *) "self",(char *) "fileName", NULL
17021 };
17022
17023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17025 if (!SWIG_IsOK(res1)) {
17026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17027 }
17028 arg1 = reinterpret_cast< wxSound * >(argp1);
17029 {
17030 arg2 = wxString_in_helper(obj1);
17031 if (arg2 == NULL) SWIG_fail;
17032 temp2 = true;
17033 }
17034 {
17035 PyThreadState* __tstate = wxPyBeginAllowThreads();
17036 result = (bool)(arg1)->Create((wxString const &)*arg2);
17037 wxPyEndAllowThreads(__tstate);
17038 if (PyErr_Occurred()) SWIG_fail;
17039 }
17040 {
17041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17042 }
17043 {
17044 if (temp2)
17045 delete arg2;
17046 }
17047 return resultobj;
17048 fail:
17049 {
17050 if (temp2)
17051 delete arg2;
17052 }
17053 return NULL;
17054 }
17055
17056
17057 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17058 PyObject *resultobj = 0;
17059 wxSound *arg1 = (wxSound *) 0 ;
17060 PyObject *arg2 = (PyObject *) 0 ;
17061 bool result;
17062 void *argp1 = 0 ;
17063 int res1 = 0 ;
17064 PyObject * obj0 = 0 ;
17065 PyObject * obj1 = 0 ;
17066 char * kwnames[] = {
17067 (char *) "self",(char *) "data", NULL
17068 };
17069
17070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17072 if (!SWIG_IsOK(res1)) {
17073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17074 }
17075 arg1 = reinterpret_cast< wxSound * >(argp1);
17076 arg2 = obj1;
17077 {
17078 PyThreadState* __tstate = wxPyBeginAllowThreads();
17079 result = (bool)wxSound_CreateFromData(arg1,arg2);
17080 wxPyEndAllowThreads(__tstate);
17081 if (PyErr_Occurred()) SWIG_fail;
17082 }
17083 {
17084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17085 }
17086 return resultobj;
17087 fail:
17088 return NULL;
17089 }
17090
17091
17092 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17093 PyObject *resultobj = 0;
17094 wxSound *arg1 = (wxSound *) 0 ;
17095 bool result;
17096 void *argp1 = 0 ;
17097 int res1 = 0 ;
17098 PyObject *swig_obj[1] ;
17099
17100 if (!args) SWIG_fail;
17101 swig_obj[0] = args;
17102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17103 if (!SWIG_IsOK(res1)) {
17104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17105 }
17106 arg1 = reinterpret_cast< wxSound * >(argp1);
17107 {
17108 PyThreadState* __tstate = wxPyBeginAllowThreads();
17109 result = (bool)(arg1)->IsOk();
17110 wxPyEndAllowThreads(__tstate);
17111 if (PyErr_Occurred()) SWIG_fail;
17112 }
17113 {
17114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17115 }
17116 return resultobj;
17117 fail:
17118 return NULL;
17119 }
17120
17121
17122 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17123 PyObject *resultobj = 0;
17124 wxSound *arg1 = (wxSound *) 0 ;
17125 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17126 bool result;
17127 void *argp1 = 0 ;
17128 int res1 = 0 ;
17129 unsigned int val2 ;
17130 int ecode2 = 0 ;
17131 PyObject * obj0 = 0 ;
17132 PyObject * obj1 = 0 ;
17133 char * kwnames[] = {
17134 (char *) "self",(char *) "flags", NULL
17135 };
17136
17137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17139 if (!SWIG_IsOK(res1)) {
17140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17141 }
17142 arg1 = reinterpret_cast< wxSound * >(argp1);
17143 if (obj1) {
17144 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17145 if (!SWIG_IsOK(ecode2)) {
17146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17147 }
17148 arg2 = static_cast< unsigned int >(val2);
17149 }
17150 {
17151 if (!wxPyCheckForApp()) SWIG_fail;
17152 PyThreadState* __tstate = wxPyBeginAllowThreads();
17153 result = (bool)((wxSound const *)arg1)->Play(arg2);
17154 wxPyEndAllowThreads(__tstate);
17155 if (PyErr_Occurred()) SWIG_fail;
17156 }
17157 {
17158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17159 }
17160 return resultobj;
17161 fail:
17162 return NULL;
17163 }
17164
17165
17166 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17167 PyObject *resultobj = 0;
17168 wxString *arg1 = 0 ;
17169 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17170 bool result;
17171 bool temp1 = false ;
17172 unsigned int val2 ;
17173 int ecode2 = 0 ;
17174 PyObject * obj0 = 0 ;
17175 PyObject * obj1 = 0 ;
17176 char * kwnames[] = {
17177 (char *) "filename",(char *) "flags", NULL
17178 };
17179
17180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17181 {
17182 arg1 = wxString_in_helper(obj0);
17183 if (arg1 == NULL) SWIG_fail;
17184 temp1 = true;
17185 }
17186 if (obj1) {
17187 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17188 if (!SWIG_IsOK(ecode2)) {
17189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17190 }
17191 arg2 = static_cast< unsigned int >(val2);
17192 }
17193 {
17194 if (!wxPyCheckForApp()) SWIG_fail;
17195 PyThreadState* __tstate = wxPyBeginAllowThreads();
17196 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17197 wxPyEndAllowThreads(__tstate);
17198 if (PyErr_Occurred()) SWIG_fail;
17199 }
17200 {
17201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17202 }
17203 {
17204 if (temp1)
17205 delete arg1;
17206 }
17207 return resultobj;
17208 fail:
17209 {
17210 if (temp1)
17211 delete arg1;
17212 }
17213 return NULL;
17214 }
17215
17216
17217 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17218 PyObject *resultobj = 0;
17219
17220 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17221 {
17222 if (!wxPyCheckForApp()) SWIG_fail;
17223 PyThreadState* __tstate = wxPyBeginAllowThreads();
17224 wxSound::Stop();
17225 wxPyEndAllowThreads(__tstate);
17226 if (PyErr_Occurred()) SWIG_fail;
17227 }
17228 resultobj = SWIG_Py_Void();
17229 return resultobj;
17230 fail:
17231 return NULL;
17232 }
17233
17234
17235 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17236 PyObject *obj;
17237 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17238 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17239 return SWIG_Py_Void();
17240 }
17241
17242 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17243 return SWIG_Python_InitShadowInstance(args);
17244 }
17245
17246 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17247 PyObject *resultobj = 0;
17248 wxString *arg1 = 0 ;
17249 wxString *arg2 = 0 ;
17250 wxString *arg3 = 0 ;
17251 wxString *arg4 = 0 ;
17252 wxFileTypeInfo *result = 0 ;
17253 bool temp1 = false ;
17254 bool temp2 = false ;
17255 bool temp3 = false ;
17256 bool temp4 = false ;
17257 PyObject * obj0 = 0 ;
17258 PyObject * obj1 = 0 ;
17259 PyObject * obj2 = 0 ;
17260 PyObject * obj3 = 0 ;
17261 char * kwnames[] = {
17262 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17263 };
17264
17265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17266 {
17267 arg1 = wxString_in_helper(obj0);
17268 if (arg1 == NULL) SWIG_fail;
17269 temp1 = true;
17270 }
17271 {
17272 arg2 = wxString_in_helper(obj1);
17273 if (arg2 == NULL) SWIG_fail;
17274 temp2 = true;
17275 }
17276 {
17277 arg3 = wxString_in_helper(obj2);
17278 if (arg3 == NULL) SWIG_fail;
17279 temp3 = true;
17280 }
17281 {
17282 arg4 = wxString_in_helper(obj3);
17283 if (arg4 == NULL) SWIG_fail;
17284 temp4 = true;
17285 }
17286 {
17287 PyThreadState* __tstate = wxPyBeginAllowThreads();
17288 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17289 wxPyEndAllowThreads(__tstate);
17290 if (PyErr_Occurred()) SWIG_fail;
17291 }
17292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17293 {
17294 if (temp1)
17295 delete arg1;
17296 }
17297 {
17298 if (temp2)
17299 delete arg2;
17300 }
17301 {
17302 if (temp3)
17303 delete arg3;
17304 }
17305 {
17306 if (temp4)
17307 delete arg4;
17308 }
17309 return resultobj;
17310 fail:
17311 {
17312 if (temp1)
17313 delete arg1;
17314 }
17315 {
17316 if (temp2)
17317 delete arg2;
17318 }
17319 {
17320 if (temp3)
17321 delete arg3;
17322 }
17323 {
17324 if (temp4)
17325 delete arg4;
17326 }
17327 return NULL;
17328 }
17329
17330
17331 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17332 PyObject *resultobj = 0;
17333 wxArrayString *arg1 = 0 ;
17334 wxFileTypeInfo *result = 0 ;
17335 bool temp1 = false ;
17336 PyObject * obj0 = 0 ;
17337 char * kwnames[] = {
17338 (char *) "sArray", NULL
17339 };
17340
17341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17342 {
17343 if (! PySequence_Check(obj0)) {
17344 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17345 SWIG_fail;
17346 }
17347 arg1 = new wxArrayString;
17348 temp1 = true;
17349 int i, len=PySequence_Length(obj0);
17350 for (i=0; i<len; i++) {
17351 PyObject* item = PySequence_GetItem(obj0, i);
17352 wxString* s = wxString_in_helper(item);
17353 if (PyErr_Occurred()) SWIG_fail;
17354 arg1->Add(*s);
17355 delete s;
17356 Py_DECREF(item);
17357 }
17358 }
17359 {
17360 PyThreadState* __tstate = wxPyBeginAllowThreads();
17361 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17362 wxPyEndAllowThreads(__tstate);
17363 if (PyErr_Occurred()) SWIG_fail;
17364 }
17365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17366 {
17367 if (temp1) delete arg1;
17368 }
17369 return resultobj;
17370 fail:
17371 {
17372 if (temp1) delete arg1;
17373 }
17374 return NULL;
17375 }
17376
17377
17378 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17379 PyObject *resultobj = 0;
17380 wxFileTypeInfo *result = 0 ;
17381
17382 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17383 {
17384 PyThreadState* __tstate = wxPyBeginAllowThreads();
17385 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17386 wxPyEndAllowThreads(__tstate);
17387 if (PyErr_Occurred()) SWIG_fail;
17388 }
17389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17390 return resultobj;
17391 fail:
17392 return NULL;
17393 }
17394
17395
17396 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17397 PyObject *resultobj = 0;
17398 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17399 bool result;
17400 void *argp1 = 0 ;
17401 int res1 = 0 ;
17402 PyObject *swig_obj[1] ;
17403
17404 if (!args) SWIG_fail;
17405 swig_obj[0] = args;
17406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17407 if (!SWIG_IsOK(res1)) {
17408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17409 }
17410 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17411 {
17412 PyThreadState* __tstate = wxPyBeginAllowThreads();
17413 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17414 wxPyEndAllowThreads(__tstate);
17415 if (PyErr_Occurred()) SWIG_fail;
17416 }
17417 {
17418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17419 }
17420 return resultobj;
17421 fail:
17422 return NULL;
17423 }
17424
17425
17426 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17427 PyObject *resultobj = 0;
17428 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17429 wxString *arg2 = 0 ;
17430 int arg3 = (int) 0 ;
17431 void *argp1 = 0 ;
17432 int res1 = 0 ;
17433 bool temp2 = false ;
17434 int val3 ;
17435 int ecode3 = 0 ;
17436 PyObject * obj0 = 0 ;
17437 PyObject * obj1 = 0 ;
17438 PyObject * obj2 = 0 ;
17439 char * kwnames[] = {
17440 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17441 };
17442
17443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17445 if (!SWIG_IsOK(res1)) {
17446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17447 }
17448 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17449 {
17450 arg2 = wxString_in_helper(obj1);
17451 if (arg2 == NULL) SWIG_fail;
17452 temp2 = true;
17453 }
17454 if (obj2) {
17455 ecode3 = SWIG_AsVal_int(obj2, &val3);
17456 if (!SWIG_IsOK(ecode3)) {
17457 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17458 }
17459 arg3 = static_cast< int >(val3);
17460 }
17461 {
17462 PyThreadState* __tstate = wxPyBeginAllowThreads();
17463 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17464 wxPyEndAllowThreads(__tstate);
17465 if (PyErr_Occurred()) SWIG_fail;
17466 }
17467 resultobj = SWIG_Py_Void();
17468 {
17469 if (temp2)
17470 delete arg2;
17471 }
17472 return resultobj;
17473 fail:
17474 {
17475 if (temp2)
17476 delete arg2;
17477 }
17478 return NULL;
17479 }
17480
17481
17482 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17483 PyObject *resultobj = 0;
17484 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17485 wxString *arg2 = 0 ;
17486 void *argp1 = 0 ;
17487 int res1 = 0 ;
17488 bool temp2 = false ;
17489 PyObject * obj0 = 0 ;
17490 PyObject * obj1 = 0 ;
17491 char * kwnames[] = {
17492 (char *) "self",(char *) "shortDesc", NULL
17493 };
17494
17495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17497 if (!SWIG_IsOK(res1)) {
17498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17499 }
17500 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17501 {
17502 arg2 = wxString_in_helper(obj1);
17503 if (arg2 == NULL) SWIG_fail;
17504 temp2 = true;
17505 }
17506 {
17507 PyThreadState* __tstate = wxPyBeginAllowThreads();
17508 (arg1)->SetShortDesc((wxString const &)*arg2);
17509 wxPyEndAllowThreads(__tstate);
17510 if (PyErr_Occurred()) SWIG_fail;
17511 }
17512 resultobj = SWIG_Py_Void();
17513 {
17514 if (temp2)
17515 delete arg2;
17516 }
17517 return resultobj;
17518 fail:
17519 {
17520 if (temp2)
17521 delete arg2;
17522 }
17523 return NULL;
17524 }
17525
17526
17527 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17528 PyObject *resultobj = 0;
17529 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17530 wxString *result = 0 ;
17531 void *argp1 = 0 ;
17532 int res1 = 0 ;
17533 PyObject *swig_obj[1] ;
17534
17535 if (!args) SWIG_fail;
17536 swig_obj[0] = args;
17537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17538 if (!SWIG_IsOK(res1)) {
17539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17540 }
17541 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17542 {
17543 PyThreadState* __tstate = wxPyBeginAllowThreads();
17544 {
17545 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17546 result = (wxString *) &_result_ref;
17547 }
17548 wxPyEndAllowThreads(__tstate);
17549 if (PyErr_Occurred()) SWIG_fail;
17550 }
17551 {
17552 #if wxUSE_UNICODE
17553 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17554 #else
17555 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17556 #endif
17557 }
17558 return resultobj;
17559 fail:
17560 return NULL;
17561 }
17562
17563
17564 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17565 PyObject *resultobj = 0;
17566 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17567 wxString *result = 0 ;
17568 void *argp1 = 0 ;
17569 int res1 = 0 ;
17570 PyObject *swig_obj[1] ;
17571
17572 if (!args) SWIG_fail;
17573 swig_obj[0] = args;
17574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17575 if (!SWIG_IsOK(res1)) {
17576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17577 }
17578 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17579 {
17580 PyThreadState* __tstate = wxPyBeginAllowThreads();
17581 {
17582 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17583 result = (wxString *) &_result_ref;
17584 }
17585 wxPyEndAllowThreads(__tstate);
17586 if (PyErr_Occurred()) SWIG_fail;
17587 }
17588 {
17589 #if wxUSE_UNICODE
17590 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17591 #else
17592 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17593 #endif
17594 }
17595 return resultobj;
17596 fail:
17597 return NULL;
17598 }
17599
17600
17601 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17602 PyObject *resultobj = 0;
17603 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17604 wxString *result = 0 ;
17605 void *argp1 = 0 ;
17606 int res1 = 0 ;
17607 PyObject *swig_obj[1] ;
17608
17609 if (!args) SWIG_fail;
17610 swig_obj[0] = args;
17611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17612 if (!SWIG_IsOK(res1)) {
17613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17614 }
17615 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17616 {
17617 PyThreadState* __tstate = wxPyBeginAllowThreads();
17618 {
17619 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17620 result = (wxString *) &_result_ref;
17621 }
17622 wxPyEndAllowThreads(__tstate);
17623 if (PyErr_Occurred()) SWIG_fail;
17624 }
17625 {
17626 #if wxUSE_UNICODE
17627 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17628 #else
17629 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17630 #endif
17631 }
17632 return resultobj;
17633 fail:
17634 return NULL;
17635 }
17636
17637
17638 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17639 PyObject *resultobj = 0;
17640 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17641 wxString *result = 0 ;
17642 void *argp1 = 0 ;
17643 int res1 = 0 ;
17644 PyObject *swig_obj[1] ;
17645
17646 if (!args) SWIG_fail;
17647 swig_obj[0] = args;
17648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17649 if (!SWIG_IsOK(res1)) {
17650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17651 }
17652 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17653 {
17654 PyThreadState* __tstate = wxPyBeginAllowThreads();
17655 {
17656 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17657 result = (wxString *) &_result_ref;
17658 }
17659 wxPyEndAllowThreads(__tstate);
17660 if (PyErr_Occurred()) SWIG_fail;
17661 }
17662 {
17663 #if wxUSE_UNICODE
17664 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17665 #else
17666 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17667 #endif
17668 }
17669 return resultobj;
17670 fail:
17671 return NULL;
17672 }
17673
17674
17675 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17676 PyObject *resultobj = 0;
17677 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17678 wxString *result = 0 ;
17679 void *argp1 = 0 ;
17680 int res1 = 0 ;
17681 PyObject *swig_obj[1] ;
17682
17683 if (!args) SWIG_fail;
17684 swig_obj[0] = args;
17685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17686 if (!SWIG_IsOK(res1)) {
17687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17688 }
17689 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17690 {
17691 PyThreadState* __tstate = wxPyBeginAllowThreads();
17692 {
17693 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17694 result = (wxString *) &_result_ref;
17695 }
17696 wxPyEndAllowThreads(__tstate);
17697 if (PyErr_Occurred()) SWIG_fail;
17698 }
17699 {
17700 #if wxUSE_UNICODE
17701 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17702 #else
17703 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17704 #endif
17705 }
17706 return resultobj;
17707 fail:
17708 return NULL;
17709 }
17710
17711
17712 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17713 PyObject *resultobj = 0;
17714 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17715 wxArrayString *result = 0 ;
17716 void *argp1 = 0 ;
17717 int res1 = 0 ;
17718 PyObject *swig_obj[1] ;
17719
17720 if (!args) SWIG_fail;
17721 swig_obj[0] = args;
17722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17723 if (!SWIG_IsOK(res1)) {
17724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17725 }
17726 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17727 {
17728 PyThreadState* __tstate = wxPyBeginAllowThreads();
17729 {
17730 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17731 result = (wxArrayString *) &_result_ref;
17732 }
17733 wxPyEndAllowThreads(__tstate);
17734 if (PyErr_Occurred()) SWIG_fail;
17735 }
17736 {
17737 resultobj = wxArrayString2PyList_helper(*result);
17738 }
17739 return resultobj;
17740 fail:
17741 return NULL;
17742 }
17743
17744
17745 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17746 PyObject *resultobj = 0;
17747 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17748 size_t result;
17749 void *argp1 = 0 ;
17750 int res1 = 0 ;
17751 PyObject *swig_obj[1] ;
17752
17753 if (!args) SWIG_fail;
17754 swig_obj[0] = args;
17755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17756 if (!SWIG_IsOK(res1)) {
17757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17758 }
17759 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17760 {
17761 PyThreadState* __tstate = wxPyBeginAllowThreads();
17762 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
17763 wxPyEndAllowThreads(__tstate);
17764 if (PyErr_Occurred()) SWIG_fail;
17765 }
17766 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
17767 return resultobj;
17768 fail:
17769 return NULL;
17770 }
17771
17772
17773 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17774 PyObject *resultobj = 0;
17775 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17776 wxString *result = 0 ;
17777 void *argp1 = 0 ;
17778 int res1 = 0 ;
17779 PyObject *swig_obj[1] ;
17780
17781 if (!args) SWIG_fail;
17782 swig_obj[0] = args;
17783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17784 if (!SWIG_IsOK(res1)) {
17785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17786 }
17787 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17788 {
17789 PyThreadState* __tstate = wxPyBeginAllowThreads();
17790 {
17791 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
17792 result = (wxString *) &_result_ref;
17793 }
17794 wxPyEndAllowThreads(__tstate);
17795 if (PyErr_Occurred()) SWIG_fail;
17796 }
17797 {
17798 #if wxUSE_UNICODE
17799 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17800 #else
17801 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17802 #endif
17803 }
17804 return resultobj;
17805 fail:
17806 return NULL;
17807 }
17808
17809
17810 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17811 PyObject *resultobj = 0;
17812 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17813 int result;
17814 void *argp1 = 0 ;
17815 int res1 = 0 ;
17816 PyObject *swig_obj[1] ;
17817
17818 if (!args) SWIG_fail;
17819 swig_obj[0] = args;
17820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17821 if (!SWIG_IsOK(res1)) {
17822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17823 }
17824 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17825 {
17826 PyThreadState* __tstate = wxPyBeginAllowThreads();
17827 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
17828 wxPyEndAllowThreads(__tstate);
17829 if (PyErr_Occurred()) SWIG_fail;
17830 }
17831 resultobj = SWIG_From_int(static_cast< int >(result));
17832 return resultobj;
17833 fail:
17834 return NULL;
17835 }
17836
17837
17838 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17839 PyObject *obj;
17840 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17841 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
17842 return SWIG_Py_Void();
17843 }
17844
17845 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17846 return SWIG_Python_InitShadowInstance(args);
17847 }
17848
17849 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17850 PyObject *resultobj = 0;
17851 wxFileTypeInfo *arg1 = 0 ;
17852 wxFileType *result = 0 ;
17853 void *argp1 = 0 ;
17854 int res1 = 0 ;
17855 PyObject * obj0 = 0 ;
17856 char * kwnames[] = {
17857 (char *) "ftInfo", NULL
17858 };
17859
17860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
17861 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17862 if (!SWIG_IsOK(res1)) {
17863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
17864 }
17865 if (!argp1) {
17866 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
17867 }
17868 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17869 {
17870 PyThreadState* __tstate = wxPyBeginAllowThreads();
17871 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
17872 wxPyEndAllowThreads(__tstate);
17873 if (PyErr_Occurred()) SWIG_fail;
17874 }
17875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
17876 return resultobj;
17877 fail:
17878 return NULL;
17879 }
17880
17881
17882 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17883 PyObject *resultobj = 0;
17884 wxFileType *arg1 = (wxFileType *) 0 ;
17885 void *argp1 = 0 ;
17886 int res1 = 0 ;
17887 PyObject *swig_obj[1] ;
17888
17889 if (!args) SWIG_fail;
17890 swig_obj[0] = args;
17891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
17892 if (!SWIG_IsOK(res1)) {
17893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
17894 }
17895 arg1 = reinterpret_cast< wxFileType * >(argp1);
17896 {
17897 PyThreadState* __tstate = wxPyBeginAllowThreads();
17898 delete arg1;
17899
17900 wxPyEndAllowThreads(__tstate);
17901 if (PyErr_Occurred()) SWIG_fail;
17902 }
17903 resultobj = SWIG_Py_Void();
17904 return resultobj;
17905 fail:
17906 return NULL;
17907 }
17908
17909
17910 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17911 PyObject *resultobj = 0;
17912 wxFileType *arg1 = (wxFileType *) 0 ;
17913 PyObject *result = 0 ;
17914 void *argp1 = 0 ;
17915 int res1 = 0 ;
17916 PyObject *swig_obj[1] ;
17917
17918 if (!args) SWIG_fail;
17919 swig_obj[0] = args;
17920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17921 if (!SWIG_IsOK(res1)) {
17922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
17923 }
17924 arg1 = reinterpret_cast< wxFileType * >(argp1);
17925 {
17926 PyThreadState* __tstate = wxPyBeginAllowThreads();
17927 result = (PyObject *)wxFileType_GetMimeType(arg1);
17928 wxPyEndAllowThreads(__tstate);
17929 if (PyErr_Occurred()) SWIG_fail;
17930 }
17931 resultobj = result;
17932 return resultobj;
17933 fail:
17934 return NULL;
17935 }
17936
17937
17938 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17939 PyObject *resultobj = 0;
17940 wxFileType *arg1 = (wxFileType *) 0 ;
17941 PyObject *result = 0 ;
17942 void *argp1 = 0 ;
17943 int res1 = 0 ;
17944 PyObject *swig_obj[1] ;
17945
17946 if (!args) SWIG_fail;
17947 swig_obj[0] = args;
17948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17949 if (!SWIG_IsOK(res1)) {
17950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
17951 }
17952 arg1 = reinterpret_cast< wxFileType * >(argp1);
17953 {
17954 PyThreadState* __tstate = wxPyBeginAllowThreads();
17955 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
17956 wxPyEndAllowThreads(__tstate);
17957 if (PyErr_Occurred()) SWIG_fail;
17958 }
17959 resultobj = result;
17960 return resultobj;
17961 fail:
17962 return NULL;
17963 }
17964
17965
17966 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17967 PyObject *resultobj = 0;
17968 wxFileType *arg1 = (wxFileType *) 0 ;
17969 PyObject *result = 0 ;
17970 void *argp1 = 0 ;
17971 int res1 = 0 ;
17972 PyObject *swig_obj[1] ;
17973
17974 if (!args) SWIG_fail;
17975 swig_obj[0] = args;
17976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17977 if (!SWIG_IsOK(res1)) {
17978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
17979 }
17980 arg1 = reinterpret_cast< wxFileType * >(argp1);
17981 {
17982 PyThreadState* __tstate = wxPyBeginAllowThreads();
17983 result = (PyObject *)wxFileType_GetExtensions(arg1);
17984 wxPyEndAllowThreads(__tstate);
17985 if (PyErr_Occurred()) SWIG_fail;
17986 }
17987 resultobj = result;
17988 return resultobj;
17989 fail:
17990 return NULL;
17991 }
17992
17993
17994 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17995 PyObject *resultobj = 0;
17996 wxFileType *arg1 = (wxFileType *) 0 ;
17997 wxIcon *result = 0 ;
17998 void *argp1 = 0 ;
17999 int res1 = 0 ;
18000 PyObject *swig_obj[1] ;
18001
18002 if (!args) SWIG_fail;
18003 swig_obj[0] = args;
18004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18005 if (!SWIG_IsOK(res1)) {
18006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18007 }
18008 arg1 = reinterpret_cast< wxFileType * >(argp1);
18009 {
18010 PyThreadState* __tstate = wxPyBeginAllowThreads();
18011 result = (wxIcon *)wxFileType_GetIcon(arg1);
18012 wxPyEndAllowThreads(__tstate);
18013 if (PyErr_Occurred()) SWIG_fail;
18014 }
18015 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18016 return resultobj;
18017 fail:
18018 return NULL;
18019 }
18020
18021
18022 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18023 PyObject *resultobj = 0;
18024 wxFileType *arg1 = (wxFileType *) 0 ;
18025 PyObject *result = 0 ;
18026 void *argp1 = 0 ;
18027 int res1 = 0 ;
18028 PyObject *swig_obj[1] ;
18029
18030 if (!args) SWIG_fail;
18031 swig_obj[0] = args;
18032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18033 if (!SWIG_IsOK(res1)) {
18034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18035 }
18036 arg1 = reinterpret_cast< wxFileType * >(argp1);
18037 {
18038 PyThreadState* __tstate = wxPyBeginAllowThreads();
18039 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18040 wxPyEndAllowThreads(__tstate);
18041 if (PyErr_Occurred()) SWIG_fail;
18042 }
18043 resultobj = result;
18044 return resultobj;
18045 fail:
18046 return NULL;
18047 }
18048
18049
18050 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18051 PyObject *resultobj = 0;
18052 wxFileType *arg1 = (wxFileType *) 0 ;
18053 PyObject *result = 0 ;
18054 void *argp1 = 0 ;
18055 int res1 = 0 ;
18056 PyObject *swig_obj[1] ;
18057
18058 if (!args) SWIG_fail;
18059 swig_obj[0] = args;
18060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18061 if (!SWIG_IsOK(res1)) {
18062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18063 }
18064 arg1 = reinterpret_cast< wxFileType * >(argp1);
18065 {
18066 PyThreadState* __tstate = wxPyBeginAllowThreads();
18067 result = (PyObject *)wxFileType_GetDescription(arg1);
18068 wxPyEndAllowThreads(__tstate);
18069 if (PyErr_Occurred()) SWIG_fail;
18070 }
18071 resultobj = result;
18072 return resultobj;
18073 fail:
18074 return NULL;
18075 }
18076
18077
18078 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18079 PyObject *resultobj = 0;
18080 wxFileType *arg1 = (wxFileType *) 0 ;
18081 wxString *arg2 = 0 ;
18082 wxString const &arg3_defvalue = wxPyEmptyString ;
18083 wxString *arg3 = (wxString *) &arg3_defvalue ;
18084 PyObject *result = 0 ;
18085 void *argp1 = 0 ;
18086 int res1 = 0 ;
18087 bool temp2 = false ;
18088 bool temp3 = false ;
18089 PyObject * obj0 = 0 ;
18090 PyObject * obj1 = 0 ;
18091 PyObject * obj2 = 0 ;
18092 char * kwnames[] = {
18093 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18094 };
18095
18096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18098 if (!SWIG_IsOK(res1)) {
18099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18100 }
18101 arg1 = reinterpret_cast< wxFileType * >(argp1);
18102 {
18103 arg2 = wxString_in_helper(obj1);
18104 if (arg2 == NULL) SWIG_fail;
18105 temp2 = true;
18106 }
18107 if (obj2) {
18108 {
18109 arg3 = wxString_in_helper(obj2);
18110 if (arg3 == NULL) SWIG_fail;
18111 temp3 = true;
18112 }
18113 }
18114 {
18115 PyThreadState* __tstate = wxPyBeginAllowThreads();
18116 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18117 wxPyEndAllowThreads(__tstate);
18118 if (PyErr_Occurred()) SWIG_fail;
18119 }
18120 resultobj = result;
18121 {
18122 if (temp2)
18123 delete arg2;
18124 }
18125 {
18126 if (temp3)
18127 delete arg3;
18128 }
18129 return resultobj;
18130 fail:
18131 {
18132 if (temp2)
18133 delete arg2;
18134 }
18135 {
18136 if (temp3)
18137 delete arg3;
18138 }
18139 return NULL;
18140 }
18141
18142
18143 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18144 PyObject *resultobj = 0;
18145 wxFileType *arg1 = (wxFileType *) 0 ;
18146 wxString *arg2 = 0 ;
18147 wxString const &arg3_defvalue = wxPyEmptyString ;
18148 wxString *arg3 = (wxString *) &arg3_defvalue ;
18149 PyObject *result = 0 ;
18150 void *argp1 = 0 ;
18151 int res1 = 0 ;
18152 bool temp2 = false ;
18153 bool temp3 = false ;
18154 PyObject * obj0 = 0 ;
18155 PyObject * obj1 = 0 ;
18156 PyObject * obj2 = 0 ;
18157 char * kwnames[] = {
18158 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18159 };
18160
18161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18163 if (!SWIG_IsOK(res1)) {
18164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18165 }
18166 arg1 = reinterpret_cast< wxFileType * >(argp1);
18167 {
18168 arg2 = wxString_in_helper(obj1);
18169 if (arg2 == NULL) SWIG_fail;
18170 temp2 = true;
18171 }
18172 if (obj2) {
18173 {
18174 arg3 = wxString_in_helper(obj2);
18175 if (arg3 == NULL) SWIG_fail;
18176 temp3 = true;
18177 }
18178 }
18179 {
18180 PyThreadState* __tstate = wxPyBeginAllowThreads();
18181 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18182 wxPyEndAllowThreads(__tstate);
18183 if (PyErr_Occurred()) SWIG_fail;
18184 }
18185 resultobj = result;
18186 {
18187 if (temp2)
18188 delete arg2;
18189 }
18190 {
18191 if (temp3)
18192 delete arg3;
18193 }
18194 return resultobj;
18195 fail:
18196 {
18197 if (temp2)
18198 delete arg2;
18199 }
18200 {
18201 if (temp3)
18202 delete arg3;
18203 }
18204 return NULL;
18205 }
18206
18207
18208 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18209 PyObject *resultobj = 0;
18210 wxFileType *arg1 = (wxFileType *) 0 ;
18211 wxString *arg2 = 0 ;
18212 wxString const &arg3_defvalue = wxPyEmptyString ;
18213 wxString *arg3 = (wxString *) &arg3_defvalue ;
18214 PyObject *result = 0 ;
18215 void *argp1 = 0 ;
18216 int res1 = 0 ;
18217 bool temp2 = false ;
18218 bool temp3 = false ;
18219 PyObject * obj0 = 0 ;
18220 PyObject * obj1 = 0 ;
18221 PyObject * obj2 = 0 ;
18222 char * kwnames[] = {
18223 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18224 };
18225
18226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18228 if (!SWIG_IsOK(res1)) {
18229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18230 }
18231 arg1 = reinterpret_cast< wxFileType * >(argp1);
18232 {
18233 arg2 = wxString_in_helper(obj1);
18234 if (arg2 == NULL) SWIG_fail;
18235 temp2 = true;
18236 }
18237 if (obj2) {
18238 {
18239 arg3 = wxString_in_helper(obj2);
18240 if (arg3 == NULL) SWIG_fail;
18241 temp3 = true;
18242 }
18243 }
18244 {
18245 PyThreadState* __tstate = wxPyBeginAllowThreads();
18246 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18247 wxPyEndAllowThreads(__tstate);
18248 if (PyErr_Occurred()) SWIG_fail;
18249 }
18250 resultobj = result;
18251 {
18252 if (temp2)
18253 delete arg2;
18254 }
18255 {
18256 if (temp3)
18257 delete arg3;
18258 }
18259 return resultobj;
18260 fail:
18261 {
18262 if (temp2)
18263 delete arg2;
18264 }
18265 {
18266 if (temp3)
18267 delete arg3;
18268 }
18269 return NULL;
18270 }
18271
18272
18273 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18274 PyObject *resultobj = 0;
18275 wxFileType *arg1 = (wxFileType *) 0 ;
18276 wxString *arg2 = 0 ;
18277 wxString *arg3 = 0 ;
18278 bool arg4 = (bool) true ;
18279 bool result;
18280 void *argp1 = 0 ;
18281 int res1 = 0 ;
18282 bool temp2 = false ;
18283 bool temp3 = false ;
18284 bool val4 ;
18285 int ecode4 = 0 ;
18286 PyObject * obj0 = 0 ;
18287 PyObject * obj1 = 0 ;
18288 PyObject * obj2 = 0 ;
18289 PyObject * obj3 = 0 ;
18290 char * kwnames[] = {
18291 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18292 };
18293
18294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18296 if (!SWIG_IsOK(res1)) {
18297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18298 }
18299 arg1 = reinterpret_cast< wxFileType * >(argp1);
18300 {
18301 arg2 = wxString_in_helper(obj1);
18302 if (arg2 == NULL) SWIG_fail;
18303 temp2 = true;
18304 }
18305 {
18306 arg3 = wxString_in_helper(obj2);
18307 if (arg3 == NULL) SWIG_fail;
18308 temp3 = true;
18309 }
18310 if (obj3) {
18311 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18312 if (!SWIG_IsOK(ecode4)) {
18313 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18314 }
18315 arg4 = static_cast< bool >(val4);
18316 }
18317 {
18318 PyThreadState* __tstate = wxPyBeginAllowThreads();
18319 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18320 wxPyEndAllowThreads(__tstate);
18321 if (PyErr_Occurred()) SWIG_fail;
18322 }
18323 {
18324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18325 }
18326 {
18327 if (temp2)
18328 delete arg2;
18329 }
18330 {
18331 if (temp3)
18332 delete arg3;
18333 }
18334 return resultobj;
18335 fail:
18336 {
18337 if (temp2)
18338 delete arg2;
18339 }
18340 {
18341 if (temp3)
18342 delete arg3;
18343 }
18344 return NULL;
18345 }
18346
18347
18348 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18349 PyObject *resultobj = 0;
18350 wxFileType *arg1 = (wxFileType *) 0 ;
18351 wxString const &arg2_defvalue = wxPyEmptyString ;
18352 wxString *arg2 = (wxString *) &arg2_defvalue ;
18353 int arg3 = (int) 0 ;
18354 bool result;
18355 void *argp1 = 0 ;
18356 int res1 = 0 ;
18357 bool temp2 = false ;
18358 int val3 ;
18359 int ecode3 = 0 ;
18360 PyObject * obj0 = 0 ;
18361 PyObject * obj1 = 0 ;
18362 PyObject * obj2 = 0 ;
18363 char * kwnames[] = {
18364 (char *) "self",(char *) "cmd",(char *) "index", NULL
18365 };
18366
18367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18369 if (!SWIG_IsOK(res1)) {
18370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18371 }
18372 arg1 = reinterpret_cast< wxFileType * >(argp1);
18373 if (obj1) {
18374 {
18375 arg2 = wxString_in_helper(obj1);
18376 if (arg2 == NULL) SWIG_fail;
18377 temp2 = true;
18378 }
18379 }
18380 if (obj2) {
18381 ecode3 = SWIG_AsVal_int(obj2, &val3);
18382 if (!SWIG_IsOK(ecode3)) {
18383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18384 }
18385 arg3 = static_cast< int >(val3);
18386 }
18387 {
18388 PyThreadState* __tstate = wxPyBeginAllowThreads();
18389 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18390 wxPyEndAllowThreads(__tstate);
18391 if (PyErr_Occurred()) SWIG_fail;
18392 }
18393 {
18394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18395 }
18396 {
18397 if (temp2)
18398 delete arg2;
18399 }
18400 return resultobj;
18401 fail:
18402 {
18403 if (temp2)
18404 delete arg2;
18405 }
18406 return NULL;
18407 }
18408
18409
18410 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18411 PyObject *resultobj = 0;
18412 wxFileType *arg1 = (wxFileType *) 0 ;
18413 bool result;
18414 void *argp1 = 0 ;
18415 int res1 = 0 ;
18416 PyObject *swig_obj[1] ;
18417
18418 if (!args) SWIG_fail;
18419 swig_obj[0] = args;
18420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18421 if (!SWIG_IsOK(res1)) {
18422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18423 }
18424 arg1 = reinterpret_cast< wxFileType * >(argp1);
18425 {
18426 PyThreadState* __tstate = wxPyBeginAllowThreads();
18427 result = (bool)(arg1)->Unassociate();
18428 wxPyEndAllowThreads(__tstate);
18429 if (PyErr_Occurred()) SWIG_fail;
18430 }
18431 {
18432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18433 }
18434 return resultobj;
18435 fail:
18436 return NULL;
18437 }
18438
18439
18440 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18441 PyObject *resultobj = 0;
18442 wxString *arg1 = 0 ;
18443 wxString *arg2 = 0 ;
18444 wxString const &arg3_defvalue = wxPyEmptyString ;
18445 wxString *arg3 = (wxString *) &arg3_defvalue ;
18446 wxString result;
18447 bool temp1 = false ;
18448 bool temp2 = false ;
18449 bool temp3 = false ;
18450 PyObject * obj0 = 0 ;
18451 PyObject * obj1 = 0 ;
18452 PyObject * obj2 = 0 ;
18453 char * kwnames[] = {
18454 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18455 };
18456
18457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18458 {
18459 arg1 = wxString_in_helper(obj0);
18460 if (arg1 == NULL) SWIG_fail;
18461 temp1 = true;
18462 }
18463 {
18464 arg2 = wxString_in_helper(obj1);
18465 if (arg2 == NULL) SWIG_fail;
18466 temp2 = true;
18467 }
18468 if (obj2) {
18469 {
18470 arg3 = wxString_in_helper(obj2);
18471 if (arg3 == NULL) SWIG_fail;
18472 temp3 = true;
18473 }
18474 }
18475 {
18476 PyThreadState* __tstate = wxPyBeginAllowThreads();
18477 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18478 wxPyEndAllowThreads(__tstate);
18479 if (PyErr_Occurred()) SWIG_fail;
18480 }
18481 {
18482 #if wxUSE_UNICODE
18483 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18484 #else
18485 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18486 #endif
18487 }
18488 {
18489 if (temp1)
18490 delete arg1;
18491 }
18492 {
18493 if (temp2)
18494 delete arg2;
18495 }
18496 {
18497 if (temp3)
18498 delete arg3;
18499 }
18500 return resultobj;
18501 fail:
18502 {
18503 if (temp1)
18504 delete arg1;
18505 }
18506 {
18507 if (temp2)
18508 delete arg2;
18509 }
18510 {
18511 if (temp3)
18512 delete arg3;
18513 }
18514 return NULL;
18515 }
18516
18517
18518 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18519 PyObject *obj;
18520 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18521 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18522 return SWIG_Py_Void();
18523 }
18524
18525 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18526 return SWIG_Python_InitShadowInstance(args);
18527 }
18528
18529 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18530 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18531 return 1;
18532 }
18533
18534
18535 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18536 PyObject *pyobj = 0;
18537
18538 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18539 return pyobj;
18540 }
18541
18542
18543 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18544 PyObject *resultobj = 0;
18545 wxString *arg1 = 0 ;
18546 wxString *arg2 = 0 ;
18547 bool result;
18548 bool temp1 = false ;
18549 bool temp2 = false ;
18550 PyObject * obj0 = 0 ;
18551 PyObject * obj1 = 0 ;
18552 char * kwnames[] = {
18553 (char *) "mimeType",(char *) "wildcard", NULL
18554 };
18555
18556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18557 {
18558 arg1 = wxString_in_helper(obj0);
18559 if (arg1 == NULL) SWIG_fail;
18560 temp1 = true;
18561 }
18562 {
18563 arg2 = wxString_in_helper(obj1);
18564 if (arg2 == NULL) SWIG_fail;
18565 temp2 = true;
18566 }
18567 {
18568 PyThreadState* __tstate = wxPyBeginAllowThreads();
18569 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18570 wxPyEndAllowThreads(__tstate);
18571 if (PyErr_Occurred()) SWIG_fail;
18572 }
18573 {
18574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18575 }
18576 {
18577 if (temp1)
18578 delete arg1;
18579 }
18580 {
18581 if (temp2)
18582 delete arg2;
18583 }
18584 return resultobj;
18585 fail:
18586 {
18587 if (temp1)
18588 delete arg1;
18589 }
18590 {
18591 if (temp2)
18592 delete arg2;
18593 }
18594 return NULL;
18595 }
18596
18597
18598 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18599 PyObject *resultobj = 0;
18600 wxMimeTypesManager *result = 0 ;
18601
18602 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18603 {
18604 PyThreadState* __tstate = wxPyBeginAllowThreads();
18605 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18606 wxPyEndAllowThreads(__tstate);
18607 if (PyErr_Occurred()) SWIG_fail;
18608 }
18609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18610 return resultobj;
18611 fail:
18612 return NULL;
18613 }
18614
18615
18616 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18617 PyObject *resultobj = 0;
18618 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18619 int arg2 = (int) wxMAILCAP_ALL ;
18620 wxString const &arg3_defvalue = wxPyEmptyString ;
18621 wxString *arg3 = (wxString *) &arg3_defvalue ;
18622 void *argp1 = 0 ;
18623 int res1 = 0 ;
18624 int val2 ;
18625 int ecode2 = 0 ;
18626 bool temp3 = false ;
18627 PyObject * obj0 = 0 ;
18628 PyObject * obj1 = 0 ;
18629 PyObject * obj2 = 0 ;
18630 char * kwnames[] = {
18631 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18632 };
18633
18634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18636 if (!SWIG_IsOK(res1)) {
18637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18638 }
18639 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18640 if (obj1) {
18641 ecode2 = SWIG_AsVal_int(obj1, &val2);
18642 if (!SWIG_IsOK(ecode2)) {
18643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18644 }
18645 arg2 = static_cast< int >(val2);
18646 }
18647 if (obj2) {
18648 {
18649 arg3 = wxString_in_helper(obj2);
18650 if (arg3 == NULL) SWIG_fail;
18651 temp3 = true;
18652 }
18653 }
18654 {
18655 PyThreadState* __tstate = wxPyBeginAllowThreads();
18656 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18657 wxPyEndAllowThreads(__tstate);
18658 if (PyErr_Occurred()) SWIG_fail;
18659 }
18660 resultobj = SWIG_Py_Void();
18661 {
18662 if (temp3)
18663 delete arg3;
18664 }
18665 return resultobj;
18666 fail:
18667 {
18668 if (temp3)
18669 delete arg3;
18670 }
18671 return NULL;
18672 }
18673
18674
18675 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18676 PyObject *resultobj = 0;
18677 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18678 void *argp1 = 0 ;
18679 int res1 = 0 ;
18680 PyObject *swig_obj[1] ;
18681
18682 if (!args) SWIG_fail;
18683 swig_obj[0] = args;
18684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18685 if (!SWIG_IsOK(res1)) {
18686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18687 }
18688 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18689 {
18690 PyThreadState* __tstate = wxPyBeginAllowThreads();
18691 (arg1)->ClearData();
18692 wxPyEndAllowThreads(__tstate);
18693 if (PyErr_Occurred()) SWIG_fail;
18694 }
18695 resultobj = SWIG_Py_Void();
18696 return resultobj;
18697 fail:
18698 return NULL;
18699 }
18700
18701
18702 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18703 PyObject *resultobj = 0;
18704 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18705 wxString *arg2 = 0 ;
18706 wxFileType *result = 0 ;
18707 void *argp1 = 0 ;
18708 int res1 = 0 ;
18709 bool temp2 = false ;
18710 PyObject * obj0 = 0 ;
18711 PyObject * obj1 = 0 ;
18712 char * kwnames[] = {
18713 (char *) "self",(char *) "ext", NULL
18714 };
18715
18716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18718 if (!SWIG_IsOK(res1)) {
18719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18720 }
18721 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18722 {
18723 arg2 = wxString_in_helper(obj1);
18724 if (arg2 == NULL) SWIG_fail;
18725 temp2 = true;
18726 }
18727 {
18728 PyThreadState* __tstate = wxPyBeginAllowThreads();
18729 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18730 wxPyEndAllowThreads(__tstate);
18731 if (PyErr_Occurred()) SWIG_fail;
18732 }
18733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18734 {
18735 if (temp2)
18736 delete arg2;
18737 }
18738 return resultobj;
18739 fail:
18740 {
18741 if (temp2)
18742 delete arg2;
18743 }
18744 return NULL;
18745 }
18746
18747
18748 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18749 PyObject *resultobj = 0;
18750 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18751 wxString *arg2 = 0 ;
18752 wxFileType *result = 0 ;
18753 void *argp1 = 0 ;
18754 int res1 = 0 ;
18755 bool temp2 = false ;
18756 PyObject * obj0 = 0 ;
18757 PyObject * obj1 = 0 ;
18758 char * kwnames[] = {
18759 (char *) "self",(char *) "mimeType", NULL
18760 };
18761
18762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
18763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18764 if (!SWIG_IsOK(res1)) {
18765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18766 }
18767 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18768 {
18769 arg2 = wxString_in_helper(obj1);
18770 if (arg2 == NULL) SWIG_fail;
18771 temp2 = true;
18772 }
18773 {
18774 PyThreadState* __tstate = wxPyBeginAllowThreads();
18775 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
18776 wxPyEndAllowThreads(__tstate);
18777 if (PyErr_Occurred()) SWIG_fail;
18778 }
18779 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18780 {
18781 if (temp2)
18782 delete arg2;
18783 }
18784 return resultobj;
18785 fail:
18786 {
18787 if (temp2)
18788 delete arg2;
18789 }
18790 return NULL;
18791 }
18792
18793
18794 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18795 PyObject *resultobj = 0;
18796 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18797 wxString *arg2 = 0 ;
18798 bool arg3 = (bool) false ;
18799 bool result;
18800 void *argp1 = 0 ;
18801 int res1 = 0 ;
18802 bool temp2 = false ;
18803 bool val3 ;
18804 int ecode3 = 0 ;
18805 PyObject * obj0 = 0 ;
18806 PyObject * obj1 = 0 ;
18807 PyObject * obj2 = 0 ;
18808 char * kwnames[] = {
18809 (char *) "self",(char *) "filename",(char *) "fallback", NULL
18810 };
18811
18812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18814 if (!SWIG_IsOK(res1)) {
18815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18816 }
18817 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18818 {
18819 arg2 = wxString_in_helper(obj1);
18820 if (arg2 == NULL) SWIG_fail;
18821 temp2 = true;
18822 }
18823 if (obj2) {
18824 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18825 if (!SWIG_IsOK(ecode3)) {
18826 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
18827 }
18828 arg3 = static_cast< bool >(val3);
18829 }
18830 {
18831 PyThreadState* __tstate = wxPyBeginAllowThreads();
18832 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
18833 wxPyEndAllowThreads(__tstate);
18834 if (PyErr_Occurred()) SWIG_fail;
18835 }
18836 {
18837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18838 }
18839 {
18840 if (temp2)
18841 delete arg2;
18842 }
18843 return resultobj;
18844 fail:
18845 {
18846 if (temp2)
18847 delete arg2;
18848 }
18849 return NULL;
18850 }
18851
18852
18853 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18854 PyObject *resultobj = 0;
18855 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18856 wxString *arg2 = 0 ;
18857 bool result;
18858 void *argp1 = 0 ;
18859 int res1 = 0 ;
18860 bool temp2 = false ;
18861 PyObject * obj0 = 0 ;
18862 PyObject * obj1 = 0 ;
18863 char * kwnames[] = {
18864 (char *) "self",(char *) "filename", NULL
18865 };
18866
18867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
18868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18869 if (!SWIG_IsOK(res1)) {
18870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18871 }
18872 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18873 {
18874 arg2 = wxString_in_helper(obj1);
18875 if (arg2 == NULL) SWIG_fail;
18876 temp2 = true;
18877 }
18878 {
18879 PyThreadState* __tstate = wxPyBeginAllowThreads();
18880 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
18881 wxPyEndAllowThreads(__tstate);
18882 if (PyErr_Occurred()) SWIG_fail;
18883 }
18884 {
18885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18886 }
18887 {
18888 if (temp2)
18889 delete arg2;
18890 }
18891 return resultobj;
18892 fail:
18893 {
18894 if (temp2)
18895 delete arg2;
18896 }
18897 return NULL;
18898 }
18899
18900
18901 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18902 PyObject *resultobj = 0;
18903 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18904 PyObject *result = 0 ;
18905 void *argp1 = 0 ;
18906 int res1 = 0 ;
18907 PyObject *swig_obj[1] ;
18908
18909 if (!args) SWIG_fail;
18910 swig_obj[0] = args;
18911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18912 if (!SWIG_IsOK(res1)) {
18913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18914 }
18915 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18916 {
18917 PyThreadState* __tstate = wxPyBeginAllowThreads();
18918 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
18919 wxPyEndAllowThreads(__tstate);
18920 if (PyErr_Occurred()) SWIG_fail;
18921 }
18922 resultobj = result;
18923 return resultobj;
18924 fail:
18925 return NULL;
18926 }
18927
18928
18929 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18930 PyObject *resultobj = 0;
18931 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18932 wxFileTypeInfo *arg2 = 0 ;
18933 void *argp1 = 0 ;
18934 int res1 = 0 ;
18935 void *argp2 = 0 ;
18936 int res2 = 0 ;
18937 PyObject * obj0 = 0 ;
18938 PyObject * obj1 = 0 ;
18939 char * kwnames[] = {
18940 (char *) "self",(char *) "ft", NULL
18941 };
18942
18943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
18944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18945 if (!SWIG_IsOK(res1)) {
18946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18947 }
18948 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18949 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18950 if (!SWIG_IsOK(res2)) {
18951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18952 }
18953 if (!argp2) {
18954 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18955 }
18956 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
18957 {
18958 PyThreadState* __tstate = wxPyBeginAllowThreads();
18959 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
18960 wxPyEndAllowThreads(__tstate);
18961 if (PyErr_Occurred()) SWIG_fail;
18962 }
18963 resultobj = SWIG_Py_Void();
18964 return resultobj;
18965 fail:
18966 return NULL;
18967 }
18968
18969
18970 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18971 PyObject *resultobj = 0;
18972 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18973 wxFileTypeInfo *arg2 = 0 ;
18974 wxFileType *result = 0 ;
18975 void *argp1 = 0 ;
18976 int res1 = 0 ;
18977 void *argp2 = 0 ;
18978 int res2 = 0 ;
18979 PyObject * obj0 = 0 ;
18980 PyObject * obj1 = 0 ;
18981 char * kwnames[] = {
18982 (char *) "self",(char *) "ftInfo", NULL
18983 };
18984
18985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
18986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18987 if (!SWIG_IsOK(res1)) {
18988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18989 }
18990 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18991 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18992 if (!SWIG_IsOK(res2)) {
18993 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18994 }
18995 if (!argp2) {
18996 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18997 }
18998 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
18999 {
19000 PyThreadState* __tstate = wxPyBeginAllowThreads();
19001 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19002 wxPyEndAllowThreads(__tstate);
19003 if (PyErr_Occurred()) SWIG_fail;
19004 }
19005 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19006 return resultobj;
19007 fail:
19008 return NULL;
19009 }
19010
19011
19012 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19013 PyObject *resultobj = 0;
19014 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19015 wxFileType *arg2 = (wxFileType *) 0 ;
19016 bool result;
19017 void *argp1 = 0 ;
19018 int res1 = 0 ;
19019 void *argp2 = 0 ;
19020 int res2 = 0 ;
19021 PyObject * obj0 = 0 ;
19022 PyObject * obj1 = 0 ;
19023 char * kwnames[] = {
19024 (char *) "self",(char *) "ft", NULL
19025 };
19026
19027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19029 if (!SWIG_IsOK(res1)) {
19030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19031 }
19032 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19033 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19034 if (!SWIG_IsOK(res2)) {
19035 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19036 }
19037 arg2 = reinterpret_cast< wxFileType * >(argp2);
19038 {
19039 PyThreadState* __tstate = wxPyBeginAllowThreads();
19040 result = (bool)(arg1)->Unassociate(arg2);
19041 wxPyEndAllowThreads(__tstate);
19042 if (PyErr_Occurred()) SWIG_fail;
19043 }
19044 {
19045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19046 }
19047 return resultobj;
19048 fail:
19049 return NULL;
19050 }
19051
19052
19053 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19054 PyObject *resultobj = 0;
19055 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19056 void *argp1 = 0 ;
19057 int res1 = 0 ;
19058 PyObject *swig_obj[1] ;
19059
19060 if (!args) SWIG_fail;
19061 swig_obj[0] = args;
19062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19063 if (!SWIG_IsOK(res1)) {
19064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19065 }
19066 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19067 {
19068 PyThreadState* __tstate = wxPyBeginAllowThreads();
19069 delete arg1;
19070
19071 wxPyEndAllowThreads(__tstate);
19072 if (PyErr_Occurred()) SWIG_fail;
19073 }
19074 resultobj = SWIG_Py_Void();
19075 return resultobj;
19076 fail:
19077 return NULL;
19078 }
19079
19080
19081 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19082 PyObject *obj;
19083 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19084 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19085 return SWIG_Py_Void();
19086 }
19087
19088 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19089 return SWIG_Python_InitShadowInstance(args);
19090 }
19091
19092 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19093 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19094 return 1;
19095 }
19096
19097
19098 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19099 PyObject *pyobj = 0;
19100
19101 {
19102 #if wxUSE_UNICODE
19103 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19104 #else
19105 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19106 #endif
19107 }
19108 return pyobj;
19109 }
19110
19111
19112 SWIGINTERN int ART_MENU_set(PyObject *) {
19113 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19114 return 1;
19115 }
19116
19117
19118 SWIGINTERN PyObject *ART_MENU_get(void) {
19119 PyObject *pyobj = 0;
19120
19121 {
19122 #if wxUSE_UNICODE
19123 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19124 #else
19125 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19126 #endif
19127 }
19128 return pyobj;
19129 }
19130
19131
19132 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19133 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19134 return 1;
19135 }
19136
19137
19138 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19139 PyObject *pyobj = 0;
19140
19141 {
19142 #if wxUSE_UNICODE
19143 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19144 #else
19145 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19146 #endif
19147 }
19148 return pyobj;
19149 }
19150
19151
19152 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19153 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19154 return 1;
19155 }
19156
19157
19158 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19159 PyObject *pyobj = 0;
19160
19161 {
19162 #if wxUSE_UNICODE
19163 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19164 #else
19165 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19166 #endif
19167 }
19168 return pyobj;
19169 }
19170
19171
19172 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19173 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19174 return 1;
19175 }
19176
19177
19178 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19179 PyObject *pyobj = 0;
19180
19181 {
19182 #if wxUSE_UNICODE
19183 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19184 #else
19185 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19186 #endif
19187 }
19188 return pyobj;
19189 }
19190
19191
19192 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19193 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19194 return 1;
19195 }
19196
19197
19198 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19199 PyObject *pyobj = 0;
19200
19201 {
19202 #if wxUSE_UNICODE
19203 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19204 #else
19205 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19206 #endif
19207 }
19208 return pyobj;
19209 }
19210
19211
19212 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19213 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19214 return 1;
19215 }
19216
19217
19218 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19219 PyObject *pyobj = 0;
19220
19221 {
19222 #if wxUSE_UNICODE
19223 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19224 #else
19225 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19226 #endif
19227 }
19228 return pyobj;
19229 }
19230
19231
19232 SWIGINTERN int ART_OTHER_set(PyObject *) {
19233 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19234 return 1;
19235 }
19236
19237
19238 SWIGINTERN PyObject *ART_OTHER_get(void) {
19239 PyObject *pyobj = 0;
19240
19241 {
19242 #if wxUSE_UNICODE
19243 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19244 #else
19245 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19246 #endif
19247 }
19248 return pyobj;
19249 }
19250
19251
19252 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19253 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19254 return 1;
19255 }
19256
19257
19258 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19259 PyObject *pyobj = 0;
19260
19261 {
19262 #if wxUSE_UNICODE
19263 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19264 #else
19265 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19266 #endif
19267 }
19268 return pyobj;
19269 }
19270
19271
19272 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19273 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19274 return 1;
19275 }
19276
19277
19278 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19279 PyObject *pyobj = 0;
19280
19281 {
19282 #if wxUSE_UNICODE
19283 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19284 #else
19285 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19286 #endif
19287 }
19288 return pyobj;
19289 }
19290
19291
19292 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19293 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19294 return 1;
19295 }
19296
19297
19298 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19299 PyObject *pyobj = 0;
19300
19301 {
19302 #if wxUSE_UNICODE
19303 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19304 #else
19305 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19306 #endif
19307 }
19308 return pyobj;
19309 }
19310
19311
19312 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19313 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19314 return 1;
19315 }
19316
19317
19318 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19319 PyObject *pyobj = 0;
19320
19321 {
19322 #if wxUSE_UNICODE
19323 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19324 #else
19325 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19326 #endif
19327 }
19328 return pyobj;
19329 }
19330
19331
19332 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19333 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19334 return 1;
19335 }
19336
19337
19338 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19339 PyObject *pyobj = 0;
19340
19341 {
19342 #if wxUSE_UNICODE
19343 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19344 #else
19345 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19346 #endif
19347 }
19348 return pyobj;
19349 }
19350
19351
19352 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19353 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19354 return 1;
19355 }
19356
19357
19358 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19359 PyObject *pyobj = 0;
19360
19361 {
19362 #if wxUSE_UNICODE
19363 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19364 #else
19365 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19366 #endif
19367 }
19368 return pyobj;
19369 }
19370
19371
19372 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19373 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19374 return 1;
19375 }
19376
19377
19378 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19379 PyObject *pyobj = 0;
19380
19381 {
19382 #if wxUSE_UNICODE
19383 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19384 #else
19385 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19386 #endif
19387 }
19388 return pyobj;
19389 }
19390
19391
19392 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19393 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19394 return 1;
19395 }
19396
19397
19398 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19399 PyObject *pyobj = 0;
19400
19401 {
19402 #if wxUSE_UNICODE
19403 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19404 #else
19405 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19406 #endif
19407 }
19408 return pyobj;
19409 }
19410
19411
19412 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19413 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19414 return 1;
19415 }
19416
19417
19418 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19419 PyObject *pyobj = 0;
19420
19421 {
19422 #if wxUSE_UNICODE
19423 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19424 #else
19425 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19426 #endif
19427 }
19428 return pyobj;
19429 }
19430
19431
19432 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19433 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19434 return 1;
19435 }
19436
19437
19438 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19439 PyObject *pyobj = 0;
19440
19441 {
19442 #if wxUSE_UNICODE
19443 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19444 #else
19445 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19446 #endif
19447 }
19448 return pyobj;
19449 }
19450
19451
19452 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19453 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19454 return 1;
19455 }
19456
19457
19458 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19459 PyObject *pyobj = 0;
19460
19461 {
19462 #if wxUSE_UNICODE
19463 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19464 #else
19465 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19466 #endif
19467 }
19468 return pyobj;
19469 }
19470
19471
19472 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19473 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19474 return 1;
19475 }
19476
19477
19478 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19479 PyObject *pyobj = 0;
19480
19481 {
19482 #if wxUSE_UNICODE
19483 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19484 #else
19485 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19486 #endif
19487 }
19488 return pyobj;
19489 }
19490
19491
19492 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19493 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19494 return 1;
19495 }
19496
19497
19498 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19499 PyObject *pyobj = 0;
19500
19501 {
19502 #if wxUSE_UNICODE
19503 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19504 #else
19505 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19506 #endif
19507 }
19508 return pyobj;
19509 }
19510
19511
19512 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19513 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19514 return 1;
19515 }
19516
19517
19518 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19519 PyObject *pyobj = 0;
19520
19521 {
19522 #if wxUSE_UNICODE
19523 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19524 #else
19525 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19526 #endif
19527 }
19528 return pyobj;
19529 }
19530
19531
19532 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19533 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19534 return 1;
19535 }
19536
19537
19538 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19539 PyObject *pyobj = 0;
19540
19541 {
19542 #if wxUSE_UNICODE
19543 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19544 #else
19545 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19546 #endif
19547 }
19548 return pyobj;
19549 }
19550
19551
19552 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19553 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19554 return 1;
19555 }
19556
19557
19558 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19559 PyObject *pyobj = 0;
19560
19561 {
19562 #if wxUSE_UNICODE
19563 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19564 #else
19565 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19566 #endif
19567 }
19568 return pyobj;
19569 }
19570
19571
19572 SWIGINTERN int ART_PRINT_set(PyObject *) {
19573 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19574 return 1;
19575 }
19576
19577
19578 SWIGINTERN PyObject *ART_PRINT_get(void) {
19579 PyObject *pyobj = 0;
19580
19581 {
19582 #if wxUSE_UNICODE
19583 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19584 #else
19585 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19586 #endif
19587 }
19588 return pyobj;
19589 }
19590
19591
19592 SWIGINTERN int ART_HELP_set(PyObject *) {
19593 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19594 return 1;
19595 }
19596
19597
19598 SWIGINTERN PyObject *ART_HELP_get(void) {
19599 PyObject *pyobj = 0;
19600
19601 {
19602 #if wxUSE_UNICODE
19603 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19604 #else
19605 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19606 #endif
19607 }
19608 return pyobj;
19609 }
19610
19611
19612 SWIGINTERN int ART_TIP_set(PyObject *) {
19613 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19614 return 1;
19615 }
19616
19617
19618 SWIGINTERN PyObject *ART_TIP_get(void) {
19619 PyObject *pyobj = 0;
19620
19621 {
19622 #if wxUSE_UNICODE
19623 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19624 #else
19625 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19626 #endif
19627 }
19628 return pyobj;
19629 }
19630
19631
19632 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19633 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19634 return 1;
19635 }
19636
19637
19638 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19639 PyObject *pyobj = 0;
19640
19641 {
19642 #if wxUSE_UNICODE
19643 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19644 #else
19645 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19646 #endif
19647 }
19648 return pyobj;
19649 }
19650
19651
19652 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19653 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19654 return 1;
19655 }
19656
19657
19658 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19659 PyObject *pyobj = 0;
19660
19661 {
19662 #if wxUSE_UNICODE
19663 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19664 #else
19665 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19666 #endif
19667 }
19668 return pyobj;
19669 }
19670
19671
19672 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19673 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19674 return 1;
19675 }
19676
19677
19678 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19679 PyObject *pyobj = 0;
19680
19681 {
19682 #if wxUSE_UNICODE
19683 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19684 #else
19685 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19686 #endif
19687 }
19688 return pyobj;
19689 }
19690
19691
19692 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19693 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19694 return 1;
19695 }
19696
19697
19698 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19699 PyObject *pyobj = 0;
19700
19701 {
19702 #if wxUSE_UNICODE
19703 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19704 #else
19705 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19706 #endif
19707 }
19708 return pyobj;
19709 }
19710
19711
19712 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19713 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19714 return 1;
19715 }
19716
19717
19718 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19719 PyObject *pyobj = 0;
19720
19721 {
19722 #if wxUSE_UNICODE
19723 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19724 #else
19725 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19726 #endif
19727 }
19728 return pyobj;
19729 }
19730
19731
19732 SWIGINTERN int ART_CDROM_set(PyObject *) {
19733 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19734 return 1;
19735 }
19736
19737
19738 SWIGINTERN PyObject *ART_CDROM_get(void) {
19739 PyObject *pyobj = 0;
19740
19741 {
19742 #if wxUSE_UNICODE
19743 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19744 #else
19745 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19746 #endif
19747 }
19748 return pyobj;
19749 }
19750
19751
19752 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19753 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19754 return 1;
19755 }
19756
19757
19758 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
19759 PyObject *pyobj = 0;
19760
19761 {
19762 #if wxUSE_UNICODE
19763 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19764 #else
19765 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19766 #endif
19767 }
19768 return pyobj;
19769 }
19770
19771
19772 SWIGINTERN int ART_FOLDER_set(PyObject *) {
19773 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
19774 return 1;
19775 }
19776
19777
19778 SWIGINTERN PyObject *ART_FOLDER_get(void) {
19779 PyObject *pyobj = 0;
19780
19781 {
19782 #if wxUSE_UNICODE
19783 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19784 #else
19785 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19786 #endif
19787 }
19788 return pyobj;
19789 }
19790
19791
19792 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
19793 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
19794 return 1;
19795 }
19796
19797
19798 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
19799 PyObject *pyobj = 0;
19800
19801 {
19802 #if wxUSE_UNICODE
19803 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
19804 #else
19805 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
19806 #endif
19807 }
19808 return pyobj;
19809 }
19810
19811
19812 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
19813 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
19814 return 1;
19815 }
19816
19817
19818 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
19819 PyObject *pyobj = 0;
19820
19821 {
19822 #if wxUSE_UNICODE
19823 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
19824 #else
19825 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
19826 #endif
19827 }
19828 return pyobj;
19829 }
19830
19831
19832 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
19833 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
19834 return 1;
19835 }
19836
19837
19838 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
19839 PyObject *pyobj = 0;
19840
19841 {
19842 #if wxUSE_UNICODE
19843 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
19844 #else
19845 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
19846 #endif
19847 }
19848 return pyobj;
19849 }
19850
19851
19852 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
19853 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
19854 return 1;
19855 }
19856
19857
19858 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
19859 PyObject *pyobj = 0;
19860
19861 {
19862 #if wxUSE_UNICODE
19863 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
19864 #else
19865 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
19866 #endif
19867 }
19868 return pyobj;
19869 }
19870
19871
19872 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
19873 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
19874 return 1;
19875 }
19876
19877
19878 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
19879 PyObject *pyobj = 0;
19880
19881 {
19882 #if wxUSE_UNICODE
19883 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
19884 #else
19885 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
19886 #endif
19887 }
19888 return pyobj;
19889 }
19890
19891
19892 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
19893 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
19894 return 1;
19895 }
19896
19897
19898 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
19899 PyObject *pyobj = 0;
19900
19901 {
19902 #if wxUSE_UNICODE
19903 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
19904 #else
19905 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
19906 #endif
19907 }
19908 return pyobj;
19909 }
19910
19911
19912 SWIGINTERN int ART_ERROR_set(PyObject *) {
19913 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
19914 return 1;
19915 }
19916
19917
19918 SWIGINTERN PyObject *ART_ERROR_get(void) {
19919 PyObject *pyobj = 0;
19920
19921 {
19922 #if wxUSE_UNICODE
19923 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
19924 #else
19925 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
19926 #endif
19927 }
19928 return pyobj;
19929 }
19930
19931
19932 SWIGINTERN int ART_QUESTION_set(PyObject *) {
19933 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
19934 return 1;
19935 }
19936
19937
19938 SWIGINTERN PyObject *ART_QUESTION_get(void) {
19939 PyObject *pyobj = 0;
19940
19941 {
19942 #if wxUSE_UNICODE
19943 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19944 #else
19945 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19946 #endif
19947 }
19948 return pyobj;
19949 }
19950
19951
19952 SWIGINTERN int ART_WARNING_set(PyObject *) {
19953 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
19954 return 1;
19955 }
19956
19957
19958 SWIGINTERN PyObject *ART_WARNING_get(void) {
19959 PyObject *pyobj = 0;
19960
19961 {
19962 #if wxUSE_UNICODE
19963 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
19964 #else
19965 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
19966 #endif
19967 }
19968 return pyobj;
19969 }
19970
19971
19972 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
19973 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
19974 return 1;
19975 }
19976
19977
19978 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
19979 PyObject *pyobj = 0;
19980
19981 {
19982 #if wxUSE_UNICODE
19983 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
19984 #else
19985 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
19986 #endif
19987 }
19988 return pyobj;
19989 }
19990
19991
19992 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
19993 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
19994 return 1;
19995 }
19996
19997
19998 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
19999 PyObject *pyobj = 0;
20000
20001 {
20002 #if wxUSE_UNICODE
20003 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20004 #else
20005 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20006 #endif
20007 }
20008 return pyobj;
20009 }
20010
20011
20012 SWIGINTERN int ART_COPY_set(PyObject *) {
20013 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20014 return 1;
20015 }
20016
20017
20018 SWIGINTERN PyObject *ART_COPY_get(void) {
20019 PyObject *pyobj = 0;
20020
20021 {
20022 #if wxUSE_UNICODE
20023 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20024 #else
20025 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20026 #endif
20027 }
20028 return pyobj;
20029 }
20030
20031
20032 SWIGINTERN int ART_CUT_set(PyObject *) {
20033 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20034 return 1;
20035 }
20036
20037
20038 SWIGINTERN PyObject *ART_CUT_get(void) {
20039 PyObject *pyobj = 0;
20040
20041 {
20042 #if wxUSE_UNICODE
20043 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20044 #else
20045 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20046 #endif
20047 }
20048 return pyobj;
20049 }
20050
20051
20052 SWIGINTERN int ART_PASTE_set(PyObject *) {
20053 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20054 return 1;
20055 }
20056
20057
20058 SWIGINTERN PyObject *ART_PASTE_get(void) {
20059 PyObject *pyobj = 0;
20060
20061 {
20062 #if wxUSE_UNICODE
20063 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20064 #else
20065 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20066 #endif
20067 }
20068 return pyobj;
20069 }
20070
20071
20072 SWIGINTERN int ART_DELETE_set(PyObject *) {
20073 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20074 return 1;
20075 }
20076
20077
20078 SWIGINTERN PyObject *ART_DELETE_get(void) {
20079 PyObject *pyobj = 0;
20080
20081 {
20082 #if wxUSE_UNICODE
20083 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20084 #else
20085 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20086 #endif
20087 }
20088 return pyobj;
20089 }
20090
20091
20092 SWIGINTERN int ART_NEW_set(PyObject *) {
20093 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20094 return 1;
20095 }
20096
20097
20098 SWIGINTERN PyObject *ART_NEW_get(void) {
20099 PyObject *pyobj = 0;
20100
20101 {
20102 #if wxUSE_UNICODE
20103 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20104 #else
20105 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20106 #endif
20107 }
20108 return pyobj;
20109 }
20110
20111
20112 SWIGINTERN int ART_UNDO_set(PyObject *) {
20113 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20114 return 1;
20115 }
20116
20117
20118 SWIGINTERN PyObject *ART_UNDO_get(void) {
20119 PyObject *pyobj = 0;
20120
20121 {
20122 #if wxUSE_UNICODE
20123 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20124 #else
20125 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20126 #endif
20127 }
20128 return pyobj;
20129 }
20130
20131
20132 SWIGINTERN int ART_REDO_set(PyObject *) {
20133 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20134 return 1;
20135 }
20136
20137
20138 SWIGINTERN PyObject *ART_REDO_get(void) {
20139 PyObject *pyobj = 0;
20140
20141 {
20142 #if wxUSE_UNICODE
20143 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20144 #else
20145 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20146 #endif
20147 }
20148 return pyobj;
20149 }
20150
20151
20152 SWIGINTERN int ART_QUIT_set(PyObject *) {
20153 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20154 return 1;
20155 }
20156
20157
20158 SWIGINTERN PyObject *ART_QUIT_get(void) {
20159 PyObject *pyobj = 0;
20160
20161 {
20162 #if wxUSE_UNICODE
20163 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20164 #else
20165 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20166 #endif
20167 }
20168 return pyobj;
20169 }
20170
20171
20172 SWIGINTERN int ART_FIND_set(PyObject *) {
20173 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20174 return 1;
20175 }
20176
20177
20178 SWIGINTERN PyObject *ART_FIND_get(void) {
20179 PyObject *pyobj = 0;
20180
20181 {
20182 #if wxUSE_UNICODE
20183 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20184 #else
20185 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20186 #endif
20187 }
20188 return pyobj;
20189 }
20190
20191
20192 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20193 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20194 return 1;
20195 }
20196
20197
20198 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20199 PyObject *pyobj = 0;
20200
20201 {
20202 #if wxUSE_UNICODE
20203 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20204 #else
20205 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20206 #endif
20207 }
20208 return pyobj;
20209 }
20210
20211
20212 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20213 PyObject *resultobj = 0;
20214 wxPyArtProvider *result = 0 ;
20215
20216 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20217 {
20218 if (!wxPyCheckForApp()) SWIG_fail;
20219 PyThreadState* __tstate = wxPyBeginAllowThreads();
20220 result = (wxPyArtProvider *)new wxPyArtProvider();
20221 wxPyEndAllowThreads(__tstate);
20222 if (PyErr_Occurred()) SWIG_fail;
20223 }
20224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20225 return resultobj;
20226 fail:
20227 return NULL;
20228 }
20229
20230
20231 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20232 PyObject *resultobj = 0;
20233 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20234 void *argp1 = 0 ;
20235 int res1 = 0 ;
20236 PyObject *swig_obj[1] ;
20237
20238 if (!args) SWIG_fail;
20239 swig_obj[0] = args;
20240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20241 if (!SWIG_IsOK(res1)) {
20242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20243 }
20244 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20245 {
20246 PyThreadState* __tstate = wxPyBeginAllowThreads();
20247 delete arg1;
20248
20249 wxPyEndAllowThreads(__tstate);
20250 if (PyErr_Occurred()) SWIG_fail;
20251 }
20252 resultobj = SWIG_Py_Void();
20253 return resultobj;
20254 fail:
20255 return NULL;
20256 }
20257
20258
20259 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20260 PyObject *resultobj = 0;
20261 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20262 PyObject *arg2 = (PyObject *) 0 ;
20263 PyObject *arg3 = (PyObject *) 0 ;
20264 void *argp1 = 0 ;
20265 int res1 = 0 ;
20266 PyObject * obj0 = 0 ;
20267 PyObject * obj1 = 0 ;
20268 PyObject * obj2 = 0 ;
20269 char * kwnames[] = {
20270 (char *) "self",(char *) "self",(char *) "_class", NULL
20271 };
20272
20273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20275 if (!SWIG_IsOK(res1)) {
20276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20277 }
20278 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20279 arg2 = obj1;
20280 arg3 = obj2;
20281 {
20282 PyThreadState* __tstate = wxPyBeginAllowThreads();
20283 (arg1)->_setCallbackInfo(arg2,arg3);
20284 wxPyEndAllowThreads(__tstate);
20285 if (PyErr_Occurred()) SWIG_fail;
20286 }
20287 resultobj = SWIG_Py_Void();
20288 return resultobj;
20289 fail:
20290 return NULL;
20291 }
20292
20293
20294 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20295 PyObject *resultobj = 0;
20296 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20297 int res1 = 0 ;
20298 PyObject * obj0 = 0 ;
20299 char * kwnames[] = {
20300 (char *) "provider", NULL
20301 };
20302
20303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
20304 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20305 if (!SWIG_IsOK(res1)) {
20306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20307 }
20308 {
20309 PyThreadState* __tstate = wxPyBeginAllowThreads();
20310 wxPyArtProvider::PushProvider(arg1);
20311 wxPyEndAllowThreads(__tstate);
20312 if (PyErr_Occurred()) SWIG_fail;
20313 }
20314 resultobj = SWIG_Py_Void();
20315 return resultobj;
20316 fail:
20317 return NULL;
20318 }
20319
20320
20321 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20322 PyObject *resultobj = 0;
20323 bool result;
20324
20325 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
20326 {
20327 PyThreadState* __tstate = wxPyBeginAllowThreads();
20328 result = (bool)wxPyArtProvider::PopProvider();
20329 wxPyEndAllowThreads(__tstate);
20330 if (PyErr_Occurred()) SWIG_fail;
20331 }
20332 {
20333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20334 }
20335 return resultobj;
20336 fail:
20337 return NULL;
20338 }
20339
20340
20341 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20342 PyObject *resultobj = 0;
20343 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20344 bool result;
20345 void *argp1 = 0 ;
20346 int res1 = 0 ;
20347 PyObject * obj0 = 0 ;
20348 char * kwnames[] = {
20349 (char *) "provider", NULL
20350 };
20351
20352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
20353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20354 if (!SWIG_IsOK(res1)) {
20355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20356 }
20357 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20358 {
20359 PyThreadState* __tstate = wxPyBeginAllowThreads();
20360 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
20361 wxPyEndAllowThreads(__tstate);
20362 if (PyErr_Occurred()) SWIG_fail;
20363 }
20364 {
20365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20366 }
20367 return resultobj;
20368 fail:
20369 return NULL;
20370 }
20371
20372
20373 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20374 PyObject *resultobj = 0;
20375 wxString *arg1 = 0 ;
20376 wxString const &arg2_defvalue = wxPyART_OTHER ;
20377 wxString *arg2 = (wxString *) &arg2_defvalue ;
20378 wxSize const &arg3_defvalue = wxDefaultSize ;
20379 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20380 wxBitmap result;
20381 bool temp1 = false ;
20382 bool temp2 = false ;
20383 wxSize temp3 ;
20384 PyObject * obj0 = 0 ;
20385 PyObject * obj1 = 0 ;
20386 PyObject * obj2 = 0 ;
20387 char * kwnames[] = {
20388 (char *) "id",(char *) "client",(char *) "size", NULL
20389 };
20390
20391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20392 {
20393 arg1 = wxString_in_helper(obj0);
20394 if (arg1 == NULL) SWIG_fail;
20395 temp1 = true;
20396 }
20397 if (obj1) {
20398 {
20399 arg2 = wxString_in_helper(obj1);
20400 if (arg2 == NULL) SWIG_fail;
20401 temp2 = true;
20402 }
20403 }
20404 if (obj2) {
20405 {
20406 arg3 = &temp3;
20407 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20408 }
20409 }
20410 {
20411 if (!wxPyCheckForApp()) SWIG_fail;
20412 PyThreadState* __tstate = wxPyBeginAllowThreads();
20413 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20414 wxPyEndAllowThreads(__tstate);
20415 if (PyErr_Occurred()) SWIG_fail;
20416 }
20417 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20418 {
20419 if (temp1)
20420 delete arg1;
20421 }
20422 {
20423 if (temp2)
20424 delete arg2;
20425 }
20426 return resultobj;
20427 fail:
20428 {
20429 if (temp1)
20430 delete arg1;
20431 }
20432 {
20433 if (temp2)
20434 delete arg2;
20435 }
20436 return NULL;
20437 }
20438
20439
20440 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20441 PyObject *resultobj = 0;
20442 wxString *arg1 = 0 ;
20443 wxString const &arg2_defvalue = wxPyART_OTHER ;
20444 wxString *arg2 = (wxString *) &arg2_defvalue ;
20445 wxSize const &arg3_defvalue = wxDefaultSize ;
20446 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20447 wxIcon result;
20448 bool temp1 = false ;
20449 bool temp2 = false ;
20450 wxSize temp3 ;
20451 PyObject * obj0 = 0 ;
20452 PyObject * obj1 = 0 ;
20453 PyObject * obj2 = 0 ;
20454 char * kwnames[] = {
20455 (char *) "id",(char *) "client",(char *) "size", NULL
20456 };
20457
20458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20459 {
20460 arg1 = wxString_in_helper(obj0);
20461 if (arg1 == NULL) SWIG_fail;
20462 temp1 = true;
20463 }
20464 if (obj1) {
20465 {
20466 arg2 = wxString_in_helper(obj1);
20467 if (arg2 == NULL) SWIG_fail;
20468 temp2 = true;
20469 }
20470 }
20471 if (obj2) {
20472 {
20473 arg3 = &temp3;
20474 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20475 }
20476 }
20477 {
20478 if (!wxPyCheckForApp()) SWIG_fail;
20479 PyThreadState* __tstate = wxPyBeginAllowThreads();
20480 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20481 wxPyEndAllowThreads(__tstate);
20482 if (PyErr_Occurred()) SWIG_fail;
20483 }
20484 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20485 {
20486 if (temp1)
20487 delete arg1;
20488 }
20489 {
20490 if (temp2)
20491 delete arg2;
20492 }
20493 return resultobj;
20494 fail:
20495 {
20496 if (temp1)
20497 delete arg1;
20498 }
20499 {
20500 if (temp2)
20501 delete arg2;
20502 }
20503 return NULL;
20504 }
20505
20506
20507 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20508 PyObject *resultobj = 0;
20509 wxString *arg1 = 0 ;
20510 bool arg2 = (bool) false ;
20511 wxSize result;
20512 bool temp1 = false ;
20513 bool val2 ;
20514 int ecode2 = 0 ;
20515 PyObject * obj0 = 0 ;
20516 PyObject * obj1 = 0 ;
20517 char * kwnames[] = {
20518 (char *) "client",(char *) "platform_dependent", NULL
20519 };
20520
20521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20522 {
20523 arg1 = wxString_in_helper(obj0);
20524 if (arg1 == NULL) SWIG_fail;
20525 temp1 = true;
20526 }
20527 if (obj1) {
20528 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20529 if (!SWIG_IsOK(ecode2)) {
20530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20531 }
20532 arg2 = static_cast< bool >(val2);
20533 }
20534 {
20535 PyThreadState* __tstate = wxPyBeginAllowThreads();
20536 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20537 wxPyEndAllowThreads(__tstate);
20538 if (PyErr_Occurred()) SWIG_fail;
20539 }
20540 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20541 {
20542 if (temp1)
20543 delete arg1;
20544 }
20545 return resultobj;
20546 fail:
20547 {
20548 if (temp1)
20549 delete arg1;
20550 }
20551 return NULL;
20552 }
20553
20554
20555 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20556 PyObject *resultobj = 0;
20557 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20558 void *argp1 = 0 ;
20559 int res1 = 0 ;
20560 PyObject *swig_obj[1] ;
20561
20562 if (!args) SWIG_fail;
20563 swig_obj[0] = args;
20564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20565 if (!SWIG_IsOK(res1)) {
20566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20567 }
20568 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20569 {
20570 PyThreadState* __tstate = wxPyBeginAllowThreads();
20571 wxPyArtProvider_Destroy(arg1);
20572 wxPyEndAllowThreads(__tstate);
20573 if (PyErr_Occurred()) SWIG_fail;
20574 }
20575 resultobj = SWIG_Py_Void();
20576 return resultobj;
20577 fail:
20578 return NULL;
20579 }
20580
20581
20582 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20583 PyObject *obj;
20584 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20585 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20586 return SWIG_Py_Void();
20587 }
20588
20589 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20590 return SWIG_Python_InitShadowInstance(args);
20591 }
20592
20593 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20594 PyObject *resultobj = 0;
20595 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20596 void *argp1 = 0 ;
20597 int res1 = 0 ;
20598 PyObject *swig_obj[1] ;
20599
20600 if (!args) SWIG_fail;
20601 swig_obj[0] = args;
20602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20603 if (!SWIG_IsOK(res1)) {
20604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20605 }
20606 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20607 {
20608 PyThreadState* __tstate = wxPyBeginAllowThreads();
20609 delete arg1;
20610
20611 wxPyEndAllowThreads(__tstate);
20612 if (PyErr_Occurred()) SWIG_fail;
20613 }
20614 resultobj = SWIG_Py_Void();
20615 return resultobj;
20616 fail:
20617 return NULL;
20618 }
20619
20620
20621 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20622 PyObject *resultobj = 0;
20623 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20624 wxConfigBase *result = 0 ;
20625 int res1 = 0 ;
20626 PyObject * obj0 = 0 ;
20627 char * kwnames[] = {
20628 (char *) "config", NULL
20629 };
20630
20631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20632 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20633 if (!SWIG_IsOK(res1)) {
20634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20635 }
20636 {
20637 PyThreadState* __tstate = wxPyBeginAllowThreads();
20638 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20639 wxPyEndAllowThreads(__tstate);
20640 if (PyErr_Occurred()) SWIG_fail;
20641 }
20642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20643 return resultobj;
20644 fail:
20645 return NULL;
20646 }
20647
20648
20649 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20650 PyObject *resultobj = 0;
20651 bool arg1 = (bool) true ;
20652 wxConfigBase *result = 0 ;
20653 bool val1 ;
20654 int ecode1 = 0 ;
20655 PyObject * obj0 = 0 ;
20656 char * kwnames[] = {
20657 (char *) "createOnDemand", NULL
20658 };
20659
20660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20661 if (obj0) {
20662 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20663 if (!SWIG_IsOK(ecode1)) {
20664 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20665 }
20666 arg1 = static_cast< bool >(val1);
20667 }
20668 {
20669 PyThreadState* __tstate = wxPyBeginAllowThreads();
20670 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20671 wxPyEndAllowThreads(__tstate);
20672 if (PyErr_Occurred()) SWIG_fail;
20673 }
20674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20675 return resultobj;
20676 fail:
20677 return NULL;
20678 }
20679
20680
20681 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20682 PyObject *resultobj = 0;
20683 wxConfigBase *result = 0 ;
20684
20685 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20686 {
20687 PyThreadState* __tstate = wxPyBeginAllowThreads();
20688 result = (wxConfigBase *)wxConfigBase::Create();
20689 wxPyEndAllowThreads(__tstate);
20690 if (PyErr_Occurred()) SWIG_fail;
20691 }
20692 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20693 return resultobj;
20694 fail:
20695 return NULL;
20696 }
20697
20698
20699 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20700 PyObject *resultobj = 0;
20701
20702 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20703 {
20704 PyThreadState* __tstate = wxPyBeginAllowThreads();
20705 wxConfigBase::DontCreateOnDemand();
20706 wxPyEndAllowThreads(__tstate);
20707 if (PyErr_Occurred()) SWIG_fail;
20708 }
20709 resultobj = SWIG_Py_Void();
20710 return resultobj;
20711 fail:
20712 return NULL;
20713 }
20714
20715
20716 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20717 PyObject *resultobj = 0;
20718 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20719 wxString *arg2 = 0 ;
20720 void *argp1 = 0 ;
20721 int res1 = 0 ;
20722 bool temp2 = false ;
20723 PyObject * obj0 = 0 ;
20724 PyObject * obj1 = 0 ;
20725 char * kwnames[] = {
20726 (char *) "self",(char *) "path", NULL
20727 };
20728
20729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
20730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20731 if (!SWIG_IsOK(res1)) {
20732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20733 }
20734 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20735 {
20736 arg2 = wxString_in_helper(obj1);
20737 if (arg2 == NULL) SWIG_fail;
20738 temp2 = true;
20739 }
20740 {
20741 PyThreadState* __tstate = wxPyBeginAllowThreads();
20742 (arg1)->SetPath((wxString const &)*arg2);
20743 wxPyEndAllowThreads(__tstate);
20744 if (PyErr_Occurred()) SWIG_fail;
20745 }
20746 resultobj = SWIG_Py_Void();
20747 {
20748 if (temp2)
20749 delete arg2;
20750 }
20751 return resultobj;
20752 fail:
20753 {
20754 if (temp2)
20755 delete arg2;
20756 }
20757 return NULL;
20758 }
20759
20760
20761 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20762 PyObject *resultobj = 0;
20763 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20764 wxString *result = 0 ;
20765 void *argp1 = 0 ;
20766 int res1 = 0 ;
20767 PyObject *swig_obj[1] ;
20768
20769 if (!args) SWIG_fail;
20770 swig_obj[0] = args;
20771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20772 if (!SWIG_IsOK(res1)) {
20773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20774 }
20775 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20776 {
20777 PyThreadState* __tstate = wxPyBeginAllowThreads();
20778 {
20779 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
20780 result = (wxString *) &_result_ref;
20781 }
20782 wxPyEndAllowThreads(__tstate);
20783 if (PyErr_Occurred()) SWIG_fail;
20784 }
20785 {
20786 #if wxUSE_UNICODE
20787 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
20788 #else
20789 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
20790 #endif
20791 }
20792 return resultobj;
20793 fail:
20794 return NULL;
20795 }
20796
20797
20798 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20799 PyObject *resultobj = 0;
20800 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20801 PyObject *result = 0 ;
20802 void *argp1 = 0 ;
20803 int res1 = 0 ;
20804 PyObject *swig_obj[1] ;
20805
20806 if (!args) SWIG_fail;
20807 swig_obj[0] = args;
20808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20809 if (!SWIG_IsOK(res1)) {
20810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20811 }
20812 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20813 {
20814 PyThreadState* __tstate = wxPyBeginAllowThreads();
20815 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
20816 wxPyEndAllowThreads(__tstate);
20817 if (PyErr_Occurred()) SWIG_fail;
20818 }
20819 resultobj = result;
20820 return resultobj;
20821 fail:
20822 return NULL;
20823 }
20824
20825
20826 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20827 PyObject *resultobj = 0;
20828 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20829 long arg2 ;
20830 PyObject *result = 0 ;
20831 void *argp1 = 0 ;
20832 int res1 = 0 ;
20833 long val2 ;
20834 int ecode2 = 0 ;
20835 PyObject * obj0 = 0 ;
20836 PyObject * obj1 = 0 ;
20837 char * kwnames[] = {
20838 (char *) "self",(char *) "index", NULL
20839 };
20840
20841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20843 if (!SWIG_IsOK(res1)) {
20844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20845 }
20846 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20847 ecode2 = SWIG_AsVal_long(obj1, &val2);
20848 if (!SWIG_IsOK(ecode2)) {
20849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
20850 }
20851 arg2 = static_cast< long >(val2);
20852 {
20853 PyThreadState* __tstate = wxPyBeginAllowThreads();
20854 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
20855 wxPyEndAllowThreads(__tstate);
20856 if (PyErr_Occurred()) SWIG_fail;
20857 }
20858 resultobj = result;
20859 return resultobj;
20860 fail:
20861 return NULL;
20862 }
20863
20864
20865 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20866 PyObject *resultobj = 0;
20867 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20868 PyObject *result = 0 ;
20869 void *argp1 = 0 ;
20870 int res1 = 0 ;
20871 PyObject *swig_obj[1] ;
20872
20873 if (!args) SWIG_fail;
20874 swig_obj[0] = args;
20875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20876 if (!SWIG_IsOK(res1)) {
20877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20878 }
20879 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20880 {
20881 PyThreadState* __tstate = wxPyBeginAllowThreads();
20882 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
20883 wxPyEndAllowThreads(__tstate);
20884 if (PyErr_Occurred()) SWIG_fail;
20885 }
20886 resultobj = result;
20887 return resultobj;
20888 fail:
20889 return NULL;
20890 }
20891
20892
20893 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20894 PyObject *resultobj = 0;
20895 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20896 long arg2 ;
20897 PyObject *result = 0 ;
20898 void *argp1 = 0 ;
20899 int res1 = 0 ;
20900 long val2 ;
20901 int ecode2 = 0 ;
20902 PyObject * obj0 = 0 ;
20903 PyObject * obj1 = 0 ;
20904 char * kwnames[] = {
20905 (char *) "self",(char *) "index", NULL
20906 };
20907
20908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20910 if (!SWIG_IsOK(res1)) {
20911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20912 }
20913 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20914 ecode2 = SWIG_AsVal_long(obj1, &val2);
20915 if (!SWIG_IsOK(ecode2)) {
20916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
20917 }
20918 arg2 = static_cast< long >(val2);
20919 {
20920 PyThreadState* __tstate = wxPyBeginAllowThreads();
20921 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
20922 wxPyEndAllowThreads(__tstate);
20923 if (PyErr_Occurred()) SWIG_fail;
20924 }
20925 resultobj = result;
20926 return resultobj;
20927 fail:
20928 return NULL;
20929 }
20930
20931
20932 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20933 PyObject *resultobj = 0;
20934 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20935 bool arg2 = (bool) false ;
20936 size_t result;
20937 void *argp1 = 0 ;
20938 int res1 = 0 ;
20939 bool val2 ;
20940 int ecode2 = 0 ;
20941 PyObject * obj0 = 0 ;
20942 PyObject * obj1 = 0 ;
20943 char * kwnames[] = {
20944 (char *) "self",(char *) "recursive", NULL
20945 };
20946
20947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
20948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20949 if (!SWIG_IsOK(res1)) {
20950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20951 }
20952 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20953 if (obj1) {
20954 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20955 if (!SWIG_IsOK(ecode2)) {
20956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
20957 }
20958 arg2 = static_cast< bool >(val2);
20959 }
20960 {
20961 PyThreadState* __tstate = wxPyBeginAllowThreads();
20962 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
20963 wxPyEndAllowThreads(__tstate);
20964 if (PyErr_Occurred()) SWIG_fail;
20965 }
20966 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20967 return resultobj;
20968 fail:
20969 return NULL;
20970 }
20971
20972
20973 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20974 PyObject *resultobj = 0;
20975 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20976 bool arg2 = (bool) false ;
20977 size_t result;
20978 void *argp1 = 0 ;
20979 int res1 = 0 ;
20980 bool val2 ;
20981 int ecode2 = 0 ;
20982 PyObject * obj0 = 0 ;
20983 PyObject * obj1 = 0 ;
20984 char * kwnames[] = {
20985 (char *) "self",(char *) "recursive", NULL
20986 };
20987
20988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
20989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20990 if (!SWIG_IsOK(res1)) {
20991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20992 }
20993 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20994 if (obj1) {
20995 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20996 if (!SWIG_IsOK(ecode2)) {
20997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
20998 }
20999 arg2 = static_cast< bool >(val2);
21000 }
21001 {
21002 PyThreadState* __tstate = wxPyBeginAllowThreads();
21003 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21004 wxPyEndAllowThreads(__tstate);
21005 if (PyErr_Occurred()) SWIG_fail;
21006 }
21007 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21008 return resultobj;
21009 fail:
21010 return NULL;
21011 }
21012
21013
21014 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21015 PyObject *resultobj = 0;
21016 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21017 wxString *arg2 = 0 ;
21018 bool result;
21019 void *argp1 = 0 ;
21020 int res1 = 0 ;
21021 bool temp2 = false ;
21022 PyObject * obj0 = 0 ;
21023 PyObject * obj1 = 0 ;
21024 char * kwnames[] = {
21025 (char *) "self",(char *) "name", NULL
21026 };
21027
21028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21030 if (!SWIG_IsOK(res1)) {
21031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21032 }
21033 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21034 {
21035 arg2 = wxString_in_helper(obj1);
21036 if (arg2 == NULL) SWIG_fail;
21037 temp2 = true;
21038 }
21039 {
21040 PyThreadState* __tstate = wxPyBeginAllowThreads();
21041 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21042 wxPyEndAllowThreads(__tstate);
21043 if (PyErr_Occurred()) SWIG_fail;
21044 }
21045 {
21046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21047 }
21048 {
21049 if (temp2)
21050 delete arg2;
21051 }
21052 return resultobj;
21053 fail:
21054 {
21055 if (temp2)
21056 delete arg2;
21057 }
21058 return NULL;
21059 }
21060
21061
21062 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21063 PyObject *resultobj = 0;
21064 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21065 wxString *arg2 = 0 ;
21066 bool result;
21067 void *argp1 = 0 ;
21068 int res1 = 0 ;
21069 bool temp2 = false ;
21070 PyObject * obj0 = 0 ;
21071 PyObject * obj1 = 0 ;
21072 char * kwnames[] = {
21073 (char *) "self",(char *) "name", NULL
21074 };
21075
21076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21078 if (!SWIG_IsOK(res1)) {
21079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21080 }
21081 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21082 {
21083 arg2 = wxString_in_helper(obj1);
21084 if (arg2 == NULL) SWIG_fail;
21085 temp2 = true;
21086 }
21087 {
21088 PyThreadState* __tstate = wxPyBeginAllowThreads();
21089 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21090 wxPyEndAllowThreads(__tstate);
21091 if (PyErr_Occurred()) SWIG_fail;
21092 }
21093 {
21094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21095 }
21096 {
21097 if (temp2)
21098 delete arg2;
21099 }
21100 return resultobj;
21101 fail:
21102 {
21103 if (temp2)
21104 delete arg2;
21105 }
21106 return NULL;
21107 }
21108
21109
21110 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21111 PyObject *resultobj = 0;
21112 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21113 wxString *arg2 = 0 ;
21114 bool result;
21115 void *argp1 = 0 ;
21116 int res1 = 0 ;
21117 bool temp2 = false ;
21118 PyObject * obj0 = 0 ;
21119 PyObject * obj1 = 0 ;
21120 char * kwnames[] = {
21121 (char *) "self",(char *) "name", NULL
21122 };
21123
21124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21126 if (!SWIG_IsOK(res1)) {
21127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21128 }
21129 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21130 {
21131 arg2 = wxString_in_helper(obj1);
21132 if (arg2 == NULL) SWIG_fail;
21133 temp2 = true;
21134 }
21135 {
21136 PyThreadState* __tstate = wxPyBeginAllowThreads();
21137 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21138 wxPyEndAllowThreads(__tstate);
21139 if (PyErr_Occurred()) SWIG_fail;
21140 }
21141 {
21142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21143 }
21144 {
21145 if (temp2)
21146 delete arg2;
21147 }
21148 return resultobj;
21149 fail:
21150 {
21151 if (temp2)
21152 delete arg2;
21153 }
21154 return NULL;
21155 }
21156
21157
21158 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21159 PyObject *resultobj = 0;
21160 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21161 wxString *arg2 = 0 ;
21162 wxConfigBase::EntryType result;
21163 void *argp1 = 0 ;
21164 int res1 = 0 ;
21165 bool temp2 = false ;
21166 PyObject * obj0 = 0 ;
21167 PyObject * obj1 = 0 ;
21168 char * kwnames[] = {
21169 (char *) "self",(char *) "name", NULL
21170 };
21171
21172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21174 if (!SWIG_IsOK(res1)) {
21175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21176 }
21177 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21178 {
21179 arg2 = wxString_in_helper(obj1);
21180 if (arg2 == NULL) SWIG_fail;
21181 temp2 = true;
21182 }
21183 {
21184 PyThreadState* __tstate = wxPyBeginAllowThreads();
21185 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21186 wxPyEndAllowThreads(__tstate);
21187 if (PyErr_Occurred()) SWIG_fail;
21188 }
21189 resultobj = SWIG_From_int(static_cast< int >(result));
21190 {
21191 if (temp2)
21192 delete arg2;
21193 }
21194 return resultobj;
21195 fail:
21196 {
21197 if (temp2)
21198 delete arg2;
21199 }
21200 return NULL;
21201 }
21202
21203
21204 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21205 PyObject *resultobj = 0;
21206 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21207 wxString *arg2 = 0 ;
21208 wxString const &arg3_defvalue = wxPyEmptyString ;
21209 wxString *arg3 = (wxString *) &arg3_defvalue ;
21210 wxString result;
21211 void *argp1 = 0 ;
21212 int res1 = 0 ;
21213 bool temp2 = false ;
21214 bool temp3 = false ;
21215 PyObject * obj0 = 0 ;
21216 PyObject * obj1 = 0 ;
21217 PyObject * obj2 = 0 ;
21218 char * kwnames[] = {
21219 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21220 };
21221
21222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21224 if (!SWIG_IsOK(res1)) {
21225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21226 }
21227 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21228 {
21229 arg2 = wxString_in_helper(obj1);
21230 if (arg2 == NULL) SWIG_fail;
21231 temp2 = true;
21232 }
21233 if (obj2) {
21234 {
21235 arg3 = wxString_in_helper(obj2);
21236 if (arg3 == NULL) SWIG_fail;
21237 temp3 = true;
21238 }
21239 }
21240 {
21241 PyThreadState* __tstate = wxPyBeginAllowThreads();
21242 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21243 wxPyEndAllowThreads(__tstate);
21244 if (PyErr_Occurred()) SWIG_fail;
21245 }
21246 {
21247 #if wxUSE_UNICODE
21248 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21249 #else
21250 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21251 #endif
21252 }
21253 {
21254 if (temp2)
21255 delete arg2;
21256 }
21257 {
21258 if (temp3)
21259 delete arg3;
21260 }
21261 return resultobj;
21262 fail:
21263 {
21264 if (temp2)
21265 delete arg2;
21266 }
21267 {
21268 if (temp3)
21269 delete arg3;
21270 }
21271 return NULL;
21272 }
21273
21274
21275 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21276 PyObject *resultobj = 0;
21277 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21278 wxString *arg2 = 0 ;
21279 long arg3 = (long) 0 ;
21280 long result;
21281 void *argp1 = 0 ;
21282 int res1 = 0 ;
21283 bool temp2 = false ;
21284 long val3 ;
21285 int ecode3 = 0 ;
21286 PyObject * obj0 = 0 ;
21287 PyObject * obj1 = 0 ;
21288 PyObject * obj2 = 0 ;
21289 char * kwnames[] = {
21290 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21291 };
21292
21293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21295 if (!SWIG_IsOK(res1)) {
21296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21297 }
21298 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21299 {
21300 arg2 = wxString_in_helper(obj1);
21301 if (arg2 == NULL) SWIG_fail;
21302 temp2 = true;
21303 }
21304 if (obj2) {
21305 ecode3 = SWIG_AsVal_long(obj2, &val3);
21306 if (!SWIG_IsOK(ecode3)) {
21307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21308 }
21309 arg3 = static_cast< long >(val3);
21310 }
21311 {
21312 PyThreadState* __tstate = wxPyBeginAllowThreads();
21313 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21314 wxPyEndAllowThreads(__tstate);
21315 if (PyErr_Occurred()) SWIG_fail;
21316 }
21317 resultobj = SWIG_From_long(static_cast< long >(result));
21318 {
21319 if (temp2)
21320 delete arg2;
21321 }
21322 return resultobj;
21323 fail:
21324 {
21325 if (temp2)
21326 delete arg2;
21327 }
21328 return NULL;
21329 }
21330
21331
21332 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21333 PyObject *resultobj = 0;
21334 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21335 wxString *arg2 = 0 ;
21336 double arg3 = (double) 0.0 ;
21337 double result;
21338 void *argp1 = 0 ;
21339 int res1 = 0 ;
21340 bool temp2 = false ;
21341 double val3 ;
21342 int ecode3 = 0 ;
21343 PyObject * obj0 = 0 ;
21344 PyObject * obj1 = 0 ;
21345 PyObject * obj2 = 0 ;
21346 char * kwnames[] = {
21347 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21348 };
21349
21350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21352 if (!SWIG_IsOK(res1)) {
21353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21354 }
21355 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21356 {
21357 arg2 = wxString_in_helper(obj1);
21358 if (arg2 == NULL) SWIG_fail;
21359 temp2 = true;
21360 }
21361 if (obj2) {
21362 ecode3 = SWIG_AsVal_double(obj2, &val3);
21363 if (!SWIG_IsOK(ecode3)) {
21364 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21365 }
21366 arg3 = static_cast< double >(val3);
21367 }
21368 {
21369 PyThreadState* __tstate = wxPyBeginAllowThreads();
21370 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21371 wxPyEndAllowThreads(__tstate);
21372 if (PyErr_Occurred()) SWIG_fail;
21373 }
21374 resultobj = SWIG_From_double(static_cast< double >(result));
21375 {
21376 if (temp2)
21377 delete arg2;
21378 }
21379 return resultobj;
21380 fail:
21381 {
21382 if (temp2)
21383 delete arg2;
21384 }
21385 return NULL;
21386 }
21387
21388
21389 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21390 PyObject *resultobj = 0;
21391 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21392 wxString *arg2 = 0 ;
21393 bool arg3 = (bool) false ;
21394 bool result;
21395 void *argp1 = 0 ;
21396 int res1 = 0 ;
21397 bool temp2 = false ;
21398 bool val3 ;
21399 int ecode3 = 0 ;
21400 PyObject * obj0 = 0 ;
21401 PyObject * obj1 = 0 ;
21402 PyObject * obj2 = 0 ;
21403 char * kwnames[] = {
21404 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21405 };
21406
21407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21409 if (!SWIG_IsOK(res1)) {
21410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21411 }
21412 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21413 {
21414 arg2 = wxString_in_helper(obj1);
21415 if (arg2 == NULL) SWIG_fail;
21416 temp2 = true;
21417 }
21418 if (obj2) {
21419 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21420 if (!SWIG_IsOK(ecode3)) {
21421 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21422 }
21423 arg3 = static_cast< bool >(val3);
21424 }
21425 {
21426 PyThreadState* __tstate = wxPyBeginAllowThreads();
21427 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21428 wxPyEndAllowThreads(__tstate);
21429 if (PyErr_Occurred()) SWIG_fail;
21430 }
21431 {
21432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21433 }
21434 {
21435 if (temp2)
21436 delete arg2;
21437 }
21438 return resultobj;
21439 fail:
21440 {
21441 if (temp2)
21442 delete arg2;
21443 }
21444 return NULL;
21445 }
21446
21447
21448 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21449 PyObject *resultobj = 0;
21450 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21451 wxString *arg2 = 0 ;
21452 wxString *arg3 = 0 ;
21453 bool result;
21454 void *argp1 = 0 ;
21455 int res1 = 0 ;
21456 bool temp2 = false ;
21457 bool temp3 = false ;
21458 PyObject * obj0 = 0 ;
21459 PyObject * obj1 = 0 ;
21460 PyObject * obj2 = 0 ;
21461 char * kwnames[] = {
21462 (char *) "self",(char *) "key",(char *) "value", NULL
21463 };
21464
21465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21467 if (!SWIG_IsOK(res1)) {
21468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21469 }
21470 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21471 {
21472 arg2 = wxString_in_helper(obj1);
21473 if (arg2 == NULL) SWIG_fail;
21474 temp2 = true;
21475 }
21476 {
21477 arg3 = wxString_in_helper(obj2);
21478 if (arg3 == NULL) SWIG_fail;
21479 temp3 = true;
21480 }
21481 {
21482 PyThreadState* __tstate = wxPyBeginAllowThreads();
21483 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21484 wxPyEndAllowThreads(__tstate);
21485 if (PyErr_Occurred()) SWIG_fail;
21486 }
21487 {
21488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21489 }
21490 {
21491 if (temp2)
21492 delete arg2;
21493 }
21494 {
21495 if (temp3)
21496 delete arg3;
21497 }
21498 return resultobj;
21499 fail:
21500 {
21501 if (temp2)
21502 delete arg2;
21503 }
21504 {
21505 if (temp3)
21506 delete arg3;
21507 }
21508 return NULL;
21509 }
21510
21511
21512 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21513 PyObject *resultobj = 0;
21514 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21515 wxString *arg2 = 0 ;
21516 long arg3 ;
21517 bool result;
21518 void *argp1 = 0 ;
21519 int res1 = 0 ;
21520 bool temp2 = false ;
21521 long val3 ;
21522 int ecode3 = 0 ;
21523 PyObject * obj0 = 0 ;
21524 PyObject * obj1 = 0 ;
21525 PyObject * obj2 = 0 ;
21526 char * kwnames[] = {
21527 (char *) "self",(char *) "key",(char *) "value", NULL
21528 };
21529
21530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21532 if (!SWIG_IsOK(res1)) {
21533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21534 }
21535 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21536 {
21537 arg2 = wxString_in_helper(obj1);
21538 if (arg2 == NULL) SWIG_fail;
21539 temp2 = true;
21540 }
21541 ecode3 = SWIG_AsVal_long(obj2, &val3);
21542 if (!SWIG_IsOK(ecode3)) {
21543 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21544 }
21545 arg3 = static_cast< long >(val3);
21546 {
21547 PyThreadState* __tstate = wxPyBeginAllowThreads();
21548 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21549 wxPyEndAllowThreads(__tstate);
21550 if (PyErr_Occurred()) SWIG_fail;
21551 }
21552 {
21553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21554 }
21555 {
21556 if (temp2)
21557 delete arg2;
21558 }
21559 return resultobj;
21560 fail:
21561 {
21562 if (temp2)
21563 delete arg2;
21564 }
21565 return NULL;
21566 }
21567
21568
21569 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21570 PyObject *resultobj = 0;
21571 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21572 wxString *arg2 = 0 ;
21573 double arg3 ;
21574 bool result;
21575 void *argp1 = 0 ;
21576 int res1 = 0 ;
21577 bool temp2 = false ;
21578 double val3 ;
21579 int ecode3 = 0 ;
21580 PyObject * obj0 = 0 ;
21581 PyObject * obj1 = 0 ;
21582 PyObject * obj2 = 0 ;
21583 char * kwnames[] = {
21584 (char *) "self",(char *) "key",(char *) "value", NULL
21585 };
21586
21587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21589 if (!SWIG_IsOK(res1)) {
21590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21591 }
21592 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21593 {
21594 arg2 = wxString_in_helper(obj1);
21595 if (arg2 == NULL) SWIG_fail;
21596 temp2 = true;
21597 }
21598 ecode3 = SWIG_AsVal_double(obj2, &val3);
21599 if (!SWIG_IsOK(ecode3)) {
21600 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21601 }
21602 arg3 = static_cast< double >(val3);
21603 {
21604 PyThreadState* __tstate = wxPyBeginAllowThreads();
21605 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21606 wxPyEndAllowThreads(__tstate);
21607 if (PyErr_Occurred()) SWIG_fail;
21608 }
21609 {
21610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21611 }
21612 {
21613 if (temp2)
21614 delete arg2;
21615 }
21616 return resultobj;
21617 fail:
21618 {
21619 if (temp2)
21620 delete arg2;
21621 }
21622 return NULL;
21623 }
21624
21625
21626 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21627 PyObject *resultobj = 0;
21628 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21629 wxString *arg2 = 0 ;
21630 bool arg3 ;
21631 bool result;
21632 void *argp1 = 0 ;
21633 int res1 = 0 ;
21634 bool temp2 = false ;
21635 bool val3 ;
21636 int ecode3 = 0 ;
21637 PyObject * obj0 = 0 ;
21638 PyObject * obj1 = 0 ;
21639 PyObject * obj2 = 0 ;
21640 char * kwnames[] = {
21641 (char *) "self",(char *) "key",(char *) "value", NULL
21642 };
21643
21644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21646 if (!SWIG_IsOK(res1)) {
21647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21648 }
21649 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21650 {
21651 arg2 = wxString_in_helper(obj1);
21652 if (arg2 == NULL) SWIG_fail;
21653 temp2 = true;
21654 }
21655 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21656 if (!SWIG_IsOK(ecode3)) {
21657 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21658 }
21659 arg3 = static_cast< bool >(val3);
21660 {
21661 PyThreadState* __tstate = wxPyBeginAllowThreads();
21662 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21663 wxPyEndAllowThreads(__tstate);
21664 if (PyErr_Occurred()) SWIG_fail;
21665 }
21666 {
21667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21668 }
21669 {
21670 if (temp2)
21671 delete arg2;
21672 }
21673 return resultobj;
21674 fail:
21675 {
21676 if (temp2)
21677 delete arg2;
21678 }
21679 return NULL;
21680 }
21681
21682
21683 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21684 PyObject *resultobj = 0;
21685 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21686 bool arg2 = (bool) false ;
21687 bool result;
21688 void *argp1 = 0 ;
21689 int res1 = 0 ;
21690 bool val2 ;
21691 int ecode2 = 0 ;
21692 PyObject * obj0 = 0 ;
21693 PyObject * obj1 = 0 ;
21694 char * kwnames[] = {
21695 (char *) "self",(char *) "currentOnly", NULL
21696 };
21697
21698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21700 if (!SWIG_IsOK(res1)) {
21701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21702 }
21703 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21704 if (obj1) {
21705 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21706 if (!SWIG_IsOK(ecode2)) {
21707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21708 }
21709 arg2 = static_cast< bool >(val2);
21710 }
21711 {
21712 PyThreadState* __tstate = wxPyBeginAllowThreads();
21713 result = (bool)(arg1)->Flush(arg2);
21714 wxPyEndAllowThreads(__tstate);
21715 if (PyErr_Occurred()) SWIG_fail;
21716 }
21717 {
21718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21719 }
21720 return resultobj;
21721 fail:
21722 return NULL;
21723 }
21724
21725
21726 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21727 PyObject *resultobj = 0;
21728 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21729 wxString *arg2 = 0 ;
21730 wxString *arg3 = 0 ;
21731 bool result;
21732 void *argp1 = 0 ;
21733 int res1 = 0 ;
21734 bool temp2 = false ;
21735 bool temp3 = false ;
21736 PyObject * obj0 = 0 ;
21737 PyObject * obj1 = 0 ;
21738 PyObject * obj2 = 0 ;
21739 char * kwnames[] = {
21740 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21741 };
21742
21743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21745 if (!SWIG_IsOK(res1)) {
21746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21747 }
21748 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21749 {
21750 arg2 = wxString_in_helper(obj1);
21751 if (arg2 == NULL) SWIG_fail;
21752 temp2 = true;
21753 }
21754 {
21755 arg3 = wxString_in_helper(obj2);
21756 if (arg3 == NULL) SWIG_fail;
21757 temp3 = true;
21758 }
21759 {
21760 PyThreadState* __tstate = wxPyBeginAllowThreads();
21761 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
21762 wxPyEndAllowThreads(__tstate);
21763 if (PyErr_Occurred()) SWIG_fail;
21764 }
21765 {
21766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21767 }
21768 {
21769 if (temp2)
21770 delete arg2;
21771 }
21772 {
21773 if (temp3)
21774 delete arg3;
21775 }
21776 return resultobj;
21777 fail:
21778 {
21779 if (temp2)
21780 delete arg2;
21781 }
21782 {
21783 if (temp3)
21784 delete arg3;
21785 }
21786 return NULL;
21787 }
21788
21789
21790 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21791 PyObject *resultobj = 0;
21792 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21793 wxString *arg2 = 0 ;
21794 wxString *arg3 = 0 ;
21795 bool result;
21796 void *argp1 = 0 ;
21797 int res1 = 0 ;
21798 bool temp2 = false ;
21799 bool temp3 = false ;
21800 PyObject * obj0 = 0 ;
21801 PyObject * obj1 = 0 ;
21802 PyObject * obj2 = 0 ;
21803 char * kwnames[] = {
21804 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21805 };
21806
21807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21809 if (!SWIG_IsOK(res1)) {
21810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21811 }
21812 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21813 {
21814 arg2 = wxString_in_helper(obj1);
21815 if (arg2 == NULL) SWIG_fail;
21816 temp2 = true;
21817 }
21818 {
21819 arg3 = wxString_in_helper(obj2);
21820 if (arg3 == NULL) SWIG_fail;
21821 temp3 = true;
21822 }
21823 {
21824 PyThreadState* __tstate = wxPyBeginAllowThreads();
21825 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
21826 wxPyEndAllowThreads(__tstate);
21827 if (PyErr_Occurred()) SWIG_fail;
21828 }
21829 {
21830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21831 }
21832 {
21833 if (temp2)
21834 delete arg2;
21835 }
21836 {
21837 if (temp3)
21838 delete arg3;
21839 }
21840 return resultobj;
21841 fail:
21842 {
21843 if (temp2)
21844 delete arg2;
21845 }
21846 {
21847 if (temp3)
21848 delete arg3;
21849 }
21850 return NULL;
21851 }
21852
21853
21854 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21855 PyObject *resultobj = 0;
21856 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21857 wxString *arg2 = 0 ;
21858 bool arg3 = (bool) true ;
21859 bool result;
21860 void *argp1 = 0 ;
21861 int res1 = 0 ;
21862 bool temp2 = false ;
21863 bool val3 ;
21864 int ecode3 = 0 ;
21865 PyObject * obj0 = 0 ;
21866 PyObject * obj1 = 0 ;
21867 PyObject * obj2 = 0 ;
21868 char * kwnames[] = {
21869 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
21870 };
21871
21872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21874 if (!SWIG_IsOK(res1)) {
21875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21876 }
21877 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21878 {
21879 arg2 = wxString_in_helper(obj1);
21880 if (arg2 == NULL) SWIG_fail;
21881 temp2 = true;
21882 }
21883 if (obj2) {
21884 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21885 if (!SWIG_IsOK(ecode3)) {
21886 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
21887 }
21888 arg3 = static_cast< bool >(val3);
21889 }
21890 {
21891 PyThreadState* __tstate = wxPyBeginAllowThreads();
21892 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
21893 wxPyEndAllowThreads(__tstate);
21894 if (PyErr_Occurred()) SWIG_fail;
21895 }
21896 {
21897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21898 }
21899 {
21900 if (temp2)
21901 delete arg2;
21902 }
21903 return resultobj;
21904 fail:
21905 {
21906 if (temp2)
21907 delete arg2;
21908 }
21909 return NULL;
21910 }
21911
21912
21913 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21914 PyObject *resultobj = 0;
21915 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21916 wxString *arg2 = 0 ;
21917 bool result;
21918 void *argp1 = 0 ;
21919 int res1 = 0 ;
21920 bool temp2 = false ;
21921 PyObject * obj0 = 0 ;
21922 PyObject * obj1 = 0 ;
21923 char * kwnames[] = {
21924 (char *) "self",(char *) "key", NULL
21925 };
21926
21927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21929 if (!SWIG_IsOK(res1)) {
21930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21931 }
21932 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21933 {
21934 arg2 = wxString_in_helper(obj1);
21935 if (arg2 == NULL) SWIG_fail;
21936 temp2 = true;
21937 }
21938 {
21939 PyThreadState* __tstate = wxPyBeginAllowThreads();
21940 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
21941 wxPyEndAllowThreads(__tstate);
21942 if (PyErr_Occurred()) SWIG_fail;
21943 }
21944 {
21945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21946 }
21947 {
21948 if (temp2)
21949 delete arg2;
21950 }
21951 return resultobj;
21952 fail:
21953 {
21954 if (temp2)
21955 delete arg2;
21956 }
21957 return NULL;
21958 }
21959
21960
21961 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21962 PyObject *resultobj = 0;
21963 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21964 bool result;
21965 void *argp1 = 0 ;
21966 int res1 = 0 ;
21967 PyObject *swig_obj[1] ;
21968
21969 if (!args) SWIG_fail;
21970 swig_obj[0] = args;
21971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21972 if (!SWIG_IsOK(res1)) {
21973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21974 }
21975 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21976 {
21977 PyThreadState* __tstate = wxPyBeginAllowThreads();
21978 result = (bool)(arg1)->DeleteAll();
21979 wxPyEndAllowThreads(__tstate);
21980 if (PyErr_Occurred()) SWIG_fail;
21981 }
21982 {
21983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21984 }
21985 return resultobj;
21986 fail:
21987 return NULL;
21988 }
21989
21990
21991 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21992 PyObject *resultobj = 0;
21993 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21994 bool arg2 = (bool) true ;
21995 void *argp1 = 0 ;
21996 int res1 = 0 ;
21997 bool val2 ;
21998 int ecode2 = 0 ;
21999 PyObject * obj0 = 0 ;
22000 PyObject * obj1 = 0 ;
22001 char * kwnames[] = {
22002 (char *) "self",(char *) "doIt", NULL
22003 };
22004
22005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22007 if (!SWIG_IsOK(res1)) {
22008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22009 }
22010 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22011 if (obj1) {
22012 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22013 if (!SWIG_IsOK(ecode2)) {
22014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22015 }
22016 arg2 = static_cast< bool >(val2);
22017 }
22018 {
22019 PyThreadState* __tstate = wxPyBeginAllowThreads();
22020 (arg1)->SetExpandEnvVars(arg2);
22021 wxPyEndAllowThreads(__tstate);
22022 if (PyErr_Occurred()) SWIG_fail;
22023 }
22024 resultobj = SWIG_Py_Void();
22025 return resultobj;
22026 fail:
22027 return NULL;
22028 }
22029
22030
22031 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22032 PyObject *resultobj = 0;
22033 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22034 bool result;
22035 void *argp1 = 0 ;
22036 int res1 = 0 ;
22037 PyObject *swig_obj[1] ;
22038
22039 if (!args) SWIG_fail;
22040 swig_obj[0] = args;
22041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22042 if (!SWIG_IsOK(res1)) {
22043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22044 }
22045 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22046 {
22047 PyThreadState* __tstate = wxPyBeginAllowThreads();
22048 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22049 wxPyEndAllowThreads(__tstate);
22050 if (PyErr_Occurred()) SWIG_fail;
22051 }
22052 {
22053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22054 }
22055 return resultobj;
22056 fail:
22057 return NULL;
22058 }
22059
22060
22061 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22062 PyObject *resultobj = 0;
22063 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22064 bool arg2 = (bool) true ;
22065 void *argp1 = 0 ;
22066 int res1 = 0 ;
22067 bool val2 ;
22068 int ecode2 = 0 ;
22069 PyObject * obj0 = 0 ;
22070 PyObject * obj1 = 0 ;
22071 char * kwnames[] = {
22072 (char *) "self",(char *) "doIt", NULL
22073 };
22074
22075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22077 if (!SWIG_IsOK(res1)) {
22078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22079 }
22080 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22081 if (obj1) {
22082 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22083 if (!SWIG_IsOK(ecode2)) {
22084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22085 }
22086 arg2 = static_cast< bool >(val2);
22087 }
22088 {
22089 PyThreadState* __tstate = wxPyBeginAllowThreads();
22090 (arg1)->SetRecordDefaults(arg2);
22091 wxPyEndAllowThreads(__tstate);
22092 if (PyErr_Occurred()) SWIG_fail;
22093 }
22094 resultobj = SWIG_Py_Void();
22095 return resultobj;
22096 fail:
22097 return NULL;
22098 }
22099
22100
22101 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22102 PyObject *resultobj = 0;
22103 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22104 bool result;
22105 void *argp1 = 0 ;
22106 int res1 = 0 ;
22107 PyObject *swig_obj[1] ;
22108
22109 if (!args) SWIG_fail;
22110 swig_obj[0] = args;
22111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22112 if (!SWIG_IsOK(res1)) {
22113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22114 }
22115 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22116 {
22117 PyThreadState* __tstate = wxPyBeginAllowThreads();
22118 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22119 wxPyEndAllowThreads(__tstate);
22120 if (PyErr_Occurred()) SWIG_fail;
22121 }
22122 {
22123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22124 }
22125 return resultobj;
22126 fail:
22127 return NULL;
22128 }
22129
22130
22131 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22132 PyObject *resultobj = 0;
22133 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22134 wxString *arg2 = 0 ;
22135 wxString result;
22136 void *argp1 = 0 ;
22137 int res1 = 0 ;
22138 bool temp2 = false ;
22139 PyObject * obj0 = 0 ;
22140 PyObject * obj1 = 0 ;
22141 char * kwnames[] = {
22142 (char *) "self",(char *) "str", NULL
22143 };
22144
22145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22147 if (!SWIG_IsOK(res1)) {
22148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22149 }
22150 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22151 {
22152 arg2 = wxString_in_helper(obj1);
22153 if (arg2 == NULL) SWIG_fail;
22154 temp2 = true;
22155 }
22156 {
22157 PyThreadState* __tstate = wxPyBeginAllowThreads();
22158 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22159 wxPyEndAllowThreads(__tstate);
22160 if (PyErr_Occurred()) SWIG_fail;
22161 }
22162 {
22163 #if wxUSE_UNICODE
22164 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22165 #else
22166 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22167 #endif
22168 }
22169 {
22170 if (temp2)
22171 delete arg2;
22172 }
22173 return resultobj;
22174 fail:
22175 {
22176 if (temp2)
22177 delete arg2;
22178 }
22179 return NULL;
22180 }
22181
22182
22183 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22184 PyObject *resultobj = 0;
22185 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22186 wxString result;
22187 void *argp1 = 0 ;
22188 int res1 = 0 ;
22189 PyObject *swig_obj[1] ;
22190
22191 if (!args) SWIG_fail;
22192 swig_obj[0] = args;
22193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22194 if (!SWIG_IsOK(res1)) {
22195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22196 }
22197 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22198 {
22199 PyThreadState* __tstate = wxPyBeginAllowThreads();
22200 result = ((wxConfigBase const *)arg1)->GetAppName();
22201 wxPyEndAllowThreads(__tstate);
22202 if (PyErr_Occurred()) SWIG_fail;
22203 }
22204 {
22205 #if wxUSE_UNICODE
22206 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22207 #else
22208 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22209 #endif
22210 }
22211 return resultobj;
22212 fail:
22213 return NULL;
22214 }
22215
22216
22217 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22218 PyObject *resultobj = 0;
22219 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22220 wxString result;
22221 void *argp1 = 0 ;
22222 int res1 = 0 ;
22223 PyObject *swig_obj[1] ;
22224
22225 if (!args) SWIG_fail;
22226 swig_obj[0] = args;
22227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22228 if (!SWIG_IsOK(res1)) {
22229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22230 }
22231 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22232 {
22233 PyThreadState* __tstate = wxPyBeginAllowThreads();
22234 result = ((wxConfigBase const *)arg1)->GetVendorName();
22235 wxPyEndAllowThreads(__tstate);
22236 if (PyErr_Occurred()) SWIG_fail;
22237 }
22238 {
22239 #if wxUSE_UNICODE
22240 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22241 #else
22242 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22243 #endif
22244 }
22245 return resultobj;
22246 fail:
22247 return NULL;
22248 }
22249
22250
22251 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22252 PyObject *resultobj = 0;
22253 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22254 wxString *arg2 = 0 ;
22255 void *argp1 = 0 ;
22256 int res1 = 0 ;
22257 bool temp2 = false ;
22258 PyObject * obj0 = 0 ;
22259 PyObject * obj1 = 0 ;
22260 char * kwnames[] = {
22261 (char *) "self",(char *) "appName", NULL
22262 };
22263
22264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22266 if (!SWIG_IsOK(res1)) {
22267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22268 }
22269 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22270 {
22271 arg2 = wxString_in_helper(obj1);
22272 if (arg2 == NULL) SWIG_fail;
22273 temp2 = true;
22274 }
22275 {
22276 PyThreadState* __tstate = wxPyBeginAllowThreads();
22277 (arg1)->SetAppName((wxString const &)*arg2);
22278 wxPyEndAllowThreads(__tstate);
22279 if (PyErr_Occurred()) SWIG_fail;
22280 }
22281 resultobj = SWIG_Py_Void();
22282 {
22283 if (temp2)
22284 delete arg2;
22285 }
22286 return resultobj;
22287 fail:
22288 {
22289 if (temp2)
22290 delete arg2;
22291 }
22292 return NULL;
22293 }
22294
22295
22296 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22297 PyObject *resultobj = 0;
22298 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22299 wxString *arg2 = 0 ;
22300 void *argp1 = 0 ;
22301 int res1 = 0 ;
22302 bool temp2 = false ;
22303 PyObject * obj0 = 0 ;
22304 PyObject * obj1 = 0 ;
22305 char * kwnames[] = {
22306 (char *) "self",(char *) "vendorName", NULL
22307 };
22308
22309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22311 if (!SWIG_IsOK(res1)) {
22312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22313 }
22314 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22315 {
22316 arg2 = wxString_in_helper(obj1);
22317 if (arg2 == NULL) SWIG_fail;
22318 temp2 = true;
22319 }
22320 {
22321 PyThreadState* __tstate = wxPyBeginAllowThreads();
22322 (arg1)->SetVendorName((wxString const &)*arg2);
22323 wxPyEndAllowThreads(__tstate);
22324 if (PyErr_Occurred()) SWIG_fail;
22325 }
22326 resultobj = SWIG_Py_Void();
22327 {
22328 if (temp2)
22329 delete arg2;
22330 }
22331 return resultobj;
22332 fail:
22333 {
22334 if (temp2)
22335 delete arg2;
22336 }
22337 return NULL;
22338 }
22339
22340
22341 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22342 PyObject *resultobj = 0;
22343 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22344 long arg2 ;
22345 void *argp1 = 0 ;
22346 int res1 = 0 ;
22347 long val2 ;
22348 int ecode2 = 0 ;
22349 PyObject * obj0 = 0 ;
22350 PyObject * obj1 = 0 ;
22351 char * kwnames[] = {
22352 (char *) "self",(char *) "style", NULL
22353 };
22354
22355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22357 if (!SWIG_IsOK(res1)) {
22358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22359 }
22360 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22361 ecode2 = SWIG_AsVal_long(obj1, &val2);
22362 if (!SWIG_IsOK(ecode2)) {
22363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22364 }
22365 arg2 = static_cast< long >(val2);
22366 {
22367 PyThreadState* __tstate = wxPyBeginAllowThreads();
22368 (arg1)->SetStyle(arg2);
22369 wxPyEndAllowThreads(__tstate);
22370 if (PyErr_Occurred()) SWIG_fail;
22371 }
22372 resultobj = SWIG_Py_Void();
22373 return resultobj;
22374 fail:
22375 return NULL;
22376 }
22377
22378
22379 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22380 PyObject *resultobj = 0;
22381 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22382 long result;
22383 void *argp1 = 0 ;
22384 int res1 = 0 ;
22385 PyObject *swig_obj[1] ;
22386
22387 if (!args) SWIG_fail;
22388 swig_obj[0] = args;
22389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22390 if (!SWIG_IsOK(res1)) {
22391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22392 }
22393 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22394 {
22395 PyThreadState* __tstate = wxPyBeginAllowThreads();
22396 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22397 wxPyEndAllowThreads(__tstate);
22398 if (PyErr_Occurred()) SWIG_fail;
22399 }
22400 resultobj = SWIG_From_long(static_cast< long >(result));
22401 return resultobj;
22402 fail:
22403 return NULL;
22404 }
22405
22406
22407 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22408 PyObject *obj;
22409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22410 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22411 return SWIG_Py_Void();
22412 }
22413
22414 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22415 PyObject *resultobj = 0;
22416 wxString const &arg1_defvalue = wxPyEmptyString ;
22417 wxString *arg1 = (wxString *) &arg1_defvalue ;
22418 wxString const &arg2_defvalue = wxPyEmptyString ;
22419 wxString *arg2 = (wxString *) &arg2_defvalue ;
22420 wxString const &arg3_defvalue = wxPyEmptyString ;
22421 wxString *arg3 = (wxString *) &arg3_defvalue ;
22422 wxString const &arg4_defvalue = wxPyEmptyString ;
22423 wxString *arg4 = (wxString *) &arg4_defvalue ;
22424 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22425 wxConfig *result = 0 ;
22426 bool temp1 = false ;
22427 bool temp2 = false ;
22428 bool temp3 = false ;
22429 bool temp4 = false ;
22430 long val5 ;
22431 int ecode5 = 0 ;
22432 PyObject * obj0 = 0 ;
22433 PyObject * obj1 = 0 ;
22434 PyObject * obj2 = 0 ;
22435 PyObject * obj3 = 0 ;
22436 PyObject * obj4 = 0 ;
22437 char * kwnames[] = {
22438 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22439 };
22440
22441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22442 if (obj0) {
22443 {
22444 arg1 = wxString_in_helper(obj0);
22445 if (arg1 == NULL) SWIG_fail;
22446 temp1 = true;
22447 }
22448 }
22449 if (obj1) {
22450 {
22451 arg2 = wxString_in_helper(obj1);
22452 if (arg2 == NULL) SWIG_fail;
22453 temp2 = true;
22454 }
22455 }
22456 if (obj2) {
22457 {
22458 arg3 = wxString_in_helper(obj2);
22459 if (arg3 == NULL) SWIG_fail;
22460 temp3 = true;
22461 }
22462 }
22463 if (obj3) {
22464 {
22465 arg4 = wxString_in_helper(obj3);
22466 if (arg4 == NULL) SWIG_fail;
22467 temp4 = true;
22468 }
22469 }
22470 if (obj4) {
22471 ecode5 = SWIG_AsVal_long(obj4, &val5);
22472 if (!SWIG_IsOK(ecode5)) {
22473 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22474 }
22475 arg5 = static_cast< long >(val5);
22476 }
22477 {
22478 PyThreadState* __tstate = wxPyBeginAllowThreads();
22479 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22480 wxPyEndAllowThreads(__tstate);
22481 if (PyErr_Occurred()) SWIG_fail;
22482 }
22483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22484 {
22485 if (temp1)
22486 delete arg1;
22487 }
22488 {
22489 if (temp2)
22490 delete arg2;
22491 }
22492 {
22493 if (temp3)
22494 delete arg3;
22495 }
22496 {
22497 if (temp4)
22498 delete arg4;
22499 }
22500 return resultobj;
22501 fail:
22502 {
22503 if (temp1)
22504 delete arg1;
22505 }
22506 {
22507 if (temp2)
22508 delete arg2;
22509 }
22510 {
22511 if (temp3)
22512 delete arg3;
22513 }
22514 {
22515 if (temp4)
22516 delete arg4;
22517 }
22518 return NULL;
22519 }
22520
22521
22522 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22523 PyObject *resultobj = 0;
22524 wxConfig *arg1 = (wxConfig *) 0 ;
22525 void *argp1 = 0 ;
22526 int res1 = 0 ;
22527 PyObject *swig_obj[1] ;
22528
22529 if (!args) SWIG_fail;
22530 swig_obj[0] = args;
22531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22532 if (!SWIG_IsOK(res1)) {
22533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22534 }
22535 arg1 = reinterpret_cast< wxConfig * >(argp1);
22536 {
22537 PyThreadState* __tstate = wxPyBeginAllowThreads();
22538 delete arg1;
22539
22540 wxPyEndAllowThreads(__tstate);
22541 if (PyErr_Occurred()) SWIG_fail;
22542 }
22543 resultobj = SWIG_Py_Void();
22544 return resultobj;
22545 fail:
22546 return NULL;
22547 }
22548
22549
22550 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22551 PyObject *obj;
22552 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22553 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22554 return SWIG_Py_Void();
22555 }
22556
22557 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22558 return SWIG_Python_InitShadowInstance(args);
22559 }
22560
22561 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22562 PyObject *resultobj = 0;
22563 wxString const &arg1_defvalue = wxPyEmptyString ;
22564 wxString *arg1 = (wxString *) &arg1_defvalue ;
22565 wxString const &arg2_defvalue = wxPyEmptyString ;
22566 wxString *arg2 = (wxString *) &arg2_defvalue ;
22567 wxString const &arg3_defvalue = wxPyEmptyString ;
22568 wxString *arg3 = (wxString *) &arg3_defvalue ;
22569 wxString const &arg4_defvalue = wxPyEmptyString ;
22570 wxString *arg4 = (wxString *) &arg4_defvalue ;
22571 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22572 wxFileConfig *result = 0 ;
22573 bool temp1 = false ;
22574 bool temp2 = false ;
22575 bool temp3 = false ;
22576 bool temp4 = false ;
22577 long val5 ;
22578 int ecode5 = 0 ;
22579 PyObject * obj0 = 0 ;
22580 PyObject * obj1 = 0 ;
22581 PyObject * obj2 = 0 ;
22582 PyObject * obj3 = 0 ;
22583 PyObject * obj4 = 0 ;
22584 char * kwnames[] = {
22585 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22586 };
22587
22588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22589 if (obj0) {
22590 {
22591 arg1 = wxString_in_helper(obj0);
22592 if (arg1 == NULL) SWIG_fail;
22593 temp1 = true;
22594 }
22595 }
22596 if (obj1) {
22597 {
22598 arg2 = wxString_in_helper(obj1);
22599 if (arg2 == NULL) SWIG_fail;
22600 temp2 = true;
22601 }
22602 }
22603 if (obj2) {
22604 {
22605 arg3 = wxString_in_helper(obj2);
22606 if (arg3 == NULL) SWIG_fail;
22607 temp3 = true;
22608 }
22609 }
22610 if (obj3) {
22611 {
22612 arg4 = wxString_in_helper(obj3);
22613 if (arg4 == NULL) SWIG_fail;
22614 temp4 = true;
22615 }
22616 }
22617 if (obj4) {
22618 ecode5 = SWIG_AsVal_long(obj4, &val5);
22619 if (!SWIG_IsOK(ecode5)) {
22620 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22621 }
22622 arg5 = static_cast< long >(val5);
22623 }
22624 {
22625 PyThreadState* __tstate = wxPyBeginAllowThreads();
22626 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22627 wxPyEndAllowThreads(__tstate);
22628 if (PyErr_Occurred()) SWIG_fail;
22629 }
22630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22631 {
22632 if (temp1)
22633 delete arg1;
22634 }
22635 {
22636 if (temp2)
22637 delete arg2;
22638 }
22639 {
22640 if (temp3)
22641 delete arg3;
22642 }
22643 {
22644 if (temp4)
22645 delete arg4;
22646 }
22647 return resultobj;
22648 fail:
22649 {
22650 if (temp1)
22651 delete arg1;
22652 }
22653 {
22654 if (temp2)
22655 delete arg2;
22656 }
22657 {
22658 if (temp3)
22659 delete arg3;
22660 }
22661 {
22662 if (temp4)
22663 delete arg4;
22664 }
22665 return NULL;
22666 }
22667
22668
22669 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22670 PyObject *resultobj = 0;
22671 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22672 void *argp1 = 0 ;
22673 int res1 = 0 ;
22674 PyObject *swig_obj[1] ;
22675
22676 if (!args) SWIG_fail;
22677 swig_obj[0] = args;
22678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22679 if (!SWIG_IsOK(res1)) {
22680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22681 }
22682 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22683 {
22684 PyThreadState* __tstate = wxPyBeginAllowThreads();
22685 delete arg1;
22686
22687 wxPyEndAllowThreads(__tstate);
22688 if (PyErr_Occurred()) SWIG_fail;
22689 }
22690 resultobj = SWIG_Py_Void();
22691 return resultobj;
22692 fail:
22693 return NULL;
22694 }
22695
22696
22697 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22698 PyObject *obj;
22699 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22700 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22701 return SWIG_Py_Void();
22702 }
22703
22704 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22705 return SWIG_Python_InitShadowInstance(args);
22706 }
22707
22708 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22709 PyObject *resultobj = 0;
22710 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22711 wxString *arg2 = 0 ;
22712 wxConfigPathChanger *result = 0 ;
22713 void *argp1 = 0 ;
22714 int res1 = 0 ;
22715 bool temp2 = false ;
22716 PyObject * obj0 = 0 ;
22717 PyObject * obj1 = 0 ;
22718 char * kwnames[] = {
22719 (char *) "config",(char *) "entry", NULL
22720 };
22721
22722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22724 if (!SWIG_IsOK(res1)) {
22725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22726 }
22727 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22728 {
22729 arg2 = wxString_in_helper(obj1);
22730 if (arg2 == NULL) SWIG_fail;
22731 temp2 = true;
22732 }
22733 {
22734 PyThreadState* __tstate = wxPyBeginAllowThreads();
22735 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
22736 wxPyEndAllowThreads(__tstate);
22737 if (PyErr_Occurred()) SWIG_fail;
22738 }
22739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
22740 {
22741 if (temp2)
22742 delete arg2;
22743 }
22744 return resultobj;
22745 fail:
22746 {
22747 if (temp2)
22748 delete arg2;
22749 }
22750 return NULL;
22751 }
22752
22753
22754 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22755 PyObject *resultobj = 0;
22756 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22757 void *argp1 = 0 ;
22758 int res1 = 0 ;
22759 PyObject *swig_obj[1] ;
22760
22761 if (!args) SWIG_fail;
22762 swig_obj[0] = args;
22763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
22764 if (!SWIG_IsOK(res1)) {
22765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
22766 }
22767 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22768 {
22769 PyThreadState* __tstate = wxPyBeginAllowThreads();
22770 delete arg1;
22771
22772 wxPyEndAllowThreads(__tstate);
22773 if (PyErr_Occurred()) SWIG_fail;
22774 }
22775 resultobj = SWIG_Py_Void();
22776 return resultobj;
22777 fail:
22778 return NULL;
22779 }
22780
22781
22782 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22783 PyObject *resultobj = 0;
22784 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22785 wxString *result = 0 ;
22786 void *argp1 = 0 ;
22787 int res1 = 0 ;
22788 PyObject *swig_obj[1] ;
22789
22790 if (!args) SWIG_fail;
22791 swig_obj[0] = args;
22792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
22793 if (!SWIG_IsOK(res1)) {
22794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
22795 }
22796 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22797 {
22798 PyThreadState* __tstate = wxPyBeginAllowThreads();
22799 {
22800 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
22801 result = (wxString *) &_result_ref;
22802 }
22803 wxPyEndAllowThreads(__tstate);
22804 if (PyErr_Occurred()) SWIG_fail;
22805 }
22806 {
22807 #if wxUSE_UNICODE
22808 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22809 #else
22810 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22811 #endif
22812 }
22813 return resultobj;
22814 fail:
22815 return NULL;
22816 }
22817
22818
22819 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22820 PyObject *obj;
22821 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22822 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
22823 return SWIG_Py_Void();
22824 }
22825
22826 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22827 return SWIG_Python_InitShadowInstance(args);
22828 }
22829
22830 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22831 PyObject *resultobj = 0;
22832 wxString *arg1 = 0 ;
22833 wxString result;
22834 bool temp1 = false ;
22835 PyObject * obj0 = 0 ;
22836 char * kwnames[] = {
22837 (char *) "sz", NULL
22838 };
22839
22840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
22841 {
22842 arg1 = wxString_in_helper(obj0);
22843 if (arg1 == NULL) SWIG_fail;
22844 temp1 = true;
22845 }
22846 {
22847 PyThreadState* __tstate = wxPyBeginAllowThreads();
22848 result = wxExpandEnvVars((wxString const &)*arg1);
22849 wxPyEndAllowThreads(__tstate);
22850 if (PyErr_Occurred()) SWIG_fail;
22851 }
22852 {
22853 #if wxUSE_UNICODE
22854 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22855 #else
22856 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22857 #endif
22858 }
22859 {
22860 if (temp1)
22861 delete arg1;
22862 }
22863 return resultobj;
22864 fail:
22865 {
22866 if (temp1)
22867 delete arg1;
22868 }
22869 return NULL;
22870 }
22871
22872
22873 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
22874 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
22875 return 1;
22876 }
22877
22878
22879 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
22880 PyObject *pyobj = 0;
22881
22882 {
22883 #if wxUSE_UNICODE
22884 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
22885 #else
22886 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
22887 #endif
22888 }
22889 return pyobj;
22890 }
22891
22892
22893 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
22894 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
22895 return 1;
22896 }
22897
22898
22899 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
22900 PyObject *pyobj = 0;
22901
22902 {
22903 #if wxUSE_UNICODE
22904 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
22905 #else
22906 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
22907 #endif
22908 }
22909 return pyobj;
22910 }
22911
22912
22913 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22914 PyObject *resultobj = 0;
22915 wxDateTime::Country arg1 ;
22916 int val1 ;
22917 int ecode1 = 0 ;
22918 PyObject * obj0 = 0 ;
22919 char * kwnames[] = {
22920 (char *) "country", NULL
22921 };
22922
22923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
22924 ecode1 = SWIG_AsVal_int(obj0, &val1);
22925 if (!SWIG_IsOK(ecode1)) {
22926 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
22927 }
22928 arg1 = static_cast< wxDateTime::Country >(val1);
22929 {
22930 PyThreadState* __tstate = wxPyBeginAllowThreads();
22931 wxDateTime::SetCountry(arg1);
22932 wxPyEndAllowThreads(__tstate);
22933 if (PyErr_Occurred()) SWIG_fail;
22934 }
22935 resultobj = SWIG_Py_Void();
22936 return resultobj;
22937 fail:
22938 return NULL;
22939 }
22940
22941
22942 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22943 PyObject *resultobj = 0;
22944 wxDateTime::Country result;
22945
22946 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
22947 {
22948 PyThreadState* __tstate = wxPyBeginAllowThreads();
22949 result = (wxDateTime::Country)wxDateTime::GetCountry();
22950 wxPyEndAllowThreads(__tstate);
22951 if (PyErr_Occurred()) SWIG_fail;
22952 }
22953 resultobj = SWIG_From_int(static_cast< int >(result));
22954 return resultobj;
22955 fail:
22956 return NULL;
22957 }
22958
22959
22960 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22961 PyObject *resultobj = 0;
22962 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
22963 bool result;
22964 int val1 ;
22965 int ecode1 = 0 ;
22966 PyObject * obj0 = 0 ;
22967 char * kwnames[] = {
22968 (char *) "country", NULL
22969 };
22970
22971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
22972 if (obj0) {
22973 ecode1 = SWIG_AsVal_int(obj0, &val1);
22974 if (!SWIG_IsOK(ecode1)) {
22975 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
22976 }
22977 arg1 = static_cast< wxDateTime::Country >(val1);
22978 }
22979 {
22980 PyThreadState* __tstate = wxPyBeginAllowThreads();
22981 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
22982 wxPyEndAllowThreads(__tstate);
22983 if (PyErr_Occurred()) SWIG_fail;
22984 }
22985 {
22986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22987 }
22988 return resultobj;
22989 fail:
22990 return NULL;
22991 }
22992
22993
22994 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22995 PyObject *resultobj = 0;
22996 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22997 int result;
22998 int val1 ;
22999 int ecode1 = 0 ;
23000 PyObject * obj0 = 0 ;
23001 char * kwnames[] = {
23002 (char *) "cal", NULL
23003 };
23004
23005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23006 if (obj0) {
23007 ecode1 = SWIG_AsVal_int(obj0, &val1);
23008 if (!SWIG_IsOK(ecode1)) {
23009 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23010 }
23011 arg1 = static_cast< wxDateTime::Calendar >(val1);
23012 }
23013 {
23014 PyThreadState* __tstate = wxPyBeginAllowThreads();
23015 result = (int)wxDateTime::GetCurrentYear(arg1);
23016 wxPyEndAllowThreads(__tstate);
23017 if (PyErr_Occurred()) SWIG_fail;
23018 }
23019 resultobj = SWIG_From_int(static_cast< int >(result));
23020 return resultobj;
23021 fail:
23022 return NULL;
23023 }
23024
23025
23026 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23027 PyObject *resultobj = 0;
23028 int arg1 ;
23029 int result;
23030 int val1 ;
23031 int ecode1 = 0 ;
23032 PyObject * obj0 = 0 ;
23033 char * kwnames[] = {
23034 (char *) "year", NULL
23035 };
23036
23037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23038 ecode1 = SWIG_AsVal_int(obj0, &val1);
23039 if (!SWIG_IsOK(ecode1)) {
23040 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23041 }
23042 arg1 = static_cast< int >(val1);
23043 {
23044 PyThreadState* __tstate = wxPyBeginAllowThreads();
23045 result = (int)wxDateTime::ConvertYearToBC(arg1);
23046 wxPyEndAllowThreads(__tstate);
23047 if (PyErr_Occurred()) SWIG_fail;
23048 }
23049 resultobj = SWIG_From_int(static_cast< int >(result));
23050 return resultobj;
23051 fail:
23052 return NULL;
23053 }
23054
23055
23056 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23057 PyObject *resultobj = 0;
23058 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23059 wxDateTime::Month result;
23060 int val1 ;
23061 int ecode1 = 0 ;
23062 PyObject * obj0 = 0 ;
23063 char * kwnames[] = {
23064 (char *) "cal", NULL
23065 };
23066
23067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23068 if (obj0) {
23069 ecode1 = SWIG_AsVal_int(obj0, &val1);
23070 if (!SWIG_IsOK(ecode1)) {
23071 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23072 }
23073 arg1 = static_cast< wxDateTime::Calendar >(val1);
23074 }
23075 {
23076 PyThreadState* __tstate = wxPyBeginAllowThreads();
23077 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23078 wxPyEndAllowThreads(__tstate);
23079 if (PyErr_Occurred()) SWIG_fail;
23080 }
23081 resultobj = SWIG_From_int(static_cast< int >(result));
23082 return resultobj;
23083 fail:
23084 return NULL;
23085 }
23086
23087
23088 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23089 PyObject *resultobj = 0;
23090 int arg1 = (int) wxDateTime::Inv_Year ;
23091 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23092 bool result;
23093 int val1 ;
23094 int ecode1 = 0 ;
23095 int val2 ;
23096 int ecode2 = 0 ;
23097 PyObject * obj0 = 0 ;
23098 PyObject * obj1 = 0 ;
23099 char * kwnames[] = {
23100 (char *) "year",(char *) "cal", NULL
23101 };
23102
23103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23104 if (obj0) {
23105 ecode1 = SWIG_AsVal_int(obj0, &val1);
23106 if (!SWIG_IsOK(ecode1)) {
23107 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23108 }
23109 arg1 = static_cast< int >(val1);
23110 }
23111 if (obj1) {
23112 ecode2 = SWIG_AsVal_int(obj1, &val2);
23113 if (!SWIG_IsOK(ecode2)) {
23114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23115 }
23116 arg2 = static_cast< wxDateTime::Calendar >(val2);
23117 }
23118 {
23119 PyThreadState* __tstate = wxPyBeginAllowThreads();
23120 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23121 wxPyEndAllowThreads(__tstate);
23122 if (PyErr_Occurred()) SWIG_fail;
23123 }
23124 {
23125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23126 }
23127 return resultobj;
23128 fail:
23129 return NULL;
23130 }
23131
23132
23133 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23134 PyObject *resultobj = 0;
23135 int arg1 = (int) wxDateTime::Inv_Year ;
23136 int result;
23137 int val1 ;
23138 int ecode1 = 0 ;
23139 PyObject * obj0 = 0 ;
23140 char * kwnames[] = {
23141 (char *) "year", NULL
23142 };
23143
23144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23145 if (obj0) {
23146 ecode1 = SWIG_AsVal_int(obj0, &val1);
23147 if (!SWIG_IsOK(ecode1)) {
23148 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23149 }
23150 arg1 = static_cast< int >(val1);
23151 }
23152 {
23153 PyThreadState* __tstate = wxPyBeginAllowThreads();
23154 result = (int)wxDateTime::GetCentury(arg1);
23155 wxPyEndAllowThreads(__tstate);
23156 if (PyErr_Occurred()) SWIG_fail;
23157 }
23158 resultobj = SWIG_From_int(static_cast< int >(result));
23159 return resultobj;
23160 fail:
23161 return NULL;
23162 }
23163
23164
23165 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23166 PyObject *resultobj = 0;
23167 int arg1 ;
23168 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23169 int result;
23170 int val1 ;
23171 int ecode1 = 0 ;
23172 int val2 ;
23173 int ecode2 = 0 ;
23174 PyObject * obj0 = 0 ;
23175 PyObject * obj1 = 0 ;
23176 char * kwnames[] = {
23177 (char *) "year",(char *) "cal", NULL
23178 };
23179
23180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23181 ecode1 = SWIG_AsVal_int(obj0, &val1);
23182 if (!SWIG_IsOK(ecode1)) {
23183 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23184 }
23185 arg1 = static_cast< int >(val1);
23186 if (obj1) {
23187 ecode2 = SWIG_AsVal_int(obj1, &val2);
23188 if (!SWIG_IsOK(ecode2)) {
23189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23190 }
23191 arg2 = static_cast< wxDateTime::Calendar >(val2);
23192 }
23193 {
23194 PyThreadState* __tstate = wxPyBeginAllowThreads();
23195 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23196 wxPyEndAllowThreads(__tstate);
23197 if (PyErr_Occurred()) SWIG_fail;
23198 }
23199 resultobj = SWIG_From_int(static_cast< int >(result));
23200 return resultobj;
23201 fail:
23202 return NULL;
23203 }
23204
23205
23206 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23207 PyObject *resultobj = 0;
23208 wxDateTime::Month arg1 ;
23209 int arg2 = (int) wxDateTime::Inv_Year ;
23210 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23211 int result;
23212 int val1 ;
23213 int ecode1 = 0 ;
23214 int val2 ;
23215 int ecode2 = 0 ;
23216 int val3 ;
23217 int ecode3 = 0 ;
23218 PyObject * obj0 = 0 ;
23219 PyObject * obj1 = 0 ;
23220 PyObject * obj2 = 0 ;
23221 char * kwnames[] = {
23222 (char *) "month",(char *) "year",(char *) "cal", NULL
23223 };
23224
23225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23226 ecode1 = SWIG_AsVal_int(obj0, &val1);
23227 if (!SWIG_IsOK(ecode1)) {
23228 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23229 }
23230 arg1 = static_cast< wxDateTime::Month >(val1);
23231 if (obj1) {
23232 ecode2 = SWIG_AsVal_int(obj1, &val2);
23233 if (!SWIG_IsOK(ecode2)) {
23234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23235 }
23236 arg2 = static_cast< int >(val2);
23237 }
23238 if (obj2) {
23239 ecode3 = SWIG_AsVal_int(obj2, &val3);
23240 if (!SWIG_IsOK(ecode3)) {
23241 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23242 }
23243 arg3 = static_cast< wxDateTime::Calendar >(val3);
23244 }
23245 {
23246 PyThreadState* __tstate = wxPyBeginAllowThreads();
23247 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23248 wxPyEndAllowThreads(__tstate);
23249 if (PyErr_Occurred()) SWIG_fail;
23250 }
23251 resultobj = SWIG_From_int(static_cast< int >(result));
23252 return resultobj;
23253 fail:
23254 return NULL;
23255 }
23256
23257
23258 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23259 PyObject *resultobj = 0;
23260 wxDateTime::Month arg1 ;
23261 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23262 wxString result;
23263 int val1 ;
23264 int ecode1 = 0 ;
23265 int val2 ;
23266 int ecode2 = 0 ;
23267 PyObject * obj0 = 0 ;
23268 PyObject * obj1 = 0 ;
23269 char * kwnames[] = {
23270 (char *) "month",(char *) "flags", NULL
23271 };
23272
23273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23274 ecode1 = SWIG_AsVal_int(obj0, &val1);
23275 if (!SWIG_IsOK(ecode1)) {
23276 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23277 }
23278 arg1 = static_cast< wxDateTime::Month >(val1);
23279 if (obj1) {
23280 ecode2 = SWIG_AsVal_int(obj1, &val2);
23281 if (!SWIG_IsOK(ecode2)) {
23282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23283 }
23284 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23285 }
23286 {
23287 PyThreadState* __tstate = wxPyBeginAllowThreads();
23288 result = wxDateTime::GetMonthName(arg1,arg2);
23289 wxPyEndAllowThreads(__tstate);
23290 if (PyErr_Occurred()) SWIG_fail;
23291 }
23292 {
23293 #if wxUSE_UNICODE
23294 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23295 #else
23296 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23297 #endif
23298 }
23299 return resultobj;
23300 fail:
23301 return NULL;
23302 }
23303
23304
23305 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23306 PyObject *resultobj = 0;
23307 wxDateTime::WeekDay arg1 ;
23308 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23309 wxString result;
23310 int val1 ;
23311 int ecode1 = 0 ;
23312 int val2 ;
23313 int ecode2 = 0 ;
23314 PyObject * obj0 = 0 ;
23315 PyObject * obj1 = 0 ;
23316 char * kwnames[] = {
23317 (char *) "weekday",(char *) "flags", NULL
23318 };
23319
23320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23321 ecode1 = SWIG_AsVal_int(obj0, &val1);
23322 if (!SWIG_IsOK(ecode1)) {
23323 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23324 }
23325 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23326 if (obj1) {
23327 ecode2 = SWIG_AsVal_int(obj1, &val2);
23328 if (!SWIG_IsOK(ecode2)) {
23329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23330 }
23331 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23332 }
23333 {
23334 PyThreadState* __tstate = wxPyBeginAllowThreads();
23335 result = wxDateTime::GetWeekDayName(arg1,arg2);
23336 wxPyEndAllowThreads(__tstate);
23337 if (PyErr_Occurred()) SWIG_fail;
23338 }
23339 {
23340 #if wxUSE_UNICODE
23341 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23342 #else
23343 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23344 #endif
23345 }
23346 return resultobj;
23347 fail:
23348 return NULL;
23349 }
23350
23351
23352 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23353 PyObject *resultobj = 0;
23354 PyObject *result = 0 ;
23355
23356 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23357 {
23358 PyThreadState* __tstate = wxPyBeginAllowThreads();
23359 result = (PyObject *)wxDateTime_GetAmPmStrings();
23360 wxPyEndAllowThreads(__tstate);
23361 if (PyErr_Occurred()) SWIG_fail;
23362 }
23363 resultobj = result;
23364 return resultobj;
23365 fail:
23366 return NULL;
23367 }
23368
23369
23370 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23371 PyObject *resultobj = 0;
23372 int arg1 = (int) wxDateTime::Inv_Year ;
23373 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23374 bool result;
23375 int val1 ;
23376 int ecode1 = 0 ;
23377 int val2 ;
23378 int ecode2 = 0 ;
23379 PyObject * obj0 = 0 ;
23380 PyObject * obj1 = 0 ;
23381 char * kwnames[] = {
23382 (char *) "year",(char *) "country", NULL
23383 };
23384
23385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23386 if (obj0) {
23387 ecode1 = SWIG_AsVal_int(obj0, &val1);
23388 if (!SWIG_IsOK(ecode1)) {
23389 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23390 }
23391 arg1 = static_cast< int >(val1);
23392 }
23393 if (obj1) {
23394 ecode2 = SWIG_AsVal_int(obj1, &val2);
23395 if (!SWIG_IsOK(ecode2)) {
23396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23397 }
23398 arg2 = static_cast< wxDateTime::Country >(val2);
23399 }
23400 {
23401 PyThreadState* __tstate = wxPyBeginAllowThreads();
23402 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23403 wxPyEndAllowThreads(__tstate);
23404 if (PyErr_Occurred()) SWIG_fail;
23405 }
23406 {
23407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23408 }
23409 return resultobj;
23410 fail:
23411 return NULL;
23412 }
23413
23414
23415 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23416 PyObject *resultobj = 0;
23417 int arg1 = (int) wxDateTime::Inv_Year ;
23418 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23419 wxDateTime result;
23420 int val1 ;
23421 int ecode1 = 0 ;
23422 int val2 ;
23423 int ecode2 = 0 ;
23424 PyObject * obj0 = 0 ;
23425 PyObject * obj1 = 0 ;
23426 char * kwnames[] = {
23427 (char *) "year",(char *) "country", NULL
23428 };
23429
23430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23431 if (obj0) {
23432 ecode1 = SWIG_AsVal_int(obj0, &val1);
23433 if (!SWIG_IsOK(ecode1)) {
23434 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23435 }
23436 arg1 = static_cast< int >(val1);
23437 }
23438 if (obj1) {
23439 ecode2 = SWIG_AsVal_int(obj1, &val2);
23440 if (!SWIG_IsOK(ecode2)) {
23441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23442 }
23443 arg2 = static_cast< wxDateTime::Country >(val2);
23444 }
23445 {
23446 PyThreadState* __tstate = wxPyBeginAllowThreads();
23447 result = wxDateTime::GetBeginDST(arg1,arg2);
23448 wxPyEndAllowThreads(__tstate);
23449 if (PyErr_Occurred()) SWIG_fail;
23450 }
23451 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23452 return resultobj;
23453 fail:
23454 return NULL;
23455 }
23456
23457
23458 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23459 PyObject *resultobj = 0;
23460 int arg1 = (int) wxDateTime::Inv_Year ;
23461 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23462 wxDateTime result;
23463 int val1 ;
23464 int ecode1 = 0 ;
23465 int val2 ;
23466 int ecode2 = 0 ;
23467 PyObject * obj0 = 0 ;
23468 PyObject * obj1 = 0 ;
23469 char * kwnames[] = {
23470 (char *) "year",(char *) "country", NULL
23471 };
23472
23473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23474 if (obj0) {
23475 ecode1 = SWIG_AsVal_int(obj0, &val1);
23476 if (!SWIG_IsOK(ecode1)) {
23477 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23478 }
23479 arg1 = static_cast< int >(val1);
23480 }
23481 if (obj1) {
23482 ecode2 = SWIG_AsVal_int(obj1, &val2);
23483 if (!SWIG_IsOK(ecode2)) {
23484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23485 }
23486 arg2 = static_cast< wxDateTime::Country >(val2);
23487 }
23488 {
23489 PyThreadState* __tstate = wxPyBeginAllowThreads();
23490 result = wxDateTime::GetEndDST(arg1,arg2);
23491 wxPyEndAllowThreads(__tstate);
23492 if (PyErr_Occurred()) SWIG_fail;
23493 }
23494 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23495 return resultobj;
23496 fail:
23497 return NULL;
23498 }
23499
23500
23501 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23502 PyObject *resultobj = 0;
23503 wxDateTime result;
23504
23505 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23506 {
23507 PyThreadState* __tstate = wxPyBeginAllowThreads();
23508 result = wxDateTime::Now();
23509 wxPyEndAllowThreads(__tstate);
23510 if (PyErr_Occurred()) SWIG_fail;
23511 }
23512 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23513 return resultobj;
23514 fail:
23515 return NULL;
23516 }
23517
23518
23519 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23520 PyObject *resultobj = 0;
23521 wxDateTime result;
23522
23523 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23524 {
23525 PyThreadState* __tstate = wxPyBeginAllowThreads();
23526 result = wxDateTime::UNow();
23527 wxPyEndAllowThreads(__tstate);
23528 if (PyErr_Occurred()) SWIG_fail;
23529 }
23530 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23531 return resultobj;
23532 fail:
23533 return NULL;
23534 }
23535
23536
23537 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23538 PyObject *resultobj = 0;
23539 wxDateTime result;
23540
23541 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23542 {
23543 PyThreadState* __tstate = wxPyBeginAllowThreads();
23544 result = wxDateTime::Today();
23545 wxPyEndAllowThreads(__tstate);
23546 if (PyErr_Occurred()) SWIG_fail;
23547 }
23548 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23549 return resultobj;
23550 fail:
23551 return NULL;
23552 }
23553
23554
23555 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23556 PyObject *resultobj = 0;
23557 wxDateTime *result = 0 ;
23558
23559 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23560 {
23561 PyThreadState* __tstate = wxPyBeginAllowThreads();
23562 result = (wxDateTime *)new wxDateTime();
23563 wxPyEndAllowThreads(__tstate);
23564 if (PyErr_Occurred()) SWIG_fail;
23565 }
23566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23567 return resultobj;
23568 fail:
23569 return NULL;
23570 }
23571
23572
23573 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23574 PyObject *resultobj = 0;
23575 time_t arg1 ;
23576 wxDateTime *result = 0 ;
23577 unsigned int val1 ;
23578 int ecode1 = 0 ;
23579 PyObject * obj0 = 0 ;
23580 char * kwnames[] = {
23581 (char *) "timet", NULL
23582 };
23583
23584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23585 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23586 if (!SWIG_IsOK(ecode1)) {
23587 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23588 }
23589 arg1 = static_cast< time_t >(val1);
23590 {
23591 PyThreadState* __tstate = wxPyBeginAllowThreads();
23592 result = (wxDateTime *)new wxDateTime(arg1);
23593 wxPyEndAllowThreads(__tstate);
23594 if (PyErr_Occurred()) SWIG_fail;
23595 }
23596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23597 return resultobj;
23598 fail:
23599 return NULL;
23600 }
23601
23602
23603 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23604 PyObject *resultobj = 0;
23605 double arg1 ;
23606 wxDateTime *result = 0 ;
23607 double val1 ;
23608 int ecode1 = 0 ;
23609 PyObject * obj0 = 0 ;
23610 char * kwnames[] = {
23611 (char *) "jdn", NULL
23612 };
23613
23614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23615 ecode1 = SWIG_AsVal_double(obj0, &val1);
23616 if (!SWIG_IsOK(ecode1)) {
23617 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23618 }
23619 arg1 = static_cast< double >(val1);
23620 {
23621 PyThreadState* __tstate = wxPyBeginAllowThreads();
23622 result = (wxDateTime *)new wxDateTime(arg1);
23623 wxPyEndAllowThreads(__tstate);
23624 if (PyErr_Occurred()) SWIG_fail;
23625 }
23626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23627 return resultobj;
23628 fail:
23629 return NULL;
23630 }
23631
23632
23633 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23634 PyObject *resultobj = 0;
23635 int arg1 ;
23636 int arg2 = (int) 0 ;
23637 int arg3 = (int) 0 ;
23638 int arg4 = (int) 0 ;
23639 wxDateTime *result = 0 ;
23640 int val1 ;
23641 int ecode1 = 0 ;
23642 int val2 ;
23643 int ecode2 = 0 ;
23644 int val3 ;
23645 int ecode3 = 0 ;
23646 int val4 ;
23647 int ecode4 = 0 ;
23648 PyObject * obj0 = 0 ;
23649 PyObject * obj1 = 0 ;
23650 PyObject * obj2 = 0 ;
23651 PyObject * obj3 = 0 ;
23652 char * kwnames[] = {
23653 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23654 };
23655
23656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23657 ecode1 = SWIG_AsVal_int(obj0, &val1);
23658 if (!SWIG_IsOK(ecode1)) {
23659 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23660 }
23661 arg1 = static_cast< int >(val1);
23662 if (obj1) {
23663 ecode2 = SWIG_AsVal_int(obj1, &val2);
23664 if (!SWIG_IsOK(ecode2)) {
23665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23666 }
23667 arg2 = static_cast< int >(val2);
23668 }
23669 if (obj2) {
23670 ecode3 = SWIG_AsVal_int(obj2, &val3);
23671 if (!SWIG_IsOK(ecode3)) {
23672 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23673 }
23674 arg3 = static_cast< int >(val3);
23675 }
23676 if (obj3) {
23677 ecode4 = SWIG_AsVal_int(obj3, &val4);
23678 if (!SWIG_IsOK(ecode4)) {
23679 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23680 }
23681 arg4 = static_cast< int >(val4);
23682 }
23683 {
23684 PyThreadState* __tstate = wxPyBeginAllowThreads();
23685 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23686 wxPyEndAllowThreads(__tstate);
23687 if (PyErr_Occurred()) SWIG_fail;
23688 }
23689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23690 return resultobj;
23691 fail:
23692 return NULL;
23693 }
23694
23695
23696 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23697 PyObject *resultobj = 0;
23698 int arg1 ;
23699 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23700 int arg3 = (int) wxDateTime::Inv_Year ;
23701 int arg4 = (int) 0 ;
23702 int arg5 = (int) 0 ;
23703 int arg6 = (int) 0 ;
23704 int arg7 = (int) 0 ;
23705 wxDateTime *result = 0 ;
23706 int val1 ;
23707 int ecode1 = 0 ;
23708 int val2 ;
23709 int ecode2 = 0 ;
23710 int val3 ;
23711 int ecode3 = 0 ;
23712 int val4 ;
23713 int ecode4 = 0 ;
23714 int val5 ;
23715 int ecode5 = 0 ;
23716 int val6 ;
23717 int ecode6 = 0 ;
23718 int val7 ;
23719 int ecode7 = 0 ;
23720 PyObject * obj0 = 0 ;
23721 PyObject * obj1 = 0 ;
23722 PyObject * obj2 = 0 ;
23723 PyObject * obj3 = 0 ;
23724 PyObject * obj4 = 0 ;
23725 PyObject * obj5 = 0 ;
23726 PyObject * obj6 = 0 ;
23727 char * kwnames[] = {
23728 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23729 };
23730
23731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23732 ecode1 = SWIG_AsVal_int(obj0, &val1);
23733 if (!SWIG_IsOK(ecode1)) {
23734 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
23735 }
23736 arg1 = static_cast< int >(val1);
23737 if (obj1) {
23738 ecode2 = SWIG_AsVal_int(obj1, &val2);
23739 if (!SWIG_IsOK(ecode2)) {
23740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23741 }
23742 arg2 = static_cast< wxDateTime::Month >(val2);
23743 }
23744 if (obj2) {
23745 ecode3 = SWIG_AsVal_int(obj2, &val3);
23746 if (!SWIG_IsOK(ecode3)) {
23747 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
23748 }
23749 arg3 = static_cast< int >(val3);
23750 }
23751 if (obj3) {
23752 ecode4 = SWIG_AsVal_int(obj3, &val4);
23753 if (!SWIG_IsOK(ecode4)) {
23754 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
23755 }
23756 arg4 = static_cast< int >(val4);
23757 }
23758 if (obj4) {
23759 ecode5 = SWIG_AsVal_int(obj4, &val5);
23760 if (!SWIG_IsOK(ecode5)) {
23761 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
23762 }
23763 arg5 = static_cast< int >(val5);
23764 }
23765 if (obj5) {
23766 ecode6 = SWIG_AsVal_int(obj5, &val6);
23767 if (!SWIG_IsOK(ecode6)) {
23768 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
23769 }
23770 arg6 = static_cast< int >(val6);
23771 }
23772 if (obj6) {
23773 ecode7 = SWIG_AsVal_int(obj6, &val7);
23774 if (!SWIG_IsOK(ecode7)) {
23775 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
23776 }
23777 arg7 = static_cast< int >(val7);
23778 }
23779 {
23780 PyThreadState* __tstate = wxPyBeginAllowThreads();
23781 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
23782 wxPyEndAllowThreads(__tstate);
23783 if (PyErr_Occurred()) SWIG_fail;
23784 }
23785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23786 return resultobj;
23787 fail:
23788 return NULL;
23789 }
23790
23791
23792 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23793 PyObject *resultobj = 0;
23794 wxDateTime *arg1 = 0 ;
23795 wxDateTime *result = 0 ;
23796 void *argp1 = 0 ;
23797 int res1 = 0 ;
23798 PyObject * obj0 = 0 ;
23799 char * kwnames[] = {
23800 (char *) "date", NULL
23801 };
23802
23803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
23804 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
23805 if (!SWIG_IsOK(res1)) {
23806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
23807 }
23808 if (!argp1) {
23809 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
23810 }
23811 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23812 {
23813 PyThreadState* __tstate = wxPyBeginAllowThreads();
23814 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
23815 wxPyEndAllowThreads(__tstate);
23816 if (PyErr_Occurred()) SWIG_fail;
23817 }
23818 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23819 return resultobj;
23820 fail:
23821 return NULL;
23822 }
23823
23824
23825 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23826 PyObject *resultobj = 0;
23827 wxDateTime *arg1 = (wxDateTime *) 0 ;
23828 void *argp1 = 0 ;
23829 int res1 = 0 ;
23830 PyObject *swig_obj[1] ;
23831
23832 if (!args) SWIG_fail;
23833 swig_obj[0] = args;
23834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
23835 if (!SWIG_IsOK(res1)) {
23836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23837 }
23838 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23839 {
23840 PyThreadState* __tstate = wxPyBeginAllowThreads();
23841 delete arg1;
23842
23843 wxPyEndAllowThreads(__tstate);
23844 if (PyErr_Occurred()) SWIG_fail;
23845 }
23846 resultobj = SWIG_Py_Void();
23847 return resultobj;
23848 fail:
23849 return NULL;
23850 }
23851
23852
23853 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23854 PyObject *resultobj = 0;
23855 wxDateTime *arg1 = (wxDateTime *) 0 ;
23856 wxDateTime *result = 0 ;
23857 void *argp1 = 0 ;
23858 int res1 = 0 ;
23859 PyObject *swig_obj[1] ;
23860
23861 if (!args) SWIG_fail;
23862 swig_obj[0] = args;
23863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23864 if (!SWIG_IsOK(res1)) {
23865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
23866 }
23867 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23868 {
23869 PyThreadState* __tstate = wxPyBeginAllowThreads();
23870 {
23871 wxDateTime &_result_ref = (arg1)->SetToCurrent();
23872 result = (wxDateTime *) &_result_ref;
23873 }
23874 wxPyEndAllowThreads(__tstate);
23875 if (PyErr_Occurred()) SWIG_fail;
23876 }
23877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23878 return resultobj;
23879 fail:
23880 return NULL;
23881 }
23882
23883
23884 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23885 PyObject *resultobj = 0;
23886 wxDateTime *arg1 = (wxDateTime *) 0 ;
23887 time_t arg2 ;
23888 wxDateTime *result = 0 ;
23889 void *argp1 = 0 ;
23890 int res1 = 0 ;
23891 unsigned int val2 ;
23892 int ecode2 = 0 ;
23893 PyObject * obj0 = 0 ;
23894 PyObject * obj1 = 0 ;
23895 char * kwnames[] = {
23896 (char *) "self",(char *) "timet", NULL
23897 };
23898
23899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
23900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23901 if (!SWIG_IsOK(res1)) {
23902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
23903 }
23904 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23905 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
23906 if (!SWIG_IsOK(ecode2)) {
23907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
23908 }
23909 arg2 = static_cast< time_t >(val2);
23910 {
23911 PyThreadState* __tstate = wxPyBeginAllowThreads();
23912 {
23913 wxDateTime &_result_ref = (arg1)->Set(arg2);
23914 result = (wxDateTime *) &_result_ref;
23915 }
23916 wxPyEndAllowThreads(__tstate);
23917 if (PyErr_Occurred()) SWIG_fail;
23918 }
23919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23920 return resultobj;
23921 fail:
23922 return NULL;
23923 }
23924
23925
23926 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23927 PyObject *resultobj = 0;
23928 wxDateTime *arg1 = (wxDateTime *) 0 ;
23929 double arg2 ;
23930 wxDateTime *result = 0 ;
23931 void *argp1 = 0 ;
23932 int res1 = 0 ;
23933 double val2 ;
23934 int ecode2 = 0 ;
23935 PyObject * obj0 = 0 ;
23936 PyObject * obj1 = 0 ;
23937 char * kwnames[] = {
23938 (char *) "self",(char *) "jdn", NULL
23939 };
23940
23941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
23942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23943 if (!SWIG_IsOK(res1)) {
23944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
23945 }
23946 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23947 ecode2 = SWIG_AsVal_double(obj1, &val2);
23948 if (!SWIG_IsOK(ecode2)) {
23949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
23950 }
23951 arg2 = static_cast< double >(val2);
23952 {
23953 PyThreadState* __tstate = wxPyBeginAllowThreads();
23954 {
23955 wxDateTime &_result_ref = (arg1)->Set(arg2);
23956 result = (wxDateTime *) &_result_ref;
23957 }
23958 wxPyEndAllowThreads(__tstate);
23959 if (PyErr_Occurred()) SWIG_fail;
23960 }
23961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23962 return resultobj;
23963 fail:
23964 return NULL;
23965 }
23966
23967
23968 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23969 PyObject *resultobj = 0;
23970 wxDateTime *arg1 = (wxDateTime *) 0 ;
23971 int arg2 ;
23972 int arg3 = (int) 0 ;
23973 int arg4 = (int) 0 ;
23974 int arg5 = (int) 0 ;
23975 wxDateTime *result = 0 ;
23976 void *argp1 = 0 ;
23977 int res1 = 0 ;
23978 int val2 ;
23979 int ecode2 = 0 ;
23980 int val3 ;
23981 int ecode3 = 0 ;
23982 int val4 ;
23983 int ecode4 = 0 ;
23984 int val5 ;
23985 int ecode5 = 0 ;
23986 PyObject * obj0 = 0 ;
23987 PyObject * obj1 = 0 ;
23988 PyObject * obj2 = 0 ;
23989 PyObject * obj3 = 0 ;
23990 PyObject * obj4 = 0 ;
23991 char * kwnames[] = {
23992 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23993 };
23994
23995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23997 if (!SWIG_IsOK(res1)) {
23998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
23999 }
24000 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24001 ecode2 = SWIG_AsVal_int(obj1, &val2);
24002 if (!SWIG_IsOK(ecode2)) {
24003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24004 }
24005 arg2 = static_cast< int >(val2);
24006 if (obj2) {
24007 ecode3 = SWIG_AsVal_int(obj2, &val3);
24008 if (!SWIG_IsOK(ecode3)) {
24009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24010 }
24011 arg3 = static_cast< int >(val3);
24012 }
24013 if (obj3) {
24014 ecode4 = SWIG_AsVal_int(obj3, &val4);
24015 if (!SWIG_IsOK(ecode4)) {
24016 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24017 }
24018 arg4 = static_cast< int >(val4);
24019 }
24020 if (obj4) {
24021 ecode5 = SWIG_AsVal_int(obj4, &val5);
24022 if (!SWIG_IsOK(ecode5)) {
24023 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24024 }
24025 arg5 = static_cast< int >(val5);
24026 }
24027 {
24028 PyThreadState* __tstate = wxPyBeginAllowThreads();
24029 {
24030 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24031 result = (wxDateTime *) &_result_ref;
24032 }
24033 wxPyEndAllowThreads(__tstate);
24034 if (PyErr_Occurred()) SWIG_fail;
24035 }
24036 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24037 return resultobj;
24038 fail:
24039 return NULL;
24040 }
24041
24042
24043 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24044 PyObject *resultobj = 0;
24045 wxDateTime *arg1 = (wxDateTime *) 0 ;
24046 int arg2 ;
24047 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24048 int arg4 = (int) wxDateTime::Inv_Year ;
24049 int arg5 = (int) 0 ;
24050 int arg6 = (int) 0 ;
24051 int arg7 = (int) 0 ;
24052 int arg8 = (int) 0 ;
24053 wxDateTime *result = 0 ;
24054 void *argp1 = 0 ;
24055 int res1 = 0 ;
24056 int val2 ;
24057 int ecode2 = 0 ;
24058 int val3 ;
24059 int ecode3 = 0 ;
24060 int val4 ;
24061 int ecode4 = 0 ;
24062 int val5 ;
24063 int ecode5 = 0 ;
24064 int val6 ;
24065 int ecode6 = 0 ;
24066 int val7 ;
24067 int ecode7 = 0 ;
24068 int val8 ;
24069 int ecode8 = 0 ;
24070 PyObject * obj0 = 0 ;
24071 PyObject * obj1 = 0 ;
24072 PyObject * obj2 = 0 ;
24073 PyObject * obj3 = 0 ;
24074 PyObject * obj4 = 0 ;
24075 PyObject * obj5 = 0 ;
24076 PyObject * obj6 = 0 ;
24077 PyObject * obj7 = 0 ;
24078 char * kwnames[] = {
24079 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24080 };
24081
24082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24084 if (!SWIG_IsOK(res1)) {
24085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24086 }
24087 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24088 ecode2 = SWIG_AsVal_int(obj1, &val2);
24089 if (!SWIG_IsOK(ecode2)) {
24090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24091 }
24092 arg2 = static_cast< int >(val2);
24093 if (obj2) {
24094 ecode3 = SWIG_AsVal_int(obj2, &val3);
24095 if (!SWIG_IsOK(ecode3)) {
24096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24097 }
24098 arg3 = static_cast< wxDateTime::Month >(val3);
24099 }
24100 if (obj3) {
24101 ecode4 = SWIG_AsVal_int(obj3, &val4);
24102 if (!SWIG_IsOK(ecode4)) {
24103 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24104 }
24105 arg4 = static_cast< int >(val4);
24106 }
24107 if (obj4) {
24108 ecode5 = SWIG_AsVal_int(obj4, &val5);
24109 if (!SWIG_IsOK(ecode5)) {
24110 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24111 }
24112 arg5 = static_cast< int >(val5);
24113 }
24114 if (obj5) {
24115 ecode6 = SWIG_AsVal_int(obj5, &val6);
24116 if (!SWIG_IsOK(ecode6)) {
24117 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24118 }
24119 arg6 = static_cast< int >(val6);
24120 }
24121 if (obj6) {
24122 ecode7 = SWIG_AsVal_int(obj6, &val7);
24123 if (!SWIG_IsOK(ecode7)) {
24124 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24125 }
24126 arg7 = static_cast< int >(val7);
24127 }
24128 if (obj7) {
24129 ecode8 = SWIG_AsVal_int(obj7, &val8);
24130 if (!SWIG_IsOK(ecode8)) {
24131 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24132 }
24133 arg8 = static_cast< int >(val8);
24134 }
24135 {
24136 PyThreadState* __tstate = wxPyBeginAllowThreads();
24137 {
24138 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24139 result = (wxDateTime *) &_result_ref;
24140 }
24141 wxPyEndAllowThreads(__tstate);
24142 if (PyErr_Occurred()) SWIG_fail;
24143 }
24144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24145 return resultobj;
24146 fail:
24147 return NULL;
24148 }
24149
24150
24151 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24152 PyObject *resultobj = 0;
24153 wxDateTime *arg1 = (wxDateTime *) 0 ;
24154 wxDateTime *result = 0 ;
24155 void *argp1 = 0 ;
24156 int res1 = 0 ;
24157 PyObject *swig_obj[1] ;
24158
24159 if (!args) SWIG_fail;
24160 swig_obj[0] = args;
24161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24162 if (!SWIG_IsOK(res1)) {
24163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24164 }
24165 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24166 {
24167 PyThreadState* __tstate = wxPyBeginAllowThreads();
24168 {
24169 wxDateTime &_result_ref = (arg1)->ResetTime();
24170 result = (wxDateTime *) &_result_ref;
24171 }
24172 wxPyEndAllowThreads(__tstate);
24173 if (PyErr_Occurred()) SWIG_fail;
24174 }
24175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24176 return resultobj;
24177 fail:
24178 return NULL;
24179 }
24180
24181
24182 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24183 PyObject *resultobj = 0;
24184 wxDateTime *arg1 = (wxDateTime *) 0 ;
24185 int arg2 ;
24186 wxDateTime *result = 0 ;
24187 void *argp1 = 0 ;
24188 int res1 = 0 ;
24189 int val2 ;
24190 int ecode2 = 0 ;
24191 PyObject * obj0 = 0 ;
24192 PyObject * obj1 = 0 ;
24193 char * kwnames[] = {
24194 (char *) "self",(char *) "year", NULL
24195 };
24196
24197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24199 if (!SWIG_IsOK(res1)) {
24200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24201 }
24202 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24203 ecode2 = SWIG_AsVal_int(obj1, &val2);
24204 if (!SWIG_IsOK(ecode2)) {
24205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24206 }
24207 arg2 = static_cast< int >(val2);
24208 {
24209 PyThreadState* __tstate = wxPyBeginAllowThreads();
24210 {
24211 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24212 result = (wxDateTime *) &_result_ref;
24213 }
24214 wxPyEndAllowThreads(__tstate);
24215 if (PyErr_Occurred()) SWIG_fail;
24216 }
24217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24218 return resultobj;
24219 fail:
24220 return NULL;
24221 }
24222
24223
24224 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24225 PyObject *resultobj = 0;
24226 wxDateTime *arg1 = (wxDateTime *) 0 ;
24227 wxDateTime::Month arg2 ;
24228 wxDateTime *result = 0 ;
24229 void *argp1 = 0 ;
24230 int res1 = 0 ;
24231 int val2 ;
24232 int ecode2 = 0 ;
24233 PyObject * obj0 = 0 ;
24234 PyObject * obj1 = 0 ;
24235 char * kwnames[] = {
24236 (char *) "self",(char *) "month", NULL
24237 };
24238
24239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24241 if (!SWIG_IsOK(res1)) {
24242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24243 }
24244 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24245 ecode2 = SWIG_AsVal_int(obj1, &val2);
24246 if (!SWIG_IsOK(ecode2)) {
24247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24248 }
24249 arg2 = static_cast< wxDateTime::Month >(val2);
24250 {
24251 PyThreadState* __tstate = wxPyBeginAllowThreads();
24252 {
24253 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24254 result = (wxDateTime *) &_result_ref;
24255 }
24256 wxPyEndAllowThreads(__tstate);
24257 if (PyErr_Occurred()) SWIG_fail;
24258 }
24259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24260 return resultobj;
24261 fail:
24262 return NULL;
24263 }
24264
24265
24266 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24267 PyObject *resultobj = 0;
24268 wxDateTime *arg1 = (wxDateTime *) 0 ;
24269 int arg2 ;
24270 wxDateTime *result = 0 ;
24271 void *argp1 = 0 ;
24272 int res1 = 0 ;
24273 int val2 ;
24274 int ecode2 = 0 ;
24275 PyObject * obj0 = 0 ;
24276 PyObject * obj1 = 0 ;
24277 char * kwnames[] = {
24278 (char *) "self",(char *) "day", NULL
24279 };
24280
24281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24283 if (!SWIG_IsOK(res1)) {
24284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24285 }
24286 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24287 ecode2 = SWIG_AsVal_int(obj1, &val2);
24288 if (!SWIG_IsOK(ecode2)) {
24289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24290 }
24291 arg2 = static_cast< int >(val2);
24292 {
24293 PyThreadState* __tstate = wxPyBeginAllowThreads();
24294 {
24295 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24296 result = (wxDateTime *) &_result_ref;
24297 }
24298 wxPyEndAllowThreads(__tstate);
24299 if (PyErr_Occurred()) SWIG_fail;
24300 }
24301 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24302 return resultobj;
24303 fail:
24304 return NULL;
24305 }
24306
24307
24308 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24309 PyObject *resultobj = 0;
24310 wxDateTime *arg1 = (wxDateTime *) 0 ;
24311 int arg2 ;
24312 wxDateTime *result = 0 ;
24313 void *argp1 = 0 ;
24314 int res1 = 0 ;
24315 int val2 ;
24316 int ecode2 = 0 ;
24317 PyObject * obj0 = 0 ;
24318 PyObject * obj1 = 0 ;
24319 char * kwnames[] = {
24320 (char *) "self",(char *) "hour", NULL
24321 };
24322
24323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24325 if (!SWIG_IsOK(res1)) {
24326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24327 }
24328 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24329 ecode2 = SWIG_AsVal_int(obj1, &val2);
24330 if (!SWIG_IsOK(ecode2)) {
24331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24332 }
24333 arg2 = static_cast< int >(val2);
24334 {
24335 PyThreadState* __tstate = wxPyBeginAllowThreads();
24336 {
24337 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24338 result = (wxDateTime *) &_result_ref;
24339 }
24340 wxPyEndAllowThreads(__tstate);
24341 if (PyErr_Occurred()) SWIG_fail;
24342 }
24343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24344 return resultobj;
24345 fail:
24346 return NULL;
24347 }
24348
24349
24350 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24351 PyObject *resultobj = 0;
24352 wxDateTime *arg1 = (wxDateTime *) 0 ;
24353 int arg2 ;
24354 wxDateTime *result = 0 ;
24355 void *argp1 = 0 ;
24356 int res1 = 0 ;
24357 int val2 ;
24358 int ecode2 = 0 ;
24359 PyObject * obj0 = 0 ;
24360 PyObject * obj1 = 0 ;
24361 char * kwnames[] = {
24362 (char *) "self",(char *) "minute", NULL
24363 };
24364
24365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24367 if (!SWIG_IsOK(res1)) {
24368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24369 }
24370 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24371 ecode2 = SWIG_AsVal_int(obj1, &val2);
24372 if (!SWIG_IsOK(ecode2)) {
24373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24374 }
24375 arg2 = static_cast< int >(val2);
24376 {
24377 PyThreadState* __tstate = wxPyBeginAllowThreads();
24378 {
24379 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24380 result = (wxDateTime *) &_result_ref;
24381 }
24382 wxPyEndAllowThreads(__tstate);
24383 if (PyErr_Occurred()) SWIG_fail;
24384 }
24385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24386 return resultobj;
24387 fail:
24388 return NULL;
24389 }
24390
24391
24392 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24393 PyObject *resultobj = 0;
24394 wxDateTime *arg1 = (wxDateTime *) 0 ;
24395 int arg2 ;
24396 wxDateTime *result = 0 ;
24397 void *argp1 = 0 ;
24398 int res1 = 0 ;
24399 int val2 ;
24400 int ecode2 = 0 ;
24401 PyObject * obj0 = 0 ;
24402 PyObject * obj1 = 0 ;
24403 char * kwnames[] = {
24404 (char *) "self",(char *) "second", NULL
24405 };
24406
24407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24409 if (!SWIG_IsOK(res1)) {
24410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24411 }
24412 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24413 ecode2 = SWIG_AsVal_int(obj1, &val2);
24414 if (!SWIG_IsOK(ecode2)) {
24415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24416 }
24417 arg2 = static_cast< int >(val2);
24418 {
24419 PyThreadState* __tstate = wxPyBeginAllowThreads();
24420 {
24421 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24422 result = (wxDateTime *) &_result_ref;
24423 }
24424 wxPyEndAllowThreads(__tstate);
24425 if (PyErr_Occurred()) SWIG_fail;
24426 }
24427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24428 return resultobj;
24429 fail:
24430 return NULL;
24431 }
24432
24433
24434 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24435 PyObject *resultobj = 0;
24436 wxDateTime *arg1 = (wxDateTime *) 0 ;
24437 int arg2 ;
24438 wxDateTime *result = 0 ;
24439 void *argp1 = 0 ;
24440 int res1 = 0 ;
24441 int val2 ;
24442 int ecode2 = 0 ;
24443 PyObject * obj0 = 0 ;
24444 PyObject * obj1 = 0 ;
24445 char * kwnames[] = {
24446 (char *) "self",(char *) "millisecond", NULL
24447 };
24448
24449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24451 if (!SWIG_IsOK(res1)) {
24452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24453 }
24454 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24455 ecode2 = SWIG_AsVal_int(obj1, &val2);
24456 if (!SWIG_IsOK(ecode2)) {
24457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24458 }
24459 arg2 = static_cast< int >(val2);
24460 {
24461 PyThreadState* __tstate = wxPyBeginAllowThreads();
24462 {
24463 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24464 result = (wxDateTime *) &_result_ref;
24465 }
24466 wxPyEndAllowThreads(__tstate);
24467 if (PyErr_Occurred()) SWIG_fail;
24468 }
24469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24470 return resultobj;
24471 fail:
24472 return NULL;
24473 }
24474
24475
24476 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24477 PyObject *resultobj = 0;
24478 wxDateTime *arg1 = (wxDateTime *) 0 ;
24479 wxDateTime::WeekDay arg2 ;
24480 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24481 wxDateTime *result = 0 ;
24482 void *argp1 = 0 ;
24483 int res1 = 0 ;
24484 int val2 ;
24485 int ecode2 = 0 ;
24486 int val3 ;
24487 int ecode3 = 0 ;
24488 PyObject * obj0 = 0 ;
24489 PyObject * obj1 = 0 ;
24490 PyObject * obj2 = 0 ;
24491 char * kwnames[] = {
24492 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24493 };
24494
24495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24497 if (!SWIG_IsOK(res1)) {
24498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24499 }
24500 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24501 ecode2 = SWIG_AsVal_int(obj1, &val2);
24502 if (!SWIG_IsOK(ecode2)) {
24503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24504 }
24505 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24506 if (obj2) {
24507 ecode3 = SWIG_AsVal_int(obj2, &val3);
24508 if (!SWIG_IsOK(ecode3)) {
24509 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24510 }
24511 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24512 }
24513 {
24514 PyThreadState* __tstate = wxPyBeginAllowThreads();
24515 {
24516 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24517 result = (wxDateTime *) &_result_ref;
24518 }
24519 wxPyEndAllowThreads(__tstate);
24520 if (PyErr_Occurred()) SWIG_fail;
24521 }
24522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24523 return resultobj;
24524 fail:
24525 return NULL;
24526 }
24527
24528
24529 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24530 PyObject *resultobj = 0;
24531 wxDateTime *arg1 = (wxDateTime *) 0 ;
24532 wxDateTime::WeekDay arg2 ;
24533 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24534 wxDateTime result;
24535 void *argp1 = 0 ;
24536 int res1 = 0 ;
24537 int val2 ;
24538 int ecode2 = 0 ;
24539 int val3 ;
24540 int ecode3 = 0 ;
24541 PyObject * obj0 = 0 ;
24542 PyObject * obj1 = 0 ;
24543 PyObject * obj2 = 0 ;
24544 char * kwnames[] = {
24545 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24546 };
24547
24548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24550 if (!SWIG_IsOK(res1)) {
24551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24552 }
24553 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24554 ecode2 = SWIG_AsVal_int(obj1, &val2);
24555 if (!SWIG_IsOK(ecode2)) {
24556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24557 }
24558 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24559 if (obj2) {
24560 ecode3 = SWIG_AsVal_int(obj2, &val3);
24561 if (!SWIG_IsOK(ecode3)) {
24562 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24563 }
24564 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24565 }
24566 {
24567 PyThreadState* __tstate = wxPyBeginAllowThreads();
24568 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24569 wxPyEndAllowThreads(__tstate);
24570 if (PyErr_Occurred()) SWIG_fail;
24571 }
24572 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24573 return resultobj;
24574 fail:
24575 return NULL;
24576 }
24577
24578
24579 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24580 PyObject *resultobj = 0;
24581 wxDateTime *arg1 = (wxDateTime *) 0 ;
24582 wxDateTime::WeekDay arg2 ;
24583 wxDateTime *result = 0 ;
24584 void *argp1 = 0 ;
24585 int res1 = 0 ;
24586 int val2 ;
24587 int ecode2 = 0 ;
24588 PyObject * obj0 = 0 ;
24589 PyObject * obj1 = 0 ;
24590 char * kwnames[] = {
24591 (char *) "self",(char *) "weekday", NULL
24592 };
24593
24594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24596 if (!SWIG_IsOK(res1)) {
24597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24598 }
24599 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24600 ecode2 = SWIG_AsVal_int(obj1, &val2);
24601 if (!SWIG_IsOK(ecode2)) {
24602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24603 }
24604 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24605 {
24606 PyThreadState* __tstate = wxPyBeginAllowThreads();
24607 {
24608 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24609 result = (wxDateTime *) &_result_ref;
24610 }
24611 wxPyEndAllowThreads(__tstate);
24612 if (PyErr_Occurred()) SWIG_fail;
24613 }
24614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24615 return resultobj;
24616 fail:
24617 return NULL;
24618 }
24619
24620
24621 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24622 PyObject *resultobj = 0;
24623 wxDateTime *arg1 = (wxDateTime *) 0 ;
24624 wxDateTime::WeekDay arg2 ;
24625 wxDateTime result;
24626 void *argp1 = 0 ;
24627 int res1 = 0 ;
24628 int val2 ;
24629 int ecode2 = 0 ;
24630 PyObject * obj0 = 0 ;
24631 PyObject * obj1 = 0 ;
24632 char * kwnames[] = {
24633 (char *) "self",(char *) "weekday", NULL
24634 };
24635
24636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24638 if (!SWIG_IsOK(res1)) {
24639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24640 }
24641 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24642 ecode2 = SWIG_AsVal_int(obj1, &val2);
24643 if (!SWIG_IsOK(ecode2)) {
24644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24645 }
24646 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24647 {
24648 PyThreadState* __tstate = wxPyBeginAllowThreads();
24649 result = (arg1)->GetNextWeekDay(arg2);
24650 wxPyEndAllowThreads(__tstate);
24651 if (PyErr_Occurred()) SWIG_fail;
24652 }
24653 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24654 return resultobj;
24655 fail:
24656 return NULL;
24657 }
24658
24659
24660 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24661 PyObject *resultobj = 0;
24662 wxDateTime *arg1 = (wxDateTime *) 0 ;
24663 wxDateTime::WeekDay arg2 ;
24664 wxDateTime *result = 0 ;
24665 void *argp1 = 0 ;
24666 int res1 = 0 ;
24667 int val2 ;
24668 int ecode2 = 0 ;
24669 PyObject * obj0 = 0 ;
24670 PyObject * obj1 = 0 ;
24671 char * kwnames[] = {
24672 (char *) "self",(char *) "weekday", NULL
24673 };
24674
24675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24677 if (!SWIG_IsOK(res1)) {
24678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24679 }
24680 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24681 ecode2 = SWIG_AsVal_int(obj1, &val2);
24682 if (!SWIG_IsOK(ecode2)) {
24683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24684 }
24685 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24686 {
24687 PyThreadState* __tstate = wxPyBeginAllowThreads();
24688 {
24689 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24690 result = (wxDateTime *) &_result_ref;
24691 }
24692 wxPyEndAllowThreads(__tstate);
24693 if (PyErr_Occurred()) SWIG_fail;
24694 }
24695 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24696 return resultobj;
24697 fail:
24698 return NULL;
24699 }
24700
24701
24702 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24703 PyObject *resultobj = 0;
24704 wxDateTime *arg1 = (wxDateTime *) 0 ;
24705 wxDateTime::WeekDay arg2 ;
24706 wxDateTime result;
24707 void *argp1 = 0 ;
24708 int res1 = 0 ;
24709 int val2 ;
24710 int ecode2 = 0 ;
24711 PyObject * obj0 = 0 ;
24712 PyObject * obj1 = 0 ;
24713 char * kwnames[] = {
24714 (char *) "self",(char *) "weekday", NULL
24715 };
24716
24717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24719 if (!SWIG_IsOK(res1)) {
24720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24721 }
24722 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24723 ecode2 = SWIG_AsVal_int(obj1, &val2);
24724 if (!SWIG_IsOK(ecode2)) {
24725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24726 }
24727 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24728 {
24729 PyThreadState* __tstate = wxPyBeginAllowThreads();
24730 result = (arg1)->GetPrevWeekDay(arg2);
24731 wxPyEndAllowThreads(__tstate);
24732 if (PyErr_Occurred()) SWIG_fail;
24733 }
24734 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24735 return resultobj;
24736 fail:
24737 return NULL;
24738 }
24739
24740
24741 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24742 PyObject *resultobj = 0;
24743 wxDateTime *arg1 = (wxDateTime *) 0 ;
24744 wxDateTime::WeekDay arg2 ;
24745 int arg3 = (int) 1 ;
24746 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24747 int arg5 = (int) wxDateTime::Inv_Year ;
24748 bool result;
24749 void *argp1 = 0 ;
24750 int res1 = 0 ;
24751 int val2 ;
24752 int ecode2 = 0 ;
24753 int val3 ;
24754 int ecode3 = 0 ;
24755 int val4 ;
24756 int ecode4 = 0 ;
24757 int val5 ;
24758 int ecode5 = 0 ;
24759 PyObject * obj0 = 0 ;
24760 PyObject * obj1 = 0 ;
24761 PyObject * obj2 = 0 ;
24762 PyObject * obj3 = 0 ;
24763 PyObject * obj4 = 0 ;
24764 char * kwnames[] = {
24765 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
24766 };
24767
24768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24770 if (!SWIG_IsOK(res1)) {
24771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24772 }
24773 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24774 ecode2 = SWIG_AsVal_int(obj1, &val2);
24775 if (!SWIG_IsOK(ecode2)) {
24776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24777 }
24778 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24779 if (obj2) {
24780 ecode3 = SWIG_AsVal_int(obj2, &val3);
24781 if (!SWIG_IsOK(ecode3)) {
24782 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
24783 }
24784 arg3 = static_cast< int >(val3);
24785 }
24786 if (obj3) {
24787 ecode4 = SWIG_AsVal_int(obj3, &val4);
24788 if (!SWIG_IsOK(ecode4)) {
24789 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
24790 }
24791 arg4 = static_cast< wxDateTime::Month >(val4);
24792 }
24793 if (obj4) {
24794 ecode5 = SWIG_AsVal_int(obj4, &val5);
24795 if (!SWIG_IsOK(ecode5)) {
24796 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
24797 }
24798 arg5 = static_cast< int >(val5);
24799 }
24800 {
24801 PyThreadState* __tstate = wxPyBeginAllowThreads();
24802 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
24803 wxPyEndAllowThreads(__tstate);
24804 if (PyErr_Occurred()) SWIG_fail;
24805 }
24806 {
24807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24808 }
24809 return resultobj;
24810 fail:
24811 return NULL;
24812 }
24813
24814
24815 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24816 PyObject *resultobj = 0;
24817 wxDateTime *arg1 = (wxDateTime *) 0 ;
24818 wxDateTime::WeekDay arg2 ;
24819 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24820 int arg4 = (int) wxDateTime::Inv_Year ;
24821 bool result;
24822 void *argp1 = 0 ;
24823 int res1 = 0 ;
24824 int val2 ;
24825 int ecode2 = 0 ;
24826 int val3 ;
24827 int ecode3 = 0 ;
24828 int val4 ;
24829 int ecode4 = 0 ;
24830 PyObject * obj0 = 0 ;
24831 PyObject * obj1 = 0 ;
24832 PyObject * obj2 = 0 ;
24833 PyObject * obj3 = 0 ;
24834 char * kwnames[] = {
24835 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
24836 };
24837
24838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24842 }
24843 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24844 ecode2 = SWIG_AsVal_int(obj1, &val2);
24845 if (!SWIG_IsOK(ecode2)) {
24846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24847 }
24848 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24849 if (obj2) {
24850 ecode3 = SWIG_AsVal_int(obj2, &val3);
24851 if (!SWIG_IsOK(ecode3)) {
24852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24853 }
24854 arg3 = static_cast< wxDateTime::Month >(val3);
24855 }
24856 if (obj3) {
24857 ecode4 = SWIG_AsVal_int(obj3, &val4);
24858 if (!SWIG_IsOK(ecode4)) {
24859 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
24860 }
24861 arg4 = static_cast< int >(val4);
24862 }
24863 {
24864 PyThreadState* __tstate = wxPyBeginAllowThreads();
24865 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
24866 wxPyEndAllowThreads(__tstate);
24867 if (PyErr_Occurred()) SWIG_fail;
24868 }
24869 {
24870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24871 }
24872 return resultobj;
24873 fail:
24874 return NULL;
24875 }
24876
24877
24878 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24879 PyObject *resultobj = 0;
24880 wxDateTime *arg1 = (wxDateTime *) 0 ;
24881 wxDateTime::WeekDay arg2 ;
24882 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24883 int arg4 = (int) wxDateTime::Inv_Year ;
24884 wxDateTime result;
24885 void *argp1 = 0 ;
24886 int res1 = 0 ;
24887 int val2 ;
24888 int ecode2 = 0 ;
24889 int val3 ;
24890 int ecode3 = 0 ;
24891 int val4 ;
24892 int ecode4 = 0 ;
24893 PyObject * obj0 = 0 ;
24894 PyObject * obj1 = 0 ;
24895 PyObject * obj2 = 0 ;
24896 PyObject * obj3 = 0 ;
24897 char * kwnames[] = {
24898 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
24899 };
24900
24901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24903 if (!SWIG_IsOK(res1)) {
24904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24905 }
24906 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24907 ecode2 = SWIG_AsVal_int(obj1, &val2);
24908 if (!SWIG_IsOK(ecode2)) {
24909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24910 }
24911 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24912 if (obj2) {
24913 ecode3 = SWIG_AsVal_int(obj2, &val3);
24914 if (!SWIG_IsOK(ecode3)) {
24915 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24916 }
24917 arg3 = static_cast< wxDateTime::Month >(val3);
24918 }
24919 if (obj3) {
24920 ecode4 = SWIG_AsVal_int(obj3, &val4);
24921 if (!SWIG_IsOK(ecode4)) {
24922 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
24923 }
24924 arg4 = static_cast< int >(val4);
24925 }
24926 {
24927 PyThreadState* __tstate = wxPyBeginAllowThreads();
24928 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
24929 wxPyEndAllowThreads(__tstate);
24930 if (PyErr_Occurred()) SWIG_fail;
24931 }
24932 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24933 return resultobj;
24934 fail:
24935 return NULL;
24936 }
24937
24938
24939 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24940 PyObject *resultobj = 0;
24941 wxDateTime *arg1 = (wxDateTime *) 0 ;
24942 int arg2 ;
24943 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24944 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24945 bool result;
24946 void *argp1 = 0 ;
24947 int res1 = 0 ;
24948 int val2 ;
24949 int ecode2 = 0 ;
24950 int val3 ;
24951 int ecode3 = 0 ;
24952 int val4 ;
24953 int ecode4 = 0 ;
24954 PyObject * obj0 = 0 ;
24955 PyObject * obj1 = 0 ;
24956 PyObject * obj2 = 0 ;
24957 PyObject * obj3 = 0 ;
24958 char * kwnames[] = {
24959 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
24960 };
24961
24962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24964 if (!SWIG_IsOK(res1)) {
24965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24966 }
24967 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24968 ecode2 = SWIG_AsVal_int(obj1, &val2);
24969 if (!SWIG_IsOK(ecode2)) {
24970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
24971 }
24972 arg2 = static_cast< int >(val2);
24973 if (obj2) {
24974 ecode3 = SWIG_AsVal_int(obj2, &val3);
24975 if (!SWIG_IsOK(ecode3)) {
24976 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24977 }
24978 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24979 }
24980 if (obj3) {
24981 ecode4 = SWIG_AsVal_int(obj3, &val4);
24982 if (!SWIG_IsOK(ecode4)) {
24983 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
24984 }
24985 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
24986 }
24987 {
24988 PyThreadState* __tstate = wxPyBeginAllowThreads();
24989 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
24990 wxPyEndAllowThreads(__tstate);
24991 if (PyErr_Occurred()) SWIG_fail;
24992 }
24993 {
24994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24995 }
24996 return resultobj;
24997 fail:
24998 return NULL;
24999 }
25000
25001
25002 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25003 PyObject *resultobj = 0;
25004 wxDateTime *arg1 = (wxDateTime *) 0 ;
25005 int arg2 ;
25006 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25007 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25008 wxDateTime result;
25009 void *argp1 = 0 ;
25010 int res1 = 0 ;
25011 int val2 ;
25012 int ecode2 = 0 ;
25013 int val3 ;
25014 int ecode3 = 0 ;
25015 int val4 ;
25016 int ecode4 = 0 ;
25017 PyObject * obj0 = 0 ;
25018 PyObject * obj1 = 0 ;
25019 PyObject * obj2 = 0 ;
25020 PyObject * obj3 = 0 ;
25021 char * kwnames[] = {
25022 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25023 };
25024
25025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25027 if (!SWIG_IsOK(res1)) {
25028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25029 }
25030 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25031 ecode2 = SWIG_AsVal_int(obj1, &val2);
25032 if (!SWIG_IsOK(ecode2)) {
25033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25034 }
25035 arg2 = static_cast< int >(val2);
25036 if (obj2) {
25037 ecode3 = SWIG_AsVal_int(obj2, &val3);
25038 if (!SWIG_IsOK(ecode3)) {
25039 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25040 }
25041 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25042 }
25043 if (obj3) {
25044 ecode4 = SWIG_AsVal_int(obj3, &val4);
25045 if (!SWIG_IsOK(ecode4)) {
25046 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25047 }
25048 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25049 }
25050 {
25051 PyThreadState* __tstate = wxPyBeginAllowThreads();
25052 result = (arg1)->GetWeek(arg2,arg3,arg4);
25053 wxPyEndAllowThreads(__tstate);
25054 if (PyErr_Occurred()) SWIG_fail;
25055 }
25056 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25057 return resultobj;
25058 fail:
25059 return NULL;
25060 }
25061
25062
25063 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25064 PyObject *resultobj = 0;
25065 int arg1 ;
25066 int arg2 ;
25067 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25068 wxDateTime result;
25069 int val1 ;
25070 int ecode1 = 0 ;
25071 int val2 ;
25072 int ecode2 = 0 ;
25073 int val3 ;
25074 int ecode3 = 0 ;
25075 PyObject * obj0 = 0 ;
25076 PyObject * obj1 = 0 ;
25077 PyObject * obj2 = 0 ;
25078 char * kwnames[] = {
25079 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25080 };
25081
25082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25083 ecode1 = SWIG_AsVal_int(obj0, &val1);
25084 if (!SWIG_IsOK(ecode1)) {
25085 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25086 }
25087 arg1 = static_cast< int >(val1);
25088 ecode2 = SWIG_AsVal_int(obj1, &val2);
25089 if (!SWIG_IsOK(ecode2)) {
25090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25091 }
25092 arg2 = static_cast< int >(val2);
25093 if (obj2) {
25094 ecode3 = SWIG_AsVal_int(obj2, &val3);
25095 if (!SWIG_IsOK(ecode3)) {
25096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25097 }
25098 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25099 }
25100 {
25101 PyThreadState* __tstate = wxPyBeginAllowThreads();
25102 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25103 wxPyEndAllowThreads(__tstate);
25104 if (PyErr_Occurred()) SWIG_fail;
25105 }
25106 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25107 return resultobj;
25108 fail:
25109 return NULL;
25110 }
25111
25112
25113 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25114 PyObject *resultobj = 0;
25115 wxDateTime *arg1 = (wxDateTime *) 0 ;
25116 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25117 int arg3 = (int) wxDateTime::Inv_Year ;
25118 wxDateTime *result = 0 ;
25119 void *argp1 = 0 ;
25120 int res1 = 0 ;
25121 int val2 ;
25122 int ecode2 = 0 ;
25123 int val3 ;
25124 int ecode3 = 0 ;
25125 PyObject * obj0 = 0 ;
25126 PyObject * obj1 = 0 ;
25127 PyObject * obj2 = 0 ;
25128 char * kwnames[] = {
25129 (char *) "self",(char *) "month",(char *) "year", NULL
25130 };
25131
25132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25134 if (!SWIG_IsOK(res1)) {
25135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25136 }
25137 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25138 if (obj1) {
25139 ecode2 = SWIG_AsVal_int(obj1, &val2);
25140 if (!SWIG_IsOK(ecode2)) {
25141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25142 }
25143 arg2 = static_cast< wxDateTime::Month >(val2);
25144 }
25145 if (obj2) {
25146 ecode3 = SWIG_AsVal_int(obj2, &val3);
25147 if (!SWIG_IsOK(ecode3)) {
25148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25149 }
25150 arg3 = static_cast< int >(val3);
25151 }
25152 {
25153 PyThreadState* __tstate = wxPyBeginAllowThreads();
25154 {
25155 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25156 result = (wxDateTime *) &_result_ref;
25157 }
25158 wxPyEndAllowThreads(__tstate);
25159 if (PyErr_Occurred()) SWIG_fail;
25160 }
25161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25162 return resultobj;
25163 fail:
25164 return NULL;
25165 }
25166
25167
25168 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25169 PyObject *resultobj = 0;
25170 wxDateTime *arg1 = (wxDateTime *) 0 ;
25171 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25172 int arg3 = (int) wxDateTime::Inv_Year ;
25173 wxDateTime result;
25174 void *argp1 = 0 ;
25175 int res1 = 0 ;
25176 int val2 ;
25177 int ecode2 = 0 ;
25178 int val3 ;
25179 int ecode3 = 0 ;
25180 PyObject * obj0 = 0 ;
25181 PyObject * obj1 = 0 ;
25182 PyObject * obj2 = 0 ;
25183 char * kwnames[] = {
25184 (char *) "self",(char *) "month",(char *) "year", NULL
25185 };
25186
25187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25189 if (!SWIG_IsOK(res1)) {
25190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25191 }
25192 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25193 if (obj1) {
25194 ecode2 = SWIG_AsVal_int(obj1, &val2);
25195 if (!SWIG_IsOK(ecode2)) {
25196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25197 }
25198 arg2 = static_cast< wxDateTime::Month >(val2);
25199 }
25200 if (obj2) {
25201 ecode3 = SWIG_AsVal_int(obj2, &val3);
25202 if (!SWIG_IsOK(ecode3)) {
25203 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25204 }
25205 arg3 = static_cast< int >(val3);
25206 }
25207 {
25208 PyThreadState* __tstate = wxPyBeginAllowThreads();
25209 result = (arg1)->GetLastMonthDay(arg2,arg3);
25210 wxPyEndAllowThreads(__tstate);
25211 if (PyErr_Occurred()) SWIG_fail;
25212 }
25213 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25214 return resultobj;
25215 fail:
25216 return NULL;
25217 }
25218
25219
25220 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25221 PyObject *resultobj = 0;
25222 wxDateTime *arg1 = (wxDateTime *) 0 ;
25223 int arg2 ;
25224 wxDateTime *result = 0 ;
25225 void *argp1 = 0 ;
25226 int res1 = 0 ;
25227 int val2 ;
25228 int ecode2 = 0 ;
25229 PyObject * obj0 = 0 ;
25230 PyObject * obj1 = 0 ;
25231 char * kwnames[] = {
25232 (char *) "self",(char *) "yday", NULL
25233 };
25234
25235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25237 if (!SWIG_IsOK(res1)) {
25238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25239 }
25240 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25241 ecode2 = SWIG_AsVal_int(obj1, &val2);
25242 if (!SWIG_IsOK(ecode2)) {
25243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25244 }
25245 arg2 = static_cast< int >(val2);
25246 {
25247 PyThreadState* __tstate = wxPyBeginAllowThreads();
25248 {
25249 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25250 result = (wxDateTime *) &_result_ref;
25251 }
25252 wxPyEndAllowThreads(__tstate);
25253 if (PyErr_Occurred()) SWIG_fail;
25254 }
25255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25256 return resultobj;
25257 fail:
25258 return NULL;
25259 }
25260
25261
25262 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25263 PyObject *resultobj = 0;
25264 wxDateTime *arg1 = (wxDateTime *) 0 ;
25265 int arg2 ;
25266 wxDateTime result;
25267 void *argp1 = 0 ;
25268 int res1 = 0 ;
25269 int val2 ;
25270 int ecode2 = 0 ;
25271 PyObject * obj0 = 0 ;
25272 PyObject * obj1 = 0 ;
25273 char * kwnames[] = {
25274 (char *) "self",(char *) "yday", NULL
25275 };
25276
25277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25279 if (!SWIG_IsOK(res1)) {
25280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25281 }
25282 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25283 ecode2 = SWIG_AsVal_int(obj1, &val2);
25284 if (!SWIG_IsOK(ecode2)) {
25285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25286 }
25287 arg2 = static_cast< int >(val2);
25288 {
25289 PyThreadState* __tstate = wxPyBeginAllowThreads();
25290 result = (arg1)->GetYearDay(arg2);
25291 wxPyEndAllowThreads(__tstate);
25292 if (PyErr_Occurred()) SWIG_fail;
25293 }
25294 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25295 return resultobj;
25296 fail:
25297 return NULL;
25298 }
25299
25300
25301 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25302 PyObject *resultobj = 0;
25303 wxDateTime *arg1 = (wxDateTime *) 0 ;
25304 double result;
25305 void *argp1 = 0 ;
25306 int res1 = 0 ;
25307 PyObject *swig_obj[1] ;
25308
25309 if (!args) SWIG_fail;
25310 swig_obj[0] = args;
25311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25312 if (!SWIG_IsOK(res1)) {
25313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25314 }
25315 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25316 {
25317 PyThreadState* __tstate = wxPyBeginAllowThreads();
25318 result = (double)(arg1)->GetJulianDayNumber();
25319 wxPyEndAllowThreads(__tstate);
25320 if (PyErr_Occurred()) SWIG_fail;
25321 }
25322 resultobj = SWIG_From_double(static_cast< double >(result));
25323 return resultobj;
25324 fail:
25325 return NULL;
25326 }
25327
25328
25329 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25330 PyObject *resultobj = 0;
25331 wxDateTime *arg1 = (wxDateTime *) 0 ;
25332 double result;
25333 void *argp1 = 0 ;
25334 int res1 = 0 ;
25335 PyObject *swig_obj[1] ;
25336
25337 if (!args) SWIG_fail;
25338 swig_obj[0] = args;
25339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25340 if (!SWIG_IsOK(res1)) {
25341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25342 }
25343 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25344 {
25345 PyThreadState* __tstate = wxPyBeginAllowThreads();
25346 result = (double)(arg1)->GetJDN();
25347 wxPyEndAllowThreads(__tstate);
25348 if (PyErr_Occurred()) SWIG_fail;
25349 }
25350 resultobj = SWIG_From_double(static_cast< double >(result));
25351 return resultobj;
25352 fail:
25353 return NULL;
25354 }
25355
25356
25357 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25358 PyObject *resultobj = 0;
25359 wxDateTime *arg1 = (wxDateTime *) 0 ;
25360 double result;
25361 void *argp1 = 0 ;
25362 int res1 = 0 ;
25363 PyObject *swig_obj[1] ;
25364
25365 if (!args) SWIG_fail;
25366 swig_obj[0] = args;
25367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25368 if (!SWIG_IsOK(res1)) {
25369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25370 }
25371 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25372 {
25373 PyThreadState* __tstate = wxPyBeginAllowThreads();
25374 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25375 wxPyEndAllowThreads(__tstate);
25376 if (PyErr_Occurred()) SWIG_fail;
25377 }
25378 resultobj = SWIG_From_double(static_cast< double >(result));
25379 return resultobj;
25380 fail:
25381 return NULL;
25382 }
25383
25384
25385 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25386 PyObject *resultobj = 0;
25387 wxDateTime *arg1 = (wxDateTime *) 0 ;
25388 double result;
25389 void *argp1 = 0 ;
25390 int res1 = 0 ;
25391 PyObject *swig_obj[1] ;
25392
25393 if (!args) SWIG_fail;
25394 swig_obj[0] = args;
25395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25396 if (!SWIG_IsOK(res1)) {
25397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25398 }
25399 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25400 {
25401 PyThreadState* __tstate = wxPyBeginAllowThreads();
25402 result = (double)(arg1)->GetMJD();
25403 wxPyEndAllowThreads(__tstate);
25404 if (PyErr_Occurred()) SWIG_fail;
25405 }
25406 resultobj = SWIG_From_double(static_cast< double >(result));
25407 return resultobj;
25408 fail:
25409 return NULL;
25410 }
25411
25412
25413 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25414 PyObject *resultobj = 0;
25415 wxDateTime *arg1 = (wxDateTime *) 0 ;
25416 double result;
25417 void *argp1 = 0 ;
25418 int res1 = 0 ;
25419 PyObject *swig_obj[1] ;
25420
25421 if (!args) SWIG_fail;
25422 swig_obj[0] = args;
25423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25424 if (!SWIG_IsOK(res1)) {
25425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25426 }
25427 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25428 {
25429 PyThreadState* __tstate = wxPyBeginAllowThreads();
25430 result = (double)(arg1)->GetRataDie();
25431 wxPyEndAllowThreads(__tstate);
25432 if (PyErr_Occurred()) SWIG_fail;
25433 }
25434 resultobj = SWIG_From_double(static_cast< double >(result));
25435 return resultobj;
25436 fail:
25437 return NULL;
25438 }
25439
25440
25441 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25442 PyObject *resultobj = 0;
25443 wxDateTime *arg1 = (wxDateTime *) 0 ;
25444 wxDateTime::TimeZone *arg2 = 0 ;
25445 bool arg3 = (bool) false ;
25446 wxDateTime result;
25447 void *argp1 = 0 ;
25448 int res1 = 0 ;
25449 bool temp2 = false ;
25450 bool val3 ;
25451 int ecode3 = 0 ;
25452 PyObject * obj0 = 0 ;
25453 PyObject * obj1 = 0 ;
25454 PyObject * obj2 = 0 ;
25455 char * kwnames[] = {
25456 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25457 };
25458
25459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25461 if (!SWIG_IsOK(res1)) {
25462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25463 }
25464 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25465 {
25466 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25467 temp2 = true;
25468 }
25469 if (obj2) {
25470 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25471 if (!SWIG_IsOK(ecode3)) {
25472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25473 }
25474 arg3 = static_cast< bool >(val3);
25475 }
25476 {
25477 PyThreadState* __tstate = wxPyBeginAllowThreads();
25478 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25479 wxPyEndAllowThreads(__tstate);
25480 if (PyErr_Occurred()) SWIG_fail;
25481 }
25482 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25483 {
25484 if (temp2) delete arg2;
25485 }
25486 return resultobj;
25487 fail:
25488 {
25489 if (temp2) delete arg2;
25490 }
25491 return NULL;
25492 }
25493
25494
25495 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25496 PyObject *resultobj = 0;
25497 wxDateTime *arg1 = (wxDateTime *) 0 ;
25498 wxDateTime::TimeZone *arg2 = 0 ;
25499 bool arg3 = (bool) false ;
25500 wxDateTime *result = 0 ;
25501 void *argp1 = 0 ;
25502 int res1 = 0 ;
25503 bool temp2 = false ;
25504 bool val3 ;
25505 int ecode3 = 0 ;
25506 PyObject * obj0 = 0 ;
25507 PyObject * obj1 = 0 ;
25508 PyObject * obj2 = 0 ;
25509 char * kwnames[] = {
25510 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25511 };
25512
25513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25515 if (!SWIG_IsOK(res1)) {
25516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25517 }
25518 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25519 {
25520 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25521 temp2 = true;
25522 }
25523 if (obj2) {
25524 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25525 if (!SWIG_IsOK(ecode3)) {
25526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25527 }
25528 arg3 = static_cast< bool >(val3);
25529 }
25530 {
25531 PyThreadState* __tstate = wxPyBeginAllowThreads();
25532 {
25533 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25534 result = (wxDateTime *) &_result_ref;
25535 }
25536 wxPyEndAllowThreads(__tstate);
25537 if (PyErr_Occurred()) SWIG_fail;
25538 }
25539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25540 {
25541 if (temp2) delete arg2;
25542 }
25543 return resultobj;
25544 fail:
25545 {
25546 if (temp2) delete arg2;
25547 }
25548 return NULL;
25549 }
25550
25551
25552 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25553 PyObject *resultobj = 0;
25554 wxDateTime *arg1 = (wxDateTime *) 0 ;
25555 wxDateTime::TimeZone *arg2 = 0 ;
25556 bool arg3 = (bool) false ;
25557 wxDateTime result;
25558 void *argp1 = 0 ;
25559 int res1 = 0 ;
25560 bool temp2 = false ;
25561 bool val3 ;
25562 int ecode3 = 0 ;
25563 PyObject * obj0 = 0 ;
25564 PyObject * obj1 = 0 ;
25565 PyObject * obj2 = 0 ;
25566 char * kwnames[] = {
25567 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25568 };
25569
25570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25572 if (!SWIG_IsOK(res1)) {
25573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25574 }
25575 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25576 {
25577 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25578 temp2 = true;
25579 }
25580 if (obj2) {
25581 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25582 if (!SWIG_IsOK(ecode3)) {
25583 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25584 }
25585 arg3 = static_cast< bool >(val3);
25586 }
25587 {
25588 PyThreadState* __tstate = wxPyBeginAllowThreads();
25589 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25590 wxPyEndAllowThreads(__tstate);
25591 if (PyErr_Occurred()) SWIG_fail;
25592 }
25593 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25594 {
25595 if (temp2) delete arg2;
25596 }
25597 return resultobj;
25598 fail:
25599 {
25600 if (temp2) delete arg2;
25601 }
25602 return NULL;
25603 }
25604
25605
25606 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25607 PyObject *resultobj = 0;
25608 wxDateTime *arg1 = (wxDateTime *) 0 ;
25609 wxDateTime::TimeZone *arg2 = 0 ;
25610 bool arg3 = (bool) false ;
25611 wxDateTime *result = 0 ;
25612 void *argp1 = 0 ;
25613 int res1 = 0 ;
25614 bool temp2 = false ;
25615 bool val3 ;
25616 int ecode3 = 0 ;
25617 PyObject * obj0 = 0 ;
25618 PyObject * obj1 = 0 ;
25619 PyObject * obj2 = 0 ;
25620 char * kwnames[] = {
25621 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25622 };
25623
25624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25626 if (!SWIG_IsOK(res1)) {
25627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25628 }
25629 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25630 {
25631 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25632 temp2 = true;
25633 }
25634 if (obj2) {
25635 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25636 if (!SWIG_IsOK(ecode3)) {
25637 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25638 }
25639 arg3 = static_cast< bool >(val3);
25640 }
25641 {
25642 PyThreadState* __tstate = wxPyBeginAllowThreads();
25643 {
25644 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25645 result = (wxDateTime *) &_result_ref;
25646 }
25647 wxPyEndAllowThreads(__tstate);
25648 if (PyErr_Occurred()) SWIG_fail;
25649 }
25650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25651 {
25652 if (temp2) delete arg2;
25653 }
25654 return resultobj;
25655 fail:
25656 {
25657 if (temp2) delete arg2;
25658 }
25659 return NULL;
25660 }
25661
25662
25663 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25664 PyObject *resultobj = 0;
25665 wxDateTime *arg1 = (wxDateTime *) 0 ;
25666 bool arg2 = (bool) false ;
25667 wxDateTime result;
25668 void *argp1 = 0 ;
25669 int res1 = 0 ;
25670 bool val2 ;
25671 int ecode2 = 0 ;
25672 PyObject * obj0 = 0 ;
25673 PyObject * obj1 = 0 ;
25674 char * kwnames[] = {
25675 (char *) "self",(char *) "noDST", NULL
25676 };
25677
25678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25680 if (!SWIG_IsOK(res1)) {
25681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25682 }
25683 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25684 if (obj1) {
25685 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25686 if (!SWIG_IsOK(ecode2)) {
25687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25688 }
25689 arg2 = static_cast< bool >(val2);
25690 }
25691 {
25692 PyThreadState* __tstate = wxPyBeginAllowThreads();
25693 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25694 wxPyEndAllowThreads(__tstate);
25695 if (PyErr_Occurred()) SWIG_fail;
25696 }
25697 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25698 return resultobj;
25699 fail:
25700 return NULL;
25701 }
25702
25703
25704 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25705 PyObject *resultobj = 0;
25706 wxDateTime *arg1 = (wxDateTime *) 0 ;
25707 bool arg2 = (bool) false ;
25708 wxDateTime *result = 0 ;
25709 void *argp1 = 0 ;
25710 int res1 = 0 ;
25711 bool val2 ;
25712 int ecode2 = 0 ;
25713 PyObject * obj0 = 0 ;
25714 PyObject * obj1 = 0 ;
25715 char * kwnames[] = {
25716 (char *) "self",(char *) "noDST", NULL
25717 };
25718
25719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25721 if (!SWIG_IsOK(res1)) {
25722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25723 }
25724 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25725 if (obj1) {
25726 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25727 if (!SWIG_IsOK(ecode2)) {
25728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
25729 }
25730 arg2 = static_cast< bool >(val2);
25731 }
25732 {
25733 PyThreadState* __tstate = wxPyBeginAllowThreads();
25734 {
25735 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
25736 result = (wxDateTime *) &_result_ref;
25737 }
25738 wxPyEndAllowThreads(__tstate);
25739 if (PyErr_Occurred()) SWIG_fail;
25740 }
25741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25742 return resultobj;
25743 fail:
25744 return NULL;
25745 }
25746
25747
25748 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25749 PyObject *resultobj = 0;
25750 wxDateTime *arg1 = (wxDateTime *) 0 ;
25751 bool arg2 = (bool) false ;
25752 wxDateTime result;
25753 void *argp1 = 0 ;
25754 int res1 = 0 ;
25755 bool val2 ;
25756 int ecode2 = 0 ;
25757 PyObject * obj0 = 0 ;
25758 PyObject * obj1 = 0 ;
25759 char * kwnames[] = {
25760 (char *) "self",(char *) "noDST", NULL
25761 };
25762
25763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25765 if (!SWIG_IsOK(res1)) {
25766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25767 }
25768 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25769 if (obj1) {
25770 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25771 if (!SWIG_IsOK(ecode2)) {
25772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
25773 }
25774 arg2 = static_cast< bool >(val2);
25775 }
25776 {
25777 PyThreadState* __tstate = wxPyBeginAllowThreads();
25778 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
25779 wxPyEndAllowThreads(__tstate);
25780 if (PyErr_Occurred()) SWIG_fail;
25781 }
25782 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25783 return resultobj;
25784 fail:
25785 return NULL;
25786 }
25787
25788
25789 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25790 PyObject *resultobj = 0;
25791 wxDateTime *arg1 = (wxDateTime *) 0 ;
25792 bool arg2 = (bool) false ;
25793 wxDateTime *result = 0 ;
25794 void *argp1 = 0 ;
25795 int res1 = 0 ;
25796 bool val2 ;
25797 int ecode2 = 0 ;
25798 PyObject * obj0 = 0 ;
25799 PyObject * obj1 = 0 ;
25800 char * kwnames[] = {
25801 (char *) "self",(char *) "noDST", NULL
25802 };
25803
25804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25806 if (!SWIG_IsOK(res1)) {
25807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
25808 }
25809 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25810 if (obj1) {
25811 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25812 if (!SWIG_IsOK(ecode2)) {
25813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
25814 }
25815 arg2 = static_cast< bool >(val2);
25816 }
25817 {
25818 PyThreadState* __tstate = wxPyBeginAllowThreads();
25819 {
25820 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
25821 result = (wxDateTime *) &_result_ref;
25822 }
25823 wxPyEndAllowThreads(__tstate);
25824 if (PyErr_Occurred()) SWIG_fail;
25825 }
25826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25827 return resultobj;
25828 fail:
25829 return NULL;
25830 }
25831
25832
25833 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25834 PyObject *resultobj = 0;
25835 wxDateTime *arg1 = (wxDateTime *) 0 ;
25836 bool arg2 = (bool) false ;
25837 wxDateTime result;
25838 void *argp1 = 0 ;
25839 int res1 = 0 ;
25840 bool val2 ;
25841 int ecode2 = 0 ;
25842 PyObject * obj0 = 0 ;
25843 PyObject * obj1 = 0 ;
25844 char * kwnames[] = {
25845 (char *) "self",(char *) "noDST", NULL
25846 };
25847
25848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25850 if (!SWIG_IsOK(res1)) {
25851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25852 }
25853 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25854 if (obj1) {
25855 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25856 if (!SWIG_IsOK(ecode2)) {
25857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
25858 }
25859 arg2 = static_cast< bool >(val2);
25860 }
25861 {
25862 PyThreadState* __tstate = wxPyBeginAllowThreads();
25863 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
25864 wxPyEndAllowThreads(__tstate);
25865 if (PyErr_Occurred()) SWIG_fail;
25866 }
25867 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25868 return resultobj;
25869 fail:
25870 return NULL;
25871 }
25872
25873
25874 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25875 PyObject *resultobj = 0;
25876 wxDateTime *arg1 = (wxDateTime *) 0 ;
25877 bool arg2 = (bool) false ;
25878 wxDateTime *result = 0 ;
25879 void *argp1 = 0 ;
25880 int res1 = 0 ;
25881 bool val2 ;
25882 int ecode2 = 0 ;
25883 PyObject * obj0 = 0 ;
25884 PyObject * obj1 = 0 ;
25885 char * kwnames[] = {
25886 (char *) "self",(char *) "noDST", NULL
25887 };
25888
25889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25891 if (!SWIG_IsOK(res1)) {
25892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25893 }
25894 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25895 if (obj1) {
25896 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25897 if (!SWIG_IsOK(ecode2)) {
25898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
25899 }
25900 arg2 = static_cast< bool >(val2);
25901 }
25902 {
25903 PyThreadState* __tstate = wxPyBeginAllowThreads();
25904 {
25905 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
25906 result = (wxDateTime *) &_result_ref;
25907 }
25908 wxPyEndAllowThreads(__tstate);
25909 if (PyErr_Occurred()) SWIG_fail;
25910 }
25911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25912 return resultobj;
25913 fail:
25914 return NULL;
25915 }
25916
25917
25918 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25919 PyObject *resultobj = 0;
25920 wxDateTime *arg1 = (wxDateTime *) 0 ;
25921 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25922 int result;
25923 void *argp1 = 0 ;
25924 int res1 = 0 ;
25925 int val2 ;
25926 int ecode2 = 0 ;
25927 PyObject * obj0 = 0 ;
25928 PyObject * obj1 = 0 ;
25929 char * kwnames[] = {
25930 (char *) "self",(char *) "country", NULL
25931 };
25932
25933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
25934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25935 if (!SWIG_IsOK(res1)) {
25936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
25937 }
25938 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25939 if (obj1) {
25940 ecode2 = SWIG_AsVal_int(obj1, &val2);
25941 if (!SWIG_IsOK(ecode2)) {
25942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25943 }
25944 arg2 = static_cast< wxDateTime::Country >(val2);
25945 }
25946 {
25947 PyThreadState* __tstate = wxPyBeginAllowThreads();
25948 result = (int)(arg1)->IsDST(arg2);
25949 wxPyEndAllowThreads(__tstate);
25950 if (PyErr_Occurred()) SWIG_fail;
25951 }
25952 resultobj = SWIG_From_int(static_cast< int >(result));
25953 return resultobj;
25954 fail:
25955 return NULL;
25956 }
25957
25958
25959 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25960 PyObject *resultobj = 0;
25961 wxDateTime *arg1 = (wxDateTime *) 0 ;
25962 bool result;
25963 void *argp1 = 0 ;
25964 int res1 = 0 ;
25965 PyObject *swig_obj[1] ;
25966
25967 if (!args) SWIG_fail;
25968 swig_obj[0] = args;
25969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25970 if (!SWIG_IsOK(res1)) {
25971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25972 }
25973 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25974 {
25975 PyThreadState* __tstate = wxPyBeginAllowThreads();
25976 result = (bool)((wxDateTime const *)arg1)->IsValid();
25977 wxPyEndAllowThreads(__tstate);
25978 if (PyErr_Occurred()) SWIG_fail;
25979 }
25980 {
25981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25982 }
25983 return resultobj;
25984 fail:
25985 return NULL;
25986 }
25987
25988
25989 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25990 PyObject *resultobj = 0;
25991 wxDateTime *arg1 = (wxDateTime *) 0 ;
25992 time_t result;
25993 void *argp1 = 0 ;
25994 int res1 = 0 ;
25995 PyObject *swig_obj[1] ;
25996
25997 if (!args) SWIG_fail;
25998 swig_obj[0] = args;
25999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26000 if (!SWIG_IsOK(res1)) {
26001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26002 }
26003 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26004 {
26005 PyThreadState* __tstate = wxPyBeginAllowThreads();
26006 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26007 wxPyEndAllowThreads(__tstate);
26008 if (PyErr_Occurred()) SWIG_fail;
26009 }
26010 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26011 return resultobj;
26012 fail:
26013 return NULL;
26014 }
26015
26016
26017 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26018 PyObject *resultobj = 0;
26019 wxDateTime *arg1 = (wxDateTime *) 0 ;
26020 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26021 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26022 int result;
26023 void *argp1 = 0 ;
26024 int res1 = 0 ;
26025 bool temp2 = false ;
26026 PyObject * obj0 = 0 ;
26027 PyObject * obj1 = 0 ;
26028 char * kwnames[] = {
26029 (char *) "self",(char *) "tz", NULL
26030 };
26031
26032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26034 if (!SWIG_IsOK(res1)) {
26035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26036 }
26037 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26038 if (obj1) {
26039 {
26040 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26041 temp2 = true;
26042 }
26043 }
26044 {
26045 PyThreadState* __tstate = wxPyBeginAllowThreads();
26046 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26047 wxPyEndAllowThreads(__tstate);
26048 if (PyErr_Occurred()) SWIG_fail;
26049 }
26050 resultobj = SWIG_From_int(static_cast< int >(result));
26051 {
26052 if (temp2) delete arg2;
26053 }
26054 return resultobj;
26055 fail:
26056 {
26057 if (temp2) delete arg2;
26058 }
26059 return NULL;
26060 }
26061
26062
26063 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26064 PyObject *resultobj = 0;
26065 wxDateTime *arg1 = (wxDateTime *) 0 ;
26066 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26067 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26068 wxDateTime::Month result;
26069 void *argp1 = 0 ;
26070 int res1 = 0 ;
26071 bool temp2 = false ;
26072 PyObject * obj0 = 0 ;
26073 PyObject * obj1 = 0 ;
26074 char * kwnames[] = {
26075 (char *) "self",(char *) "tz", NULL
26076 };
26077
26078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26080 if (!SWIG_IsOK(res1)) {
26081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26082 }
26083 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26084 if (obj1) {
26085 {
26086 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26087 temp2 = true;
26088 }
26089 }
26090 {
26091 PyThreadState* __tstate = wxPyBeginAllowThreads();
26092 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26093 wxPyEndAllowThreads(__tstate);
26094 if (PyErr_Occurred()) SWIG_fail;
26095 }
26096 resultobj = SWIG_From_int(static_cast< int >(result));
26097 {
26098 if (temp2) delete arg2;
26099 }
26100 return resultobj;
26101 fail:
26102 {
26103 if (temp2) delete arg2;
26104 }
26105 return NULL;
26106 }
26107
26108
26109 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26110 PyObject *resultobj = 0;
26111 wxDateTime *arg1 = (wxDateTime *) 0 ;
26112 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26113 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26114 int result;
26115 void *argp1 = 0 ;
26116 int res1 = 0 ;
26117 bool temp2 = false ;
26118 PyObject * obj0 = 0 ;
26119 PyObject * obj1 = 0 ;
26120 char * kwnames[] = {
26121 (char *) "self",(char *) "tz", NULL
26122 };
26123
26124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26126 if (!SWIG_IsOK(res1)) {
26127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26128 }
26129 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26130 if (obj1) {
26131 {
26132 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26133 temp2 = true;
26134 }
26135 }
26136 {
26137 PyThreadState* __tstate = wxPyBeginAllowThreads();
26138 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26139 wxPyEndAllowThreads(__tstate);
26140 if (PyErr_Occurred()) SWIG_fail;
26141 }
26142 resultobj = SWIG_From_int(static_cast< int >(result));
26143 {
26144 if (temp2) delete arg2;
26145 }
26146 return resultobj;
26147 fail:
26148 {
26149 if (temp2) delete arg2;
26150 }
26151 return NULL;
26152 }
26153
26154
26155 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26156 PyObject *resultobj = 0;
26157 wxDateTime *arg1 = (wxDateTime *) 0 ;
26158 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26159 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26160 wxDateTime::WeekDay result;
26161 void *argp1 = 0 ;
26162 int res1 = 0 ;
26163 bool temp2 = false ;
26164 PyObject * obj0 = 0 ;
26165 PyObject * obj1 = 0 ;
26166 char * kwnames[] = {
26167 (char *) "self",(char *) "tz", NULL
26168 };
26169
26170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26172 if (!SWIG_IsOK(res1)) {
26173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26174 }
26175 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26176 if (obj1) {
26177 {
26178 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26179 temp2 = true;
26180 }
26181 }
26182 {
26183 PyThreadState* __tstate = wxPyBeginAllowThreads();
26184 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26185 wxPyEndAllowThreads(__tstate);
26186 if (PyErr_Occurred()) SWIG_fail;
26187 }
26188 resultobj = SWIG_From_int(static_cast< int >(result));
26189 {
26190 if (temp2) delete arg2;
26191 }
26192 return resultobj;
26193 fail:
26194 {
26195 if (temp2) delete arg2;
26196 }
26197 return NULL;
26198 }
26199
26200
26201 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26202 PyObject *resultobj = 0;
26203 wxDateTime *arg1 = (wxDateTime *) 0 ;
26204 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26205 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26206 int result;
26207 void *argp1 = 0 ;
26208 int res1 = 0 ;
26209 bool temp2 = false ;
26210 PyObject * obj0 = 0 ;
26211 PyObject * obj1 = 0 ;
26212 char * kwnames[] = {
26213 (char *) "self",(char *) "tz", NULL
26214 };
26215
26216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26218 if (!SWIG_IsOK(res1)) {
26219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26220 }
26221 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26222 if (obj1) {
26223 {
26224 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26225 temp2 = true;
26226 }
26227 }
26228 {
26229 PyThreadState* __tstate = wxPyBeginAllowThreads();
26230 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26231 wxPyEndAllowThreads(__tstate);
26232 if (PyErr_Occurred()) SWIG_fail;
26233 }
26234 resultobj = SWIG_From_int(static_cast< int >(result));
26235 {
26236 if (temp2) delete arg2;
26237 }
26238 return resultobj;
26239 fail:
26240 {
26241 if (temp2) delete arg2;
26242 }
26243 return NULL;
26244 }
26245
26246
26247 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26248 PyObject *resultobj = 0;
26249 wxDateTime *arg1 = (wxDateTime *) 0 ;
26250 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26251 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26252 int result;
26253 void *argp1 = 0 ;
26254 int res1 = 0 ;
26255 bool temp2 = false ;
26256 PyObject * obj0 = 0 ;
26257 PyObject * obj1 = 0 ;
26258 char * kwnames[] = {
26259 (char *) "self",(char *) "tz", NULL
26260 };
26261
26262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26264 if (!SWIG_IsOK(res1)) {
26265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26266 }
26267 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26268 if (obj1) {
26269 {
26270 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26271 temp2 = true;
26272 }
26273 }
26274 {
26275 PyThreadState* __tstate = wxPyBeginAllowThreads();
26276 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26277 wxPyEndAllowThreads(__tstate);
26278 if (PyErr_Occurred()) SWIG_fail;
26279 }
26280 resultobj = SWIG_From_int(static_cast< int >(result));
26281 {
26282 if (temp2) delete arg2;
26283 }
26284 return resultobj;
26285 fail:
26286 {
26287 if (temp2) delete arg2;
26288 }
26289 return NULL;
26290 }
26291
26292
26293 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26294 PyObject *resultobj = 0;
26295 wxDateTime *arg1 = (wxDateTime *) 0 ;
26296 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26297 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26298 int result;
26299 void *argp1 = 0 ;
26300 int res1 = 0 ;
26301 bool temp2 = false ;
26302 PyObject * obj0 = 0 ;
26303 PyObject * obj1 = 0 ;
26304 char * kwnames[] = {
26305 (char *) "self",(char *) "tz", NULL
26306 };
26307
26308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26310 if (!SWIG_IsOK(res1)) {
26311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26312 }
26313 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26314 if (obj1) {
26315 {
26316 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26317 temp2 = true;
26318 }
26319 }
26320 {
26321 PyThreadState* __tstate = wxPyBeginAllowThreads();
26322 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26323 wxPyEndAllowThreads(__tstate);
26324 if (PyErr_Occurred()) SWIG_fail;
26325 }
26326 resultobj = SWIG_From_int(static_cast< int >(result));
26327 {
26328 if (temp2) delete arg2;
26329 }
26330 return resultobj;
26331 fail:
26332 {
26333 if (temp2) delete arg2;
26334 }
26335 return NULL;
26336 }
26337
26338
26339 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26340 PyObject *resultobj = 0;
26341 wxDateTime *arg1 = (wxDateTime *) 0 ;
26342 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26343 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26344 int result;
26345 void *argp1 = 0 ;
26346 int res1 = 0 ;
26347 bool temp2 = false ;
26348 PyObject * obj0 = 0 ;
26349 PyObject * obj1 = 0 ;
26350 char * kwnames[] = {
26351 (char *) "self",(char *) "tz", NULL
26352 };
26353
26354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26356 if (!SWIG_IsOK(res1)) {
26357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26358 }
26359 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26360 if (obj1) {
26361 {
26362 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26363 temp2 = true;
26364 }
26365 }
26366 {
26367 PyThreadState* __tstate = wxPyBeginAllowThreads();
26368 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26369 wxPyEndAllowThreads(__tstate);
26370 if (PyErr_Occurred()) SWIG_fail;
26371 }
26372 resultobj = SWIG_From_int(static_cast< int >(result));
26373 {
26374 if (temp2) delete arg2;
26375 }
26376 return resultobj;
26377 fail:
26378 {
26379 if (temp2) delete arg2;
26380 }
26381 return NULL;
26382 }
26383
26384
26385 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26386 PyObject *resultobj = 0;
26387 wxDateTime *arg1 = (wxDateTime *) 0 ;
26388 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26389 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26390 int result;
26391 void *argp1 = 0 ;
26392 int res1 = 0 ;
26393 bool temp2 = false ;
26394 PyObject * obj0 = 0 ;
26395 PyObject * obj1 = 0 ;
26396 char * kwnames[] = {
26397 (char *) "self",(char *) "tz", NULL
26398 };
26399
26400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26402 if (!SWIG_IsOK(res1)) {
26403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26404 }
26405 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26406 if (obj1) {
26407 {
26408 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26409 temp2 = true;
26410 }
26411 }
26412 {
26413 PyThreadState* __tstate = wxPyBeginAllowThreads();
26414 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26415 wxPyEndAllowThreads(__tstate);
26416 if (PyErr_Occurred()) SWIG_fail;
26417 }
26418 resultobj = SWIG_From_int(static_cast< int >(result));
26419 {
26420 if (temp2) delete arg2;
26421 }
26422 return resultobj;
26423 fail:
26424 {
26425 if (temp2) delete arg2;
26426 }
26427 return NULL;
26428 }
26429
26430
26431 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26432 PyObject *resultobj = 0;
26433 wxDateTime *arg1 = (wxDateTime *) 0 ;
26434 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26435 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26436 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26437 int result;
26438 void *argp1 = 0 ;
26439 int res1 = 0 ;
26440 int val2 ;
26441 int ecode2 = 0 ;
26442 bool temp3 = false ;
26443 PyObject * obj0 = 0 ;
26444 PyObject * obj1 = 0 ;
26445 PyObject * obj2 = 0 ;
26446 char * kwnames[] = {
26447 (char *) "self",(char *) "flags",(char *) "tz", NULL
26448 };
26449
26450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26452 if (!SWIG_IsOK(res1)) {
26453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26454 }
26455 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26456 if (obj1) {
26457 ecode2 = SWIG_AsVal_int(obj1, &val2);
26458 if (!SWIG_IsOK(ecode2)) {
26459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26460 }
26461 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26462 }
26463 if (obj2) {
26464 {
26465 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26466 temp3 = true;
26467 }
26468 }
26469 {
26470 PyThreadState* __tstate = wxPyBeginAllowThreads();
26471 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26472 wxPyEndAllowThreads(__tstate);
26473 if (PyErr_Occurred()) SWIG_fail;
26474 }
26475 resultobj = SWIG_From_int(static_cast< int >(result));
26476 {
26477 if (temp3) delete arg3;
26478 }
26479 return resultobj;
26480 fail:
26481 {
26482 if (temp3) delete arg3;
26483 }
26484 return NULL;
26485 }
26486
26487
26488 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26489 PyObject *resultobj = 0;
26490 wxDateTime *arg1 = (wxDateTime *) 0 ;
26491 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26492 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26493 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26494 int result;
26495 void *argp1 = 0 ;
26496 int res1 = 0 ;
26497 int val2 ;
26498 int ecode2 = 0 ;
26499 bool temp3 = false ;
26500 PyObject * obj0 = 0 ;
26501 PyObject * obj1 = 0 ;
26502 PyObject * obj2 = 0 ;
26503 char * kwnames[] = {
26504 (char *) "self",(char *) "flags",(char *) "tz", NULL
26505 };
26506
26507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26509 if (!SWIG_IsOK(res1)) {
26510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26511 }
26512 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26513 if (obj1) {
26514 ecode2 = SWIG_AsVal_int(obj1, &val2);
26515 if (!SWIG_IsOK(ecode2)) {
26516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26517 }
26518 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26519 }
26520 if (obj2) {
26521 {
26522 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26523 temp3 = true;
26524 }
26525 }
26526 {
26527 PyThreadState* __tstate = wxPyBeginAllowThreads();
26528 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26529 wxPyEndAllowThreads(__tstate);
26530 if (PyErr_Occurred()) SWIG_fail;
26531 }
26532 resultobj = SWIG_From_int(static_cast< int >(result));
26533 {
26534 if (temp3) delete arg3;
26535 }
26536 return resultobj;
26537 fail:
26538 {
26539 if (temp3) delete arg3;
26540 }
26541 return NULL;
26542 }
26543
26544
26545 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26546 PyObject *resultobj = 0;
26547 wxDateTime *arg1 = (wxDateTime *) 0 ;
26548 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26549 bool result;
26550 void *argp1 = 0 ;
26551 int res1 = 0 ;
26552 int val2 ;
26553 int ecode2 = 0 ;
26554 PyObject * obj0 = 0 ;
26555 PyObject * obj1 = 0 ;
26556 char * kwnames[] = {
26557 (char *) "self",(char *) "country", NULL
26558 };
26559
26560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26562 if (!SWIG_IsOK(res1)) {
26563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26564 }
26565 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26566 if (obj1) {
26567 ecode2 = SWIG_AsVal_int(obj1, &val2);
26568 if (!SWIG_IsOK(ecode2)) {
26569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26570 }
26571 arg2 = static_cast< wxDateTime::Country >(val2);
26572 }
26573 {
26574 PyThreadState* __tstate = wxPyBeginAllowThreads();
26575 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26576 wxPyEndAllowThreads(__tstate);
26577 if (PyErr_Occurred()) SWIG_fail;
26578 }
26579 {
26580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26581 }
26582 return resultobj;
26583 fail:
26584 return NULL;
26585 }
26586
26587
26588 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26589 PyObject *resultobj = 0;
26590 wxDateTime *arg1 = (wxDateTime *) 0 ;
26591 wxDateTime *arg2 = 0 ;
26592 bool result;
26593 void *argp1 = 0 ;
26594 int res1 = 0 ;
26595 void *argp2 = 0 ;
26596 int res2 = 0 ;
26597 PyObject * obj0 = 0 ;
26598 PyObject * obj1 = 0 ;
26599 char * kwnames[] = {
26600 (char *) "self",(char *) "datetime", NULL
26601 };
26602
26603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26605 if (!SWIG_IsOK(res1)) {
26606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26607 }
26608 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26609 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26610 if (!SWIG_IsOK(res2)) {
26611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26612 }
26613 if (!argp2) {
26614 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26615 }
26616 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26617 {
26618 PyThreadState* __tstate = wxPyBeginAllowThreads();
26619 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26620 wxPyEndAllowThreads(__tstate);
26621 if (PyErr_Occurred()) SWIG_fail;
26622 }
26623 {
26624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26625 }
26626 return resultobj;
26627 fail:
26628 return NULL;
26629 }
26630
26631
26632 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26633 PyObject *resultobj = 0;
26634 wxDateTime *arg1 = (wxDateTime *) 0 ;
26635 wxDateTime *arg2 = 0 ;
26636 bool result;
26637 void *argp1 = 0 ;
26638 int res1 = 0 ;
26639 void *argp2 = 0 ;
26640 int res2 = 0 ;
26641 PyObject * obj0 = 0 ;
26642 PyObject * obj1 = 0 ;
26643 char * kwnames[] = {
26644 (char *) "self",(char *) "datetime", NULL
26645 };
26646
26647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26649 if (!SWIG_IsOK(res1)) {
26650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26651 }
26652 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26653 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26654 if (!SWIG_IsOK(res2)) {
26655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26656 }
26657 if (!argp2) {
26658 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26659 }
26660 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26661 {
26662 PyThreadState* __tstate = wxPyBeginAllowThreads();
26663 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26664 wxPyEndAllowThreads(__tstate);
26665 if (PyErr_Occurred()) SWIG_fail;
26666 }
26667 {
26668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26669 }
26670 return resultobj;
26671 fail:
26672 return NULL;
26673 }
26674
26675
26676 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26677 PyObject *resultobj = 0;
26678 wxDateTime *arg1 = (wxDateTime *) 0 ;
26679 wxDateTime *arg2 = 0 ;
26680 bool result;
26681 void *argp1 = 0 ;
26682 int res1 = 0 ;
26683 void *argp2 = 0 ;
26684 int res2 = 0 ;
26685 PyObject * obj0 = 0 ;
26686 PyObject * obj1 = 0 ;
26687 char * kwnames[] = {
26688 (char *) "self",(char *) "datetime", NULL
26689 };
26690
26691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26693 if (!SWIG_IsOK(res1)) {
26694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26695 }
26696 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26697 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26698 if (!SWIG_IsOK(res2)) {
26699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26700 }
26701 if (!argp2) {
26702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26703 }
26704 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26705 {
26706 PyThreadState* __tstate = wxPyBeginAllowThreads();
26707 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26708 wxPyEndAllowThreads(__tstate);
26709 if (PyErr_Occurred()) SWIG_fail;
26710 }
26711 {
26712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26713 }
26714 return resultobj;
26715 fail:
26716 return NULL;
26717 }
26718
26719
26720 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26721 PyObject *resultobj = 0;
26722 wxDateTime *arg1 = (wxDateTime *) 0 ;
26723 wxDateTime *arg2 = 0 ;
26724 wxDateTime *arg3 = 0 ;
26725 bool result;
26726 void *argp1 = 0 ;
26727 int res1 = 0 ;
26728 void *argp2 = 0 ;
26729 int res2 = 0 ;
26730 void *argp3 = 0 ;
26731 int res3 = 0 ;
26732 PyObject * obj0 = 0 ;
26733 PyObject * obj1 = 0 ;
26734 PyObject * obj2 = 0 ;
26735 char * kwnames[] = {
26736 (char *) "self",(char *) "t1",(char *) "t2", NULL
26737 };
26738
26739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26741 if (!SWIG_IsOK(res1)) {
26742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26743 }
26744 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26745 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26746 if (!SWIG_IsOK(res2)) {
26747 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26748 }
26749 if (!argp2) {
26750 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26751 }
26752 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26753 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26754 if (!SWIG_IsOK(res3)) {
26755 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26756 }
26757 if (!argp3) {
26758 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26759 }
26760 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26761 {
26762 PyThreadState* __tstate = wxPyBeginAllowThreads();
26763 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
26764 wxPyEndAllowThreads(__tstate);
26765 if (PyErr_Occurred()) SWIG_fail;
26766 }
26767 {
26768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26769 }
26770 return resultobj;
26771 fail:
26772 return NULL;
26773 }
26774
26775
26776 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26777 PyObject *resultobj = 0;
26778 wxDateTime *arg1 = (wxDateTime *) 0 ;
26779 wxDateTime *arg2 = 0 ;
26780 wxDateTime *arg3 = 0 ;
26781 bool result;
26782 void *argp1 = 0 ;
26783 int res1 = 0 ;
26784 void *argp2 = 0 ;
26785 int res2 = 0 ;
26786 void *argp3 = 0 ;
26787 int res3 = 0 ;
26788 PyObject * obj0 = 0 ;
26789 PyObject * obj1 = 0 ;
26790 PyObject * obj2 = 0 ;
26791 char * kwnames[] = {
26792 (char *) "self",(char *) "t1",(char *) "t2", NULL
26793 };
26794
26795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26797 if (!SWIG_IsOK(res1)) {
26798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26799 }
26800 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26801 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26802 if (!SWIG_IsOK(res2)) {
26803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26804 }
26805 if (!argp2) {
26806 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26807 }
26808 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26809 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26810 if (!SWIG_IsOK(res3)) {
26811 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26812 }
26813 if (!argp3) {
26814 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26815 }
26816 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26817 {
26818 PyThreadState* __tstate = wxPyBeginAllowThreads();
26819 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
26820 wxPyEndAllowThreads(__tstate);
26821 if (PyErr_Occurred()) SWIG_fail;
26822 }
26823 {
26824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26825 }
26826 return resultobj;
26827 fail:
26828 return NULL;
26829 }
26830
26831
26832 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26833 PyObject *resultobj = 0;
26834 wxDateTime *arg1 = (wxDateTime *) 0 ;
26835 wxDateTime *arg2 = 0 ;
26836 bool result;
26837 void *argp1 = 0 ;
26838 int res1 = 0 ;
26839 void *argp2 = 0 ;
26840 int res2 = 0 ;
26841 PyObject * obj0 = 0 ;
26842 PyObject * obj1 = 0 ;
26843 char * kwnames[] = {
26844 (char *) "self",(char *) "dt", NULL
26845 };
26846
26847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
26848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26849 if (!SWIG_IsOK(res1)) {
26850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26851 }
26852 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26853 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26854 if (!SWIG_IsOK(res2)) {
26855 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26856 }
26857 if (!argp2) {
26858 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26859 }
26860 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26861 {
26862 PyThreadState* __tstate = wxPyBeginAllowThreads();
26863 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
26864 wxPyEndAllowThreads(__tstate);
26865 if (PyErr_Occurred()) SWIG_fail;
26866 }
26867 {
26868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26869 }
26870 return resultobj;
26871 fail:
26872 return NULL;
26873 }
26874
26875
26876 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26877 PyObject *resultobj = 0;
26878 wxDateTime *arg1 = (wxDateTime *) 0 ;
26879 wxDateTime *arg2 = 0 ;
26880 bool result;
26881 void *argp1 = 0 ;
26882 int res1 = 0 ;
26883 void *argp2 = 0 ;
26884 int res2 = 0 ;
26885 PyObject * obj0 = 0 ;
26886 PyObject * obj1 = 0 ;
26887 char * kwnames[] = {
26888 (char *) "self",(char *) "dt", NULL
26889 };
26890
26891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
26892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26893 if (!SWIG_IsOK(res1)) {
26894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26895 }
26896 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26897 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26898 if (!SWIG_IsOK(res2)) {
26899 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26900 }
26901 if (!argp2) {
26902 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26903 }
26904 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26905 {
26906 PyThreadState* __tstate = wxPyBeginAllowThreads();
26907 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
26908 wxPyEndAllowThreads(__tstate);
26909 if (PyErr_Occurred()) SWIG_fail;
26910 }
26911 {
26912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26913 }
26914 return resultobj;
26915 fail:
26916 return NULL;
26917 }
26918
26919
26920 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26921 PyObject *resultobj = 0;
26922 wxDateTime *arg1 = (wxDateTime *) 0 ;
26923 wxDateTime *arg2 = 0 ;
26924 wxTimeSpan *arg3 = 0 ;
26925 bool result;
26926 void *argp1 = 0 ;
26927 int res1 = 0 ;
26928 void *argp2 = 0 ;
26929 int res2 = 0 ;
26930 void *argp3 = 0 ;
26931 int res3 = 0 ;
26932 PyObject * obj0 = 0 ;
26933 PyObject * obj1 = 0 ;
26934 PyObject * obj2 = 0 ;
26935 char * kwnames[] = {
26936 (char *) "self",(char *) "dt",(char *) "ts", NULL
26937 };
26938
26939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26941 if (!SWIG_IsOK(res1)) {
26942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26943 }
26944 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26945 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26946 if (!SWIG_IsOK(res2)) {
26947 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26948 }
26949 if (!argp2) {
26950 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26951 }
26952 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26953 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26954 if (!SWIG_IsOK(res3)) {
26955 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26956 }
26957 if (!argp3) {
26958 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26959 }
26960 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
26961 {
26962 PyThreadState* __tstate = wxPyBeginAllowThreads();
26963 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
26964 wxPyEndAllowThreads(__tstate);
26965 if (PyErr_Occurred()) SWIG_fail;
26966 }
26967 {
26968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26969 }
26970 return resultobj;
26971 fail:
26972 return NULL;
26973 }
26974
26975
26976 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26977 PyObject *resultobj = 0;
26978 wxDateTime *arg1 = (wxDateTime *) 0 ;
26979 wxTimeSpan *arg2 = 0 ;
26980 wxDateTime *result = 0 ;
26981 void *argp1 = 0 ;
26982 int res1 = 0 ;
26983 void *argp2 = 0 ;
26984 int res2 = 0 ;
26985 PyObject * obj0 = 0 ;
26986 PyObject * obj1 = 0 ;
26987 char * kwnames[] = {
26988 (char *) "self",(char *) "diff", NULL
26989 };
26990
26991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
26992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26993 if (!SWIG_IsOK(res1)) {
26994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26995 }
26996 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26997 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26998 if (!SWIG_IsOK(res2)) {
26999 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27000 }
27001 if (!argp2) {
27002 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27003 }
27004 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27005 {
27006 PyThreadState* __tstate = wxPyBeginAllowThreads();
27007 {
27008 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27009 result = (wxDateTime *) &_result_ref;
27010 }
27011 wxPyEndAllowThreads(__tstate);
27012 if (PyErr_Occurred()) SWIG_fail;
27013 }
27014 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27015 return resultobj;
27016 fail:
27017 return NULL;
27018 }
27019
27020
27021 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27022 PyObject *resultobj = 0;
27023 wxDateTime *arg1 = (wxDateTime *) 0 ;
27024 wxDateSpan *arg2 = 0 ;
27025 wxDateTime *result = 0 ;
27026 void *argp1 = 0 ;
27027 int res1 = 0 ;
27028 void *argp2 = 0 ;
27029 int res2 = 0 ;
27030 PyObject * obj0 = 0 ;
27031 PyObject * obj1 = 0 ;
27032 char * kwnames[] = {
27033 (char *) "self",(char *) "diff", NULL
27034 };
27035
27036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27038 if (!SWIG_IsOK(res1)) {
27039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27040 }
27041 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27042 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27043 if (!SWIG_IsOK(res2)) {
27044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27045 }
27046 if (!argp2) {
27047 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27048 }
27049 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27050 {
27051 PyThreadState* __tstate = wxPyBeginAllowThreads();
27052 {
27053 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27054 result = (wxDateTime *) &_result_ref;
27055 }
27056 wxPyEndAllowThreads(__tstate);
27057 if (PyErr_Occurred()) SWIG_fail;
27058 }
27059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27060 return resultobj;
27061 fail:
27062 return NULL;
27063 }
27064
27065
27066 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27067 PyObject *resultobj = 0;
27068 wxDateTime *arg1 = (wxDateTime *) 0 ;
27069 wxTimeSpan *arg2 = 0 ;
27070 wxDateTime *result = 0 ;
27071 void *argp1 = 0 ;
27072 int res1 = 0 ;
27073 void *argp2 = 0 ;
27074 int res2 = 0 ;
27075 PyObject * obj0 = 0 ;
27076 PyObject * obj1 = 0 ;
27077 char * kwnames[] = {
27078 (char *) "self",(char *) "diff", NULL
27079 };
27080
27081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27083 if (!SWIG_IsOK(res1)) {
27084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27085 }
27086 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27087 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27088 if (!SWIG_IsOK(res2)) {
27089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27090 }
27091 if (!argp2) {
27092 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27093 }
27094 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27095 {
27096 PyThreadState* __tstate = wxPyBeginAllowThreads();
27097 {
27098 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27099 result = (wxDateTime *) &_result_ref;
27100 }
27101 wxPyEndAllowThreads(__tstate);
27102 if (PyErr_Occurred()) SWIG_fail;
27103 }
27104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27105 return resultobj;
27106 fail:
27107 return NULL;
27108 }
27109
27110
27111 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27112 PyObject *resultobj = 0;
27113 wxDateTime *arg1 = (wxDateTime *) 0 ;
27114 wxDateSpan *arg2 = 0 ;
27115 wxDateTime *result = 0 ;
27116 void *argp1 = 0 ;
27117 int res1 = 0 ;
27118 void *argp2 = 0 ;
27119 int res2 = 0 ;
27120 PyObject * obj0 = 0 ;
27121 PyObject * obj1 = 0 ;
27122 char * kwnames[] = {
27123 (char *) "self",(char *) "diff", NULL
27124 };
27125
27126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27128 if (!SWIG_IsOK(res1)) {
27129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27130 }
27131 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27132 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27133 if (!SWIG_IsOK(res2)) {
27134 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27135 }
27136 if (!argp2) {
27137 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27138 }
27139 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27140 {
27141 PyThreadState* __tstate = wxPyBeginAllowThreads();
27142 {
27143 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27144 result = (wxDateTime *) &_result_ref;
27145 }
27146 wxPyEndAllowThreads(__tstate);
27147 if (PyErr_Occurred()) SWIG_fail;
27148 }
27149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27150 return resultobj;
27151 fail:
27152 return NULL;
27153 }
27154
27155
27156 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27157 PyObject *resultobj = 0;
27158 wxDateTime *arg1 = (wxDateTime *) 0 ;
27159 wxDateTime *arg2 = 0 ;
27160 wxTimeSpan result;
27161 void *argp1 = 0 ;
27162 int res1 = 0 ;
27163 void *argp2 = 0 ;
27164 int res2 = 0 ;
27165 PyObject * obj0 = 0 ;
27166 PyObject * obj1 = 0 ;
27167 char * kwnames[] = {
27168 (char *) "self",(char *) "dt", NULL
27169 };
27170
27171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27173 if (!SWIG_IsOK(res1)) {
27174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27175 }
27176 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27177 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27178 if (!SWIG_IsOK(res2)) {
27179 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27180 }
27181 if (!argp2) {
27182 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27183 }
27184 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27185 {
27186 PyThreadState* __tstate = wxPyBeginAllowThreads();
27187 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27188 wxPyEndAllowThreads(__tstate);
27189 if (PyErr_Occurred()) SWIG_fail;
27190 }
27191 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27192 return resultobj;
27193 fail:
27194 return NULL;
27195 }
27196
27197
27198 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27199 PyObject *resultobj = 0;
27200 wxDateTime *arg1 = (wxDateTime *) 0 ;
27201 wxTimeSpan *arg2 = 0 ;
27202 wxDateTime *result = 0 ;
27203 void *argp1 = 0 ;
27204 int res1 = 0 ;
27205 void *argp2 = 0 ;
27206 int res2 = 0 ;
27207
27208 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27210 if (!SWIG_IsOK(res1)) {
27211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27212 }
27213 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27214 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27215 if (!SWIG_IsOK(res2)) {
27216 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27217 }
27218 if (!argp2) {
27219 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27220 }
27221 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27222 {
27223 PyThreadState* __tstate = wxPyBeginAllowThreads();
27224 {
27225 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27226 result = (wxDateTime *) &_result_ref;
27227 }
27228 wxPyEndAllowThreads(__tstate);
27229 if (PyErr_Occurred()) SWIG_fail;
27230 }
27231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27232 return resultobj;
27233 fail:
27234 return NULL;
27235 }
27236
27237
27238 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27239 PyObject *resultobj = 0;
27240 wxDateTime *arg1 = (wxDateTime *) 0 ;
27241 wxDateSpan *arg2 = 0 ;
27242 wxDateTime *result = 0 ;
27243 void *argp1 = 0 ;
27244 int res1 = 0 ;
27245 void *argp2 = 0 ;
27246 int res2 = 0 ;
27247
27248 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27250 if (!SWIG_IsOK(res1)) {
27251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27252 }
27253 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27254 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27255 if (!SWIG_IsOK(res2)) {
27256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27257 }
27258 if (!argp2) {
27259 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27260 }
27261 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27262 {
27263 PyThreadState* __tstate = wxPyBeginAllowThreads();
27264 {
27265 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27266 result = (wxDateTime *) &_result_ref;
27267 }
27268 wxPyEndAllowThreads(__tstate);
27269 if (PyErr_Occurred()) SWIG_fail;
27270 }
27271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27272 return resultobj;
27273 fail:
27274 return NULL;
27275 }
27276
27277
27278 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27279 int argc;
27280 PyObject *argv[3];
27281
27282 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27283 --argc;
27284 if (argc == 2) {
27285 int _v = 0;
27286 {
27287 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27288 _v = SWIG_CheckState(res);
27289 }
27290 if (!_v) goto check_1;
27291 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27292 }
27293 check_1:
27294
27295 if (argc == 2) {
27296 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27297 }
27298
27299 fail:
27300 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27301 return NULL;
27302 }
27303
27304
27305 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27306 PyObject *resultobj = 0;
27307 wxDateTime *arg1 = (wxDateTime *) 0 ;
27308 wxTimeSpan *arg2 = 0 ;
27309 wxDateTime *result = 0 ;
27310 void *argp1 = 0 ;
27311 int res1 = 0 ;
27312 void *argp2 = 0 ;
27313 int res2 = 0 ;
27314
27315 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27317 if (!SWIG_IsOK(res1)) {
27318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27319 }
27320 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27321 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27322 if (!SWIG_IsOK(res2)) {
27323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27324 }
27325 if (!argp2) {
27326 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27327 }
27328 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27329 {
27330 PyThreadState* __tstate = wxPyBeginAllowThreads();
27331 {
27332 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27333 result = (wxDateTime *) &_result_ref;
27334 }
27335 wxPyEndAllowThreads(__tstate);
27336 if (PyErr_Occurred()) SWIG_fail;
27337 }
27338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27339 return resultobj;
27340 fail:
27341 return NULL;
27342 }
27343
27344
27345 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27346 PyObject *resultobj = 0;
27347 wxDateTime *arg1 = (wxDateTime *) 0 ;
27348 wxDateSpan *arg2 = 0 ;
27349 wxDateTime *result = 0 ;
27350 void *argp1 = 0 ;
27351 int res1 = 0 ;
27352 void *argp2 = 0 ;
27353 int res2 = 0 ;
27354
27355 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27357 if (!SWIG_IsOK(res1)) {
27358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27359 }
27360 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27361 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27362 if (!SWIG_IsOK(res2)) {
27363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27364 }
27365 if (!argp2) {
27366 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27367 }
27368 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27369 {
27370 PyThreadState* __tstate = wxPyBeginAllowThreads();
27371 {
27372 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27373 result = (wxDateTime *) &_result_ref;
27374 }
27375 wxPyEndAllowThreads(__tstate);
27376 if (PyErr_Occurred()) SWIG_fail;
27377 }
27378 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27379 return resultobj;
27380 fail:
27381 return NULL;
27382 }
27383
27384
27385 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27386 int argc;
27387 PyObject *argv[3];
27388
27389 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27390 --argc;
27391 if (argc == 2) {
27392 int _v = 0;
27393 {
27394 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27395 _v = SWIG_CheckState(res);
27396 }
27397 if (!_v) goto check_1;
27398 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27399 }
27400 check_1:
27401
27402 if (argc == 2) {
27403 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27404 }
27405
27406 fail:
27407 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27408 return NULL;
27409 }
27410
27411
27412 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27413 PyObject *resultobj = 0;
27414 wxDateTime *arg1 = (wxDateTime *) 0 ;
27415 wxTimeSpan *arg2 = 0 ;
27416 wxDateTime result;
27417 void *argp1 = 0 ;
27418 int res1 = 0 ;
27419 void *argp2 = 0 ;
27420 int res2 = 0 ;
27421
27422 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27424 if (!SWIG_IsOK(res1)) {
27425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27426 }
27427 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27428 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27429 if (!SWIG_IsOK(res2)) {
27430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27431 }
27432 if (!argp2) {
27433 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27434 }
27435 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27436 {
27437 PyThreadState* __tstate = wxPyBeginAllowThreads();
27438 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27439 wxPyEndAllowThreads(__tstate);
27440 if (PyErr_Occurred()) SWIG_fail;
27441 }
27442 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27443 return resultobj;
27444 fail:
27445 return NULL;
27446 }
27447
27448
27449 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27450 PyObject *resultobj = 0;
27451 wxDateTime *arg1 = (wxDateTime *) 0 ;
27452 wxDateSpan *arg2 = 0 ;
27453 wxDateTime result;
27454 void *argp1 = 0 ;
27455 int res1 = 0 ;
27456 void *argp2 = 0 ;
27457 int res2 = 0 ;
27458
27459 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27461 if (!SWIG_IsOK(res1)) {
27462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27463 }
27464 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27465 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27466 if (!SWIG_IsOK(res2)) {
27467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27468 }
27469 if (!argp2) {
27470 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27471 }
27472 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27473 {
27474 PyThreadState* __tstate = wxPyBeginAllowThreads();
27475 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27476 wxPyEndAllowThreads(__tstate);
27477 if (PyErr_Occurred()) SWIG_fail;
27478 }
27479 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27480 return resultobj;
27481 fail:
27482 return NULL;
27483 }
27484
27485
27486 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27487 int argc;
27488 PyObject *argv[3];
27489
27490 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27491 --argc;
27492 if (argc == 2) {
27493 int _v = 0;
27494 {
27495 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27496 _v = SWIG_CheckState(res);
27497 }
27498 if (!_v) goto check_1;
27499 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27500 }
27501 check_1:
27502
27503 if (argc == 2) {
27504 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27505 }
27506
27507 fail:
27508 Py_INCREF(Py_NotImplemented);
27509 return Py_NotImplemented;
27510 }
27511
27512
27513 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27514 PyObject *resultobj = 0;
27515 wxDateTime *arg1 = (wxDateTime *) 0 ;
27516 wxDateTime *arg2 = 0 ;
27517 wxTimeSpan result;
27518 void *argp1 = 0 ;
27519 int res1 = 0 ;
27520 void *argp2 = 0 ;
27521 int res2 = 0 ;
27522
27523 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27525 if (!SWIG_IsOK(res1)) {
27526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27527 }
27528 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27529 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27530 if (!SWIG_IsOK(res2)) {
27531 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27532 }
27533 if (!argp2) {
27534 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27535 }
27536 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27537 {
27538 PyThreadState* __tstate = wxPyBeginAllowThreads();
27539 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27540 wxPyEndAllowThreads(__tstate);
27541 if (PyErr_Occurred()) SWIG_fail;
27542 }
27543 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27544 return resultobj;
27545 fail:
27546 return NULL;
27547 }
27548
27549
27550 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27551 PyObject *resultobj = 0;
27552 wxDateTime *arg1 = (wxDateTime *) 0 ;
27553 wxTimeSpan *arg2 = 0 ;
27554 wxDateTime result;
27555 void *argp1 = 0 ;
27556 int res1 = 0 ;
27557 void *argp2 = 0 ;
27558 int res2 = 0 ;
27559
27560 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27562 if (!SWIG_IsOK(res1)) {
27563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27564 }
27565 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27566 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27567 if (!SWIG_IsOK(res2)) {
27568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27569 }
27570 if (!argp2) {
27571 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27572 }
27573 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27574 {
27575 PyThreadState* __tstate = wxPyBeginAllowThreads();
27576 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27577 wxPyEndAllowThreads(__tstate);
27578 if (PyErr_Occurred()) SWIG_fail;
27579 }
27580 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27581 return resultobj;
27582 fail:
27583 return NULL;
27584 }
27585
27586
27587 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27588 PyObject *resultobj = 0;
27589 wxDateTime *arg1 = (wxDateTime *) 0 ;
27590 wxDateSpan *arg2 = 0 ;
27591 wxDateTime result;
27592 void *argp1 = 0 ;
27593 int res1 = 0 ;
27594 void *argp2 = 0 ;
27595 int res2 = 0 ;
27596
27597 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27599 if (!SWIG_IsOK(res1)) {
27600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27601 }
27602 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27603 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27604 if (!SWIG_IsOK(res2)) {
27605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27606 }
27607 if (!argp2) {
27608 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27609 }
27610 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27611 {
27612 PyThreadState* __tstate = wxPyBeginAllowThreads();
27613 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27614 wxPyEndAllowThreads(__tstate);
27615 if (PyErr_Occurred()) SWIG_fail;
27616 }
27617 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27618 return resultobj;
27619 fail:
27620 return NULL;
27621 }
27622
27623
27624 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27625 int argc;
27626 PyObject *argv[3];
27627
27628 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27629 --argc;
27630 if (argc == 2) {
27631 int _v = 0;
27632 {
27633 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27634 _v = SWIG_CheckState(res);
27635 }
27636 if (!_v) goto check_1;
27637 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27638 }
27639 check_1:
27640
27641 if (argc == 2) {
27642 int _v = 0;
27643 {
27644 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27645 _v = SWIG_CheckState(res);
27646 }
27647 if (!_v) goto check_2;
27648 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27649 }
27650 check_2:
27651
27652 if (argc == 2) {
27653 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27654 }
27655
27656 fail:
27657 Py_INCREF(Py_NotImplemented);
27658 return Py_NotImplemented;
27659 }
27660
27661
27662 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27663 PyObject *resultobj = 0;
27664 wxDateTime *arg1 = (wxDateTime *) 0 ;
27665 wxDateTime *arg2 = (wxDateTime *) 0 ;
27666 bool result;
27667 void *argp1 = 0 ;
27668 int res1 = 0 ;
27669 void *argp2 = 0 ;
27670 int res2 = 0 ;
27671 PyObject * obj0 = 0 ;
27672 PyObject * obj1 = 0 ;
27673 char * kwnames[] = {
27674 (char *) "self",(char *) "other", NULL
27675 };
27676
27677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27679 if (!SWIG_IsOK(res1)) {
27680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27681 }
27682 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27683 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27684 if (!SWIG_IsOK(res2)) {
27685 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27686 }
27687 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27688 {
27689 PyThreadState* __tstate = wxPyBeginAllowThreads();
27690 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27691 wxPyEndAllowThreads(__tstate);
27692 if (PyErr_Occurred()) SWIG_fail;
27693 }
27694 {
27695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27696 }
27697 return resultobj;
27698 fail:
27699 return NULL;
27700 }
27701
27702
27703 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27704 PyObject *resultobj = 0;
27705 wxDateTime *arg1 = (wxDateTime *) 0 ;
27706 wxDateTime *arg2 = (wxDateTime *) 0 ;
27707 bool result;
27708 void *argp1 = 0 ;
27709 int res1 = 0 ;
27710 void *argp2 = 0 ;
27711 int res2 = 0 ;
27712 PyObject * obj0 = 0 ;
27713 PyObject * obj1 = 0 ;
27714 char * kwnames[] = {
27715 (char *) "self",(char *) "other", NULL
27716 };
27717
27718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27720 if (!SWIG_IsOK(res1)) {
27721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27722 }
27723 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27724 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27725 if (!SWIG_IsOK(res2)) {
27726 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27727 }
27728 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27729 {
27730 PyThreadState* __tstate = wxPyBeginAllowThreads();
27731 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
27732 wxPyEndAllowThreads(__tstate);
27733 if (PyErr_Occurred()) SWIG_fail;
27734 }
27735 {
27736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27737 }
27738 return resultobj;
27739 fail:
27740 return NULL;
27741 }
27742
27743
27744 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27745 PyObject *resultobj = 0;
27746 wxDateTime *arg1 = (wxDateTime *) 0 ;
27747 wxDateTime *arg2 = (wxDateTime *) 0 ;
27748 bool result;
27749 void *argp1 = 0 ;
27750 int res1 = 0 ;
27751 void *argp2 = 0 ;
27752 int res2 = 0 ;
27753 PyObject * obj0 = 0 ;
27754 PyObject * obj1 = 0 ;
27755 char * kwnames[] = {
27756 (char *) "self",(char *) "other", NULL
27757 };
27758
27759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
27760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27761 if (!SWIG_IsOK(res1)) {
27762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27763 }
27764 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27765 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27766 if (!SWIG_IsOK(res2)) {
27767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27768 }
27769 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27770 {
27771 PyThreadState* __tstate = wxPyBeginAllowThreads();
27772 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
27773 wxPyEndAllowThreads(__tstate);
27774 if (PyErr_Occurred()) SWIG_fail;
27775 }
27776 {
27777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27778 }
27779 return resultobj;
27780 fail:
27781 return NULL;
27782 }
27783
27784
27785 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27786 PyObject *resultobj = 0;
27787 wxDateTime *arg1 = (wxDateTime *) 0 ;
27788 wxDateTime *arg2 = (wxDateTime *) 0 ;
27789 bool result;
27790 void *argp1 = 0 ;
27791 int res1 = 0 ;
27792 void *argp2 = 0 ;
27793 int res2 = 0 ;
27794 PyObject * obj0 = 0 ;
27795 PyObject * obj1 = 0 ;
27796 char * kwnames[] = {
27797 (char *) "self",(char *) "other", NULL
27798 };
27799
27800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
27801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27802 if (!SWIG_IsOK(res1)) {
27803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27804 }
27805 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27806 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27807 if (!SWIG_IsOK(res2)) {
27808 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27809 }
27810 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27811 {
27812 PyThreadState* __tstate = wxPyBeginAllowThreads();
27813 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
27814 wxPyEndAllowThreads(__tstate);
27815 if (PyErr_Occurred()) SWIG_fail;
27816 }
27817 {
27818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27819 }
27820 return resultobj;
27821 fail:
27822 return NULL;
27823 }
27824
27825
27826 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27827 PyObject *resultobj = 0;
27828 wxDateTime *arg1 = (wxDateTime *) 0 ;
27829 wxDateTime *arg2 = (wxDateTime *) 0 ;
27830 bool result;
27831 void *argp1 = 0 ;
27832 int res1 = 0 ;
27833 void *argp2 = 0 ;
27834 int res2 = 0 ;
27835 PyObject * obj0 = 0 ;
27836 PyObject * obj1 = 0 ;
27837 char * kwnames[] = {
27838 (char *) "self",(char *) "other", NULL
27839 };
27840
27841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
27842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27843 if (!SWIG_IsOK(res1)) {
27844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27845 }
27846 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27847 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27848 if (!SWIG_IsOK(res2)) {
27849 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27850 }
27851 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27852 {
27853 PyThreadState* __tstate = wxPyBeginAllowThreads();
27854 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
27855 wxPyEndAllowThreads(__tstate);
27856 if (PyErr_Occurred()) SWIG_fail;
27857 }
27858 {
27859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27860 }
27861 return resultobj;
27862 fail:
27863 return NULL;
27864 }
27865
27866
27867 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27868 PyObject *resultobj = 0;
27869 wxDateTime *arg1 = (wxDateTime *) 0 ;
27870 wxDateTime *arg2 = (wxDateTime *) 0 ;
27871 bool result;
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 *) "other", NULL
27880 };
27881
27882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
27883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27884 if (!SWIG_IsOK(res1)) {
27885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27886 }
27887 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27888 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27889 if (!SWIG_IsOK(res2)) {
27890 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27891 }
27892 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27893 {
27894 PyThreadState* __tstate = wxPyBeginAllowThreads();
27895 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
27896 wxPyEndAllowThreads(__tstate);
27897 if (PyErr_Occurred()) SWIG_fail;
27898 }
27899 {
27900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27901 }
27902 return resultobj;
27903 fail:
27904 return NULL;
27905 }
27906
27907
27908 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27909 PyObject *resultobj = 0;
27910 wxDateTime *arg1 = (wxDateTime *) 0 ;
27911 wxString *arg2 = 0 ;
27912 int result;
27913 void *argp1 = 0 ;
27914 int res1 = 0 ;
27915 bool temp2 = false ;
27916 PyObject * obj0 = 0 ;
27917 PyObject * obj1 = 0 ;
27918 char * kwnames[] = {
27919 (char *) "self",(char *) "date", NULL
27920 };
27921
27922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
27923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27924 if (!SWIG_IsOK(res1)) {
27925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
27926 }
27927 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27928 {
27929 arg2 = wxString_in_helper(obj1);
27930 if (arg2 == NULL) SWIG_fail;
27931 temp2 = true;
27932 }
27933 {
27934 PyThreadState* __tstate = wxPyBeginAllowThreads();
27935 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
27936 wxPyEndAllowThreads(__tstate);
27937 if (PyErr_Occurred()) SWIG_fail;
27938 }
27939 resultobj = SWIG_From_int(static_cast< int >(result));
27940 {
27941 if (temp2)
27942 delete arg2;
27943 }
27944 return resultobj;
27945 fail:
27946 {
27947 if (temp2)
27948 delete arg2;
27949 }
27950 return NULL;
27951 }
27952
27953
27954 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27955 PyObject *resultobj = 0;
27956 wxDateTime *arg1 = (wxDateTime *) 0 ;
27957 wxString *arg2 = 0 ;
27958 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
27959 wxString *arg3 = (wxString *) &arg3_defvalue ;
27960 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
27961 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
27962 int result;
27963 void *argp1 = 0 ;
27964 int res1 = 0 ;
27965 bool temp2 = false ;
27966 bool temp3 = false ;
27967 void *argp4 = 0 ;
27968 int res4 = 0 ;
27969 PyObject * obj0 = 0 ;
27970 PyObject * obj1 = 0 ;
27971 PyObject * obj2 = 0 ;
27972 PyObject * obj3 = 0 ;
27973 char * kwnames[] = {
27974 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
27975 };
27976
27977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27979 if (!SWIG_IsOK(res1)) {
27980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
27981 }
27982 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27983 {
27984 arg2 = wxString_in_helper(obj1);
27985 if (arg2 == NULL) SWIG_fail;
27986 temp2 = true;
27987 }
27988 if (obj2) {
27989 {
27990 arg3 = wxString_in_helper(obj2);
27991 if (arg3 == NULL) SWIG_fail;
27992 temp3 = true;
27993 }
27994 }
27995 if (obj3) {
27996 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
27997 if (!SWIG_IsOK(res4)) {
27998 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
27999 }
28000 if (!argp4) {
28001 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28002 }
28003 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28004 }
28005 {
28006 PyThreadState* __tstate = wxPyBeginAllowThreads();
28007 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28008 wxPyEndAllowThreads(__tstate);
28009 if (PyErr_Occurred()) SWIG_fail;
28010 }
28011 resultobj = SWIG_From_int(static_cast< int >(result));
28012 {
28013 if (temp2)
28014 delete arg2;
28015 }
28016 {
28017 if (temp3)
28018 delete arg3;
28019 }
28020 return resultobj;
28021 fail:
28022 {
28023 if (temp2)
28024 delete arg2;
28025 }
28026 {
28027 if (temp3)
28028 delete arg3;
28029 }
28030 return NULL;
28031 }
28032
28033
28034 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28035 PyObject *resultobj = 0;
28036 wxDateTime *arg1 = (wxDateTime *) 0 ;
28037 wxString *arg2 = 0 ;
28038 int result;
28039 void *argp1 = 0 ;
28040 int res1 = 0 ;
28041 bool temp2 = false ;
28042 PyObject * obj0 = 0 ;
28043 PyObject * obj1 = 0 ;
28044 char * kwnames[] = {
28045 (char *) "self",(char *) "datetime", NULL
28046 };
28047
28048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28050 if (!SWIG_IsOK(res1)) {
28051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28052 }
28053 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28054 {
28055 arg2 = wxString_in_helper(obj1);
28056 if (arg2 == NULL) SWIG_fail;
28057 temp2 = true;
28058 }
28059 {
28060 PyThreadState* __tstate = wxPyBeginAllowThreads();
28061 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28062 wxPyEndAllowThreads(__tstate);
28063 if (PyErr_Occurred()) SWIG_fail;
28064 }
28065 resultobj = SWIG_From_int(static_cast< int >(result));
28066 {
28067 if (temp2)
28068 delete arg2;
28069 }
28070 return resultobj;
28071 fail:
28072 {
28073 if (temp2)
28074 delete arg2;
28075 }
28076 return NULL;
28077 }
28078
28079
28080 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28081 PyObject *resultobj = 0;
28082 wxDateTime *arg1 = (wxDateTime *) 0 ;
28083 wxString *arg2 = 0 ;
28084 int result;
28085 void *argp1 = 0 ;
28086 int res1 = 0 ;
28087 bool temp2 = false ;
28088 PyObject * obj0 = 0 ;
28089 PyObject * obj1 = 0 ;
28090 char * kwnames[] = {
28091 (char *) "self",(char *) "date", NULL
28092 };
28093
28094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28096 if (!SWIG_IsOK(res1)) {
28097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28098 }
28099 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28100 {
28101 arg2 = wxString_in_helper(obj1);
28102 if (arg2 == NULL) SWIG_fail;
28103 temp2 = true;
28104 }
28105 {
28106 PyThreadState* __tstate = wxPyBeginAllowThreads();
28107 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28108 wxPyEndAllowThreads(__tstate);
28109 if (PyErr_Occurred()) SWIG_fail;
28110 }
28111 resultobj = SWIG_From_int(static_cast< int >(result));
28112 {
28113 if (temp2)
28114 delete arg2;
28115 }
28116 return resultobj;
28117 fail:
28118 {
28119 if (temp2)
28120 delete arg2;
28121 }
28122 return NULL;
28123 }
28124
28125
28126 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28127 PyObject *resultobj = 0;
28128 wxDateTime *arg1 = (wxDateTime *) 0 ;
28129 wxString *arg2 = 0 ;
28130 int result;
28131 void *argp1 = 0 ;
28132 int res1 = 0 ;
28133 bool temp2 = false ;
28134 PyObject * obj0 = 0 ;
28135 PyObject * obj1 = 0 ;
28136 char * kwnames[] = {
28137 (char *) "self",(char *) "time", NULL
28138 };
28139
28140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28142 if (!SWIG_IsOK(res1)) {
28143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28144 }
28145 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28146 {
28147 arg2 = wxString_in_helper(obj1);
28148 if (arg2 == NULL) SWIG_fail;
28149 temp2 = true;
28150 }
28151 {
28152 PyThreadState* __tstate = wxPyBeginAllowThreads();
28153 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28154 wxPyEndAllowThreads(__tstate);
28155 if (PyErr_Occurred()) SWIG_fail;
28156 }
28157 resultobj = SWIG_From_int(static_cast< int >(result));
28158 {
28159 if (temp2)
28160 delete arg2;
28161 }
28162 return resultobj;
28163 fail:
28164 {
28165 if (temp2)
28166 delete arg2;
28167 }
28168 return NULL;
28169 }
28170
28171
28172 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28173 PyObject *resultobj = 0;
28174 wxDateTime *arg1 = (wxDateTime *) 0 ;
28175 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28176 wxString *arg2 = (wxString *) &arg2_defvalue ;
28177 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28178 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28179 wxString result;
28180 void *argp1 = 0 ;
28181 int res1 = 0 ;
28182 bool temp2 = false ;
28183 bool temp3 = false ;
28184 PyObject * obj0 = 0 ;
28185 PyObject * obj1 = 0 ;
28186 PyObject * obj2 = 0 ;
28187 char * kwnames[] = {
28188 (char *) "self",(char *) "format",(char *) "tz", NULL
28189 };
28190
28191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28193 if (!SWIG_IsOK(res1)) {
28194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28195 }
28196 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28197 if (obj1) {
28198 {
28199 arg2 = wxString_in_helper(obj1);
28200 if (arg2 == NULL) SWIG_fail;
28201 temp2 = true;
28202 }
28203 }
28204 if (obj2) {
28205 {
28206 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28207 temp3 = true;
28208 }
28209 }
28210 {
28211 PyThreadState* __tstate = wxPyBeginAllowThreads();
28212 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28213 wxPyEndAllowThreads(__tstate);
28214 if (PyErr_Occurred()) SWIG_fail;
28215 }
28216 {
28217 #if wxUSE_UNICODE
28218 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28219 #else
28220 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28221 #endif
28222 }
28223 {
28224 if (temp2)
28225 delete arg2;
28226 }
28227 {
28228 if (temp3) delete arg3;
28229 }
28230 return resultobj;
28231 fail:
28232 {
28233 if (temp2)
28234 delete arg2;
28235 }
28236 {
28237 if (temp3) delete arg3;
28238 }
28239 return NULL;
28240 }
28241
28242
28243 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28244 PyObject *resultobj = 0;
28245 wxDateTime *arg1 = (wxDateTime *) 0 ;
28246 wxString result;
28247 void *argp1 = 0 ;
28248 int res1 = 0 ;
28249 PyObject *swig_obj[1] ;
28250
28251 if (!args) SWIG_fail;
28252 swig_obj[0] = args;
28253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28254 if (!SWIG_IsOK(res1)) {
28255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28256 }
28257 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28258 {
28259 PyThreadState* __tstate = wxPyBeginAllowThreads();
28260 result = ((wxDateTime const *)arg1)->FormatDate();
28261 wxPyEndAllowThreads(__tstate);
28262 if (PyErr_Occurred()) SWIG_fail;
28263 }
28264 {
28265 #if wxUSE_UNICODE
28266 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28267 #else
28268 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28269 #endif
28270 }
28271 return resultobj;
28272 fail:
28273 return NULL;
28274 }
28275
28276
28277 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28278 PyObject *resultobj = 0;
28279 wxDateTime *arg1 = (wxDateTime *) 0 ;
28280 wxString result;
28281 void *argp1 = 0 ;
28282 int res1 = 0 ;
28283 PyObject *swig_obj[1] ;
28284
28285 if (!args) SWIG_fail;
28286 swig_obj[0] = args;
28287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28288 if (!SWIG_IsOK(res1)) {
28289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28290 }
28291 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28292 {
28293 PyThreadState* __tstate = wxPyBeginAllowThreads();
28294 result = ((wxDateTime const *)arg1)->FormatTime();
28295 wxPyEndAllowThreads(__tstate);
28296 if (PyErr_Occurred()) SWIG_fail;
28297 }
28298 {
28299 #if wxUSE_UNICODE
28300 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28301 #else
28302 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28303 #endif
28304 }
28305 return resultobj;
28306 fail:
28307 return NULL;
28308 }
28309
28310
28311 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28312 PyObject *resultobj = 0;
28313 wxDateTime *arg1 = (wxDateTime *) 0 ;
28314 wxString result;
28315 void *argp1 = 0 ;
28316 int res1 = 0 ;
28317 PyObject *swig_obj[1] ;
28318
28319 if (!args) SWIG_fail;
28320 swig_obj[0] = args;
28321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28322 if (!SWIG_IsOK(res1)) {
28323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28324 }
28325 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28326 {
28327 PyThreadState* __tstate = wxPyBeginAllowThreads();
28328 result = ((wxDateTime const *)arg1)->FormatISODate();
28329 wxPyEndAllowThreads(__tstate);
28330 if (PyErr_Occurred()) SWIG_fail;
28331 }
28332 {
28333 #if wxUSE_UNICODE
28334 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28335 #else
28336 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28337 #endif
28338 }
28339 return resultobj;
28340 fail:
28341 return NULL;
28342 }
28343
28344
28345 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28346 PyObject *resultobj = 0;
28347 wxDateTime *arg1 = (wxDateTime *) 0 ;
28348 wxString result;
28349 void *argp1 = 0 ;
28350 int res1 = 0 ;
28351 PyObject *swig_obj[1] ;
28352
28353 if (!args) SWIG_fail;
28354 swig_obj[0] = args;
28355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28356 if (!SWIG_IsOK(res1)) {
28357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28358 }
28359 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28360 {
28361 PyThreadState* __tstate = wxPyBeginAllowThreads();
28362 result = ((wxDateTime const *)arg1)->FormatISOTime();
28363 wxPyEndAllowThreads(__tstate);
28364 if (PyErr_Occurred()) SWIG_fail;
28365 }
28366 {
28367 #if wxUSE_UNICODE
28368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28369 #else
28370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28371 #endif
28372 }
28373 return resultobj;
28374 fail:
28375 return NULL;
28376 }
28377
28378
28379 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28380 PyObject *obj;
28381 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28382 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28383 return SWIG_Py_Void();
28384 }
28385
28386 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28387 return SWIG_Python_InitShadowInstance(args);
28388 }
28389
28390 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28391 PyObject *resultobj = 0;
28392 long arg1 ;
28393 wxTimeSpan result;
28394 long val1 ;
28395 int ecode1 = 0 ;
28396 PyObject * obj0 = 0 ;
28397 char * kwnames[] = {
28398 (char *) "ms", NULL
28399 };
28400
28401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28402 ecode1 = SWIG_AsVal_long(obj0, &val1);
28403 if (!SWIG_IsOK(ecode1)) {
28404 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28405 }
28406 arg1 = static_cast< long >(val1);
28407 {
28408 PyThreadState* __tstate = wxPyBeginAllowThreads();
28409 result = wxTimeSpan::Milliseconds(arg1);
28410 wxPyEndAllowThreads(__tstate);
28411 if (PyErr_Occurred()) SWIG_fail;
28412 }
28413 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28414 return resultobj;
28415 fail:
28416 return NULL;
28417 }
28418
28419
28420 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28421 PyObject *resultobj = 0;
28422 wxTimeSpan result;
28423
28424 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28425 {
28426 PyThreadState* __tstate = wxPyBeginAllowThreads();
28427 result = wxTimeSpan::Millisecond();
28428 wxPyEndAllowThreads(__tstate);
28429 if (PyErr_Occurred()) SWIG_fail;
28430 }
28431 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28432 return resultobj;
28433 fail:
28434 return NULL;
28435 }
28436
28437
28438 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28439 PyObject *resultobj = 0;
28440 long arg1 ;
28441 wxTimeSpan result;
28442 long val1 ;
28443 int ecode1 = 0 ;
28444 PyObject * obj0 = 0 ;
28445 char * kwnames[] = {
28446 (char *) "sec", NULL
28447 };
28448
28449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28450 ecode1 = SWIG_AsVal_long(obj0, &val1);
28451 if (!SWIG_IsOK(ecode1)) {
28452 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28453 }
28454 arg1 = static_cast< long >(val1);
28455 {
28456 PyThreadState* __tstate = wxPyBeginAllowThreads();
28457 result = wxTimeSpan::Seconds(arg1);
28458 wxPyEndAllowThreads(__tstate);
28459 if (PyErr_Occurred()) SWIG_fail;
28460 }
28461 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28462 return resultobj;
28463 fail:
28464 return NULL;
28465 }
28466
28467
28468 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28469 PyObject *resultobj = 0;
28470 wxTimeSpan result;
28471
28472 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28473 {
28474 PyThreadState* __tstate = wxPyBeginAllowThreads();
28475 result = wxTimeSpan::Second();
28476 wxPyEndAllowThreads(__tstate);
28477 if (PyErr_Occurred()) SWIG_fail;
28478 }
28479 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28480 return resultobj;
28481 fail:
28482 return NULL;
28483 }
28484
28485
28486 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28487 PyObject *resultobj = 0;
28488 long arg1 ;
28489 wxTimeSpan result;
28490 long val1 ;
28491 int ecode1 = 0 ;
28492 PyObject * obj0 = 0 ;
28493 char * kwnames[] = {
28494 (char *) "min", NULL
28495 };
28496
28497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28498 ecode1 = SWIG_AsVal_long(obj0, &val1);
28499 if (!SWIG_IsOK(ecode1)) {
28500 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28501 }
28502 arg1 = static_cast< long >(val1);
28503 {
28504 PyThreadState* __tstate = wxPyBeginAllowThreads();
28505 result = wxTimeSpan::Minutes(arg1);
28506 wxPyEndAllowThreads(__tstate);
28507 if (PyErr_Occurred()) SWIG_fail;
28508 }
28509 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28510 return resultobj;
28511 fail:
28512 return NULL;
28513 }
28514
28515
28516 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28517 PyObject *resultobj = 0;
28518 wxTimeSpan result;
28519
28520 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28521 {
28522 PyThreadState* __tstate = wxPyBeginAllowThreads();
28523 result = wxTimeSpan::Minute();
28524 wxPyEndAllowThreads(__tstate);
28525 if (PyErr_Occurred()) SWIG_fail;
28526 }
28527 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28528 return resultobj;
28529 fail:
28530 return NULL;
28531 }
28532
28533
28534 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28535 PyObject *resultobj = 0;
28536 long arg1 ;
28537 wxTimeSpan result;
28538 long val1 ;
28539 int ecode1 = 0 ;
28540 PyObject * obj0 = 0 ;
28541 char * kwnames[] = {
28542 (char *) "hours", NULL
28543 };
28544
28545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28546 ecode1 = SWIG_AsVal_long(obj0, &val1);
28547 if (!SWIG_IsOK(ecode1)) {
28548 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28549 }
28550 arg1 = static_cast< long >(val1);
28551 {
28552 PyThreadState* __tstate = wxPyBeginAllowThreads();
28553 result = wxTimeSpan::Hours(arg1);
28554 wxPyEndAllowThreads(__tstate);
28555 if (PyErr_Occurred()) SWIG_fail;
28556 }
28557 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28558 return resultobj;
28559 fail:
28560 return NULL;
28561 }
28562
28563
28564 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28565 PyObject *resultobj = 0;
28566 wxTimeSpan result;
28567
28568 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28569 {
28570 PyThreadState* __tstate = wxPyBeginAllowThreads();
28571 result = wxTimeSpan::Hour();
28572 wxPyEndAllowThreads(__tstate);
28573 if (PyErr_Occurred()) SWIG_fail;
28574 }
28575 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28576 return resultobj;
28577 fail:
28578 return NULL;
28579 }
28580
28581
28582 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28583 PyObject *resultobj = 0;
28584 long arg1 ;
28585 wxTimeSpan result;
28586 long val1 ;
28587 int ecode1 = 0 ;
28588 PyObject * obj0 = 0 ;
28589 char * kwnames[] = {
28590 (char *) "days", NULL
28591 };
28592
28593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28594 ecode1 = SWIG_AsVal_long(obj0, &val1);
28595 if (!SWIG_IsOK(ecode1)) {
28596 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28597 }
28598 arg1 = static_cast< long >(val1);
28599 {
28600 PyThreadState* __tstate = wxPyBeginAllowThreads();
28601 result = wxTimeSpan::Days(arg1);
28602 wxPyEndAllowThreads(__tstate);
28603 if (PyErr_Occurred()) SWIG_fail;
28604 }
28605 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28606 return resultobj;
28607 fail:
28608 return NULL;
28609 }
28610
28611
28612 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28613 PyObject *resultobj = 0;
28614 wxTimeSpan result;
28615
28616 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28617 {
28618 PyThreadState* __tstate = wxPyBeginAllowThreads();
28619 result = wxTimeSpan::Day();
28620 wxPyEndAllowThreads(__tstate);
28621 if (PyErr_Occurred()) SWIG_fail;
28622 }
28623 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28624 return resultobj;
28625 fail:
28626 return NULL;
28627 }
28628
28629
28630 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28631 PyObject *resultobj = 0;
28632 long arg1 ;
28633 wxTimeSpan result;
28634 long val1 ;
28635 int ecode1 = 0 ;
28636 PyObject * obj0 = 0 ;
28637 char * kwnames[] = {
28638 (char *) "days", NULL
28639 };
28640
28641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28642 ecode1 = SWIG_AsVal_long(obj0, &val1);
28643 if (!SWIG_IsOK(ecode1)) {
28644 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28645 }
28646 arg1 = static_cast< long >(val1);
28647 {
28648 PyThreadState* __tstate = wxPyBeginAllowThreads();
28649 result = wxTimeSpan::Weeks(arg1);
28650 wxPyEndAllowThreads(__tstate);
28651 if (PyErr_Occurred()) SWIG_fail;
28652 }
28653 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28654 return resultobj;
28655 fail:
28656 return NULL;
28657 }
28658
28659
28660 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28661 PyObject *resultobj = 0;
28662 wxTimeSpan result;
28663
28664 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28665 {
28666 PyThreadState* __tstate = wxPyBeginAllowThreads();
28667 result = wxTimeSpan::Week();
28668 wxPyEndAllowThreads(__tstate);
28669 if (PyErr_Occurred()) SWIG_fail;
28670 }
28671 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28672 return resultobj;
28673 fail:
28674 return NULL;
28675 }
28676
28677
28678 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28679 PyObject *resultobj = 0;
28680 long arg1 = (long) 0 ;
28681 long arg2 = (long) 0 ;
28682 long arg3 = (long) 0 ;
28683 long arg4 = (long) 0 ;
28684 wxTimeSpan *result = 0 ;
28685 long val1 ;
28686 int ecode1 = 0 ;
28687 long val2 ;
28688 int ecode2 = 0 ;
28689 long val3 ;
28690 int ecode3 = 0 ;
28691 long val4 ;
28692 int ecode4 = 0 ;
28693 PyObject * obj0 = 0 ;
28694 PyObject * obj1 = 0 ;
28695 PyObject * obj2 = 0 ;
28696 PyObject * obj3 = 0 ;
28697 char * kwnames[] = {
28698 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28699 };
28700
28701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28702 if (obj0) {
28703 ecode1 = SWIG_AsVal_long(obj0, &val1);
28704 if (!SWIG_IsOK(ecode1)) {
28705 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28706 }
28707 arg1 = static_cast< long >(val1);
28708 }
28709 if (obj1) {
28710 ecode2 = SWIG_AsVal_long(obj1, &val2);
28711 if (!SWIG_IsOK(ecode2)) {
28712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28713 }
28714 arg2 = static_cast< long >(val2);
28715 }
28716 if (obj2) {
28717 ecode3 = SWIG_AsVal_long(obj2, &val3);
28718 if (!SWIG_IsOK(ecode3)) {
28719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28720 }
28721 arg3 = static_cast< long >(val3);
28722 }
28723 if (obj3) {
28724 ecode4 = SWIG_AsVal_long(obj3, &val4);
28725 if (!SWIG_IsOK(ecode4)) {
28726 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28727 }
28728 arg4 = static_cast< long >(val4);
28729 }
28730 {
28731 PyThreadState* __tstate = wxPyBeginAllowThreads();
28732 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
28733 wxPyEndAllowThreads(__tstate);
28734 if (PyErr_Occurred()) SWIG_fail;
28735 }
28736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
28737 return resultobj;
28738 fail:
28739 return NULL;
28740 }
28741
28742
28743 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28744 PyObject *resultobj = 0;
28745 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28746 void *argp1 = 0 ;
28747 int res1 = 0 ;
28748 PyObject *swig_obj[1] ;
28749
28750 if (!args) SWIG_fail;
28751 swig_obj[0] = args;
28752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28753 if (!SWIG_IsOK(res1)) {
28754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28755 }
28756 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28757 {
28758 PyThreadState* __tstate = wxPyBeginAllowThreads();
28759 delete arg1;
28760
28761 wxPyEndAllowThreads(__tstate);
28762 if (PyErr_Occurred()) SWIG_fail;
28763 }
28764 resultobj = SWIG_Py_Void();
28765 return resultobj;
28766 fail:
28767 return NULL;
28768 }
28769
28770
28771 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28772 PyObject *resultobj = 0;
28773 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28774 wxTimeSpan *arg2 = 0 ;
28775 wxTimeSpan *result = 0 ;
28776 void *argp1 = 0 ;
28777 int res1 = 0 ;
28778 void *argp2 = 0 ;
28779 int res2 = 0 ;
28780 PyObject * obj0 = 0 ;
28781 PyObject * obj1 = 0 ;
28782 char * kwnames[] = {
28783 (char *) "self",(char *) "diff", NULL
28784 };
28785
28786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
28787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28788 if (!SWIG_IsOK(res1)) {
28789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28790 }
28791 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28792 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28793 if (!SWIG_IsOK(res2)) {
28794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28795 }
28796 if (!argp2) {
28797 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28798 }
28799 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28800 {
28801 PyThreadState* __tstate = wxPyBeginAllowThreads();
28802 {
28803 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
28804 result = (wxTimeSpan *) &_result_ref;
28805 }
28806 wxPyEndAllowThreads(__tstate);
28807 if (PyErr_Occurred()) SWIG_fail;
28808 }
28809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28810 return resultobj;
28811 fail:
28812 return NULL;
28813 }
28814
28815
28816 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28817 PyObject *resultobj = 0;
28818 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28819 wxTimeSpan *arg2 = 0 ;
28820 wxTimeSpan *result = 0 ;
28821 void *argp1 = 0 ;
28822 int res1 = 0 ;
28823 void *argp2 = 0 ;
28824 int res2 = 0 ;
28825 PyObject * obj0 = 0 ;
28826 PyObject * obj1 = 0 ;
28827 char * kwnames[] = {
28828 (char *) "self",(char *) "diff", NULL
28829 };
28830
28831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
28832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28833 if (!SWIG_IsOK(res1)) {
28834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28835 }
28836 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28837 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28838 if (!SWIG_IsOK(res2)) {
28839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28840 }
28841 if (!argp2) {
28842 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28843 }
28844 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28845 {
28846 PyThreadState* __tstate = wxPyBeginAllowThreads();
28847 {
28848 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
28849 result = (wxTimeSpan *) &_result_ref;
28850 }
28851 wxPyEndAllowThreads(__tstate);
28852 if (PyErr_Occurred()) SWIG_fail;
28853 }
28854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28855 return resultobj;
28856 fail:
28857 return NULL;
28858 }
28859
28860
28861 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28862 PyObject *resultobj = 0;
28863 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28864 int arg2 ;
28865 wxTimeSpan *result = 0 ;
28866 void *argp1 = 0 ;
28867 int res1 = 0 ;
28868 int val2 ;
28869 int ecode2 = 0 ;
28870 PyObject * obj0 = 0 ;
28871 PyObject * obj1 = 0 ;
28872 char * kwnames[] = {
28873 (char *) "self",(char *) "n", NULL
28874 };
28875
28876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
28877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28878 if (!SWIG_IsOK(res1)) {
28879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28880 }
28881 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28882 ecode2 = SWIG_AsVal_int(obj1, &val2);
28883 if (!SWIG_IsOK(ecode2)) {
28884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
28885 }
28886 arg2 = static_cast< int >(val2);
28887 {
28888 PyThreadState* __tstate = wxPyBeginAllowThreads();
28889 {
28890 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
28891 result = (wxTimeSpan *) &_result_ref;
28892 }
28893 wxPyEndAllowThreads(__tstate);
28894 if (PyErr_Occurred()) SWIG_fail;
28895 }
28896 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28897 return resultobj;
28898 fail:
28899 return NULL;
28900 }
28901
28902
28903 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28904 PyObject *resultobj = 0;
28905 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28906 wxTimeSpan *result = 0 ;
28907 void *argp1 = 0 ;
28908 int res1 = 0 ;
28909 PyObject *swig_obj[1] ;
28910
28911 if (!args) SWIG_fail;
28912 swig_obj[0] = args;
28913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28914 if (!SWIG_IsOK(res1)) {
28915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28916 }
28917 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28918 {
28919 PyThreadState* __tstate = wxPyBeginAllowThreads();
28920 {
28921 wxTimeSpan &_result_ref = (arg1)->Neg();
28922 result = (wxTimeSpan *) &_result_ref;
28923 }
28924 wxPyEndAllowThreads(__tstate);
28925 if (PyErr_Occurred()) SWIG_fail;
28926 }
28927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28928 return resultobj;
28929 fail:
28930 return NULL;
28931 }
28932
28933
28934 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28935 PyObject *resultobj = 0;
28936 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28937 wxTimeSpan result;
28938 void *argp1 = 0 ;
28939 int res1 = 0 ;
28940 PyObject *swig_obj[1] ;
28941
28942 if (!args) SWIG_fail;
28943 swig_obj[0] = args;
28944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28945 if (!SWIG_IsOK(res1)) {
28946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28947 }
28948 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28949 {
28950 PyThreadState* __tstate = wxPyBeginAllowThreads();
28951 result = ((wxTimeSpan const *)arg1)->Abs();
28952 wxPyEndAllowThreads(__tstate);
28953 if (PyErr_Occurred()) SWIG_fail;
28954 }
28955 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28956 return resultobj;
28957 fail:
28958 return NULL;
28959 }
28960
28961
28962 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28963 PyObject *resultobj = 0;
28964 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28965 wxTimeSpan *arg2 = 0 ;
28966 wxTimeSpan *result = 0 ;
28967 void *argp1 = 0 ;
28968 int res1 = 0 ;
28969 void *argp2 = 0 ;
28970 int res2 = 0 ;
28971 PyObject * obj0 = 0 ;
28972 PyObject * obj1 = 0 ;
28973 char * kwnames[] = {
28974 (char *) "self",(char *) "diff", NULL
28975 };
28976
28977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
28978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28979 if (!SWIG_IsOK(res1)) {
28980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28981 }
28982 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28983 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28984 if (!SWIG_IsOK(res2)) {
28985 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28986 }
28987 if (!argp2) {
28988 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28989 }
28990 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28991 {
28992 PyThreadState* __tstate = wxPyBeginAllowThreads();
28993 {
28994 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
28995 result = (wxTimeSpan *) &_result_ref;
28996 }
28997 wxPyEndAllowThreads(__tstate);
28998 if (PyErr_Occurred()) SWIG_fail;
28999 }
29000 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29001 return resultobj;
29002 fail:
29003 return NULL;
29004 }
29005
29006
29007 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29008 PyObject *resultobj = 0;
29009 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29010 wxTimeSpan *arg2 = 0 ;
29011 wxTimeSpan *result = 0 ;
29012 void *argp1 = 0 ;
29013 int res1 = 0 ;
29014 void *argp2 = 0 ;
29015 int res2 = 0 ;
29016 PyObject * obj0 = 0 ;
29017 PyObject * obj1 = 0 ;
29018 char * kwnames[] = {
29019 (char *) "self",(char *) "diff", NULL
29020 };
29021
29022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29024 if (!SWIG_IsOK(res1)) {
29025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29026 }
29027 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29028 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29029 if (!SWIG_IsOK(res2)) {
29030 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29031 }
29032 if (!argp2) {
29033 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29034 }
29035 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29036 {
29037 PyThreadState* __tstate = wxPyBeginAllowThreads();
29038 {
29039 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29040 result = (wxTimeSpan *) &_result_ref;
29041 }
29042 wxPyEndAllowThreads(__tstate);
29043 if (PyErr_Occurred()) SWIG_fail;
29044 }
29045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29046 return resultobj;
29047 fail:
29048 return NULL;
29049 }
29050
29051
29052 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29053 PyObject *resultobj = 0;
29054 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29055 int arg2 ;
29056 wxTimeSpan *result = 0 ;
29057 void *argp1 = 0 ;
29058 int res1 = 0 ;
29059 int val2 ;
29060 int ecode2 = 0 ;
29061 PyObject * obj0 = 0 ;
29062 PyObject * obj1 = 0 ;
29063 char * kwnames[] = {
29064 (char *) "self",(char *) "n", NULL
29065 };
29066
29067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29069 if (!SWIG_IsOK(res1)) {
29070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29071 }
29072 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29073 ecode2 = SWIG_AsVal_int(obj1, &val2);
29074 if (!SWIG_IsOK(ecode2)) {
29075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29076 }
29077 arg2 = static_cast< int >(val2);
29078 {
29079 PyThreadState* __tstate = wxPyBeginAllowThreads();
29080 {
29081 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29082 result = (wxTimeSpan *) &_result_ref;
29083 }
29084 wxPyEndAllowThreads(__tstate);
29085 if (PyErr_Occurred()) SWIG_fail;
29086 }
29087 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29088 return resultobj;
29089 fail:
29090 return NULL;
29091 }
29092
29093
29094 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29095 PyObject *resultobj = 0;
29096 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29097 wxTimeSpan *result = 0 ;
29098 void *argp1 = 0 ;
29099 int res1 = 0 ;
29100 PyObject *swig_obj[1] ;
29101
29102 if (!args) SWIG_fail;
29103 swig_obj[0] = args;
29104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29105 if (!SWIG_IsOK(res1)) {
29106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29107 }
29108 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29109 {
29110 PyThreadState* __tstate = wxPyBeginAllowThreads();
29111 {
29112 wxTimeSpan &_result_ref = (arg1)->operator -();
29113 result = (wxTimeSpan *) &_result_ref;
29114 }
29115 wxPyEndAllowThreads(__tstate);
29116 if (PyErr_Occurred()) SWIG_fail;
29117 }
29118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29119 return resultobj;
29120 fail:
29121 return NULL;
29122 }
29123
29124
29125 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29126 PyObject *resultobj = 0;
29127 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29128 wxTimeSpan *arg2 = 0 ;
29129 wxTimeSpan result;
29130 void *argp1 = 0 ;
29131 int res1 = 0 ;
29132 void *argp2 = 0 ;
29133 int res2 = 0 ;
29134 PyObject * obj0 = 0 ;
29135 PyObject * obj1 = 0 ;
29136 char * kwnames[] = {
29137 (char *) "self",(char *) "other", NULL
29138 };
29139
29140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29142 if (!SWIG_IsOK(res1)) {
29143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29144 }
29145 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29146 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29147 if (!SWIG_IsOK(res2)) {
29148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29149 }
29150 if (!argp2) {
29151 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29152 }
29153 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29154 {
29155 PyThreadState* __tstate = wxPyBeginAllowThreads();
29156 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29157 wxPyEndAllowThreads(__tstate);
29158 if (PyErr_Occurred()) SWIG_fail;
29159 }
29160 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29161 return resultobj;
29162 fail:
29163 return NULL;
29164 }
29165
29166
29167 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29168 PyObject *resultobj = 0;
29169 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29170 wxTimeSpan *arg2 = 0 ;
29171 wxTimeSpan result;
29172 void *argp1 = 0 ;
29173 int res1 = 0 ;
29174 void *argp2 = 0 ;
29175 int res2 = 0 ;
29176 PyObject * obj0 = 0 ;
29177 PyObject * obj1 = 0 ;
29178 char * kwnames[] = {
29179 (char *) "self",(char *) "other", NULL
29180 };
29181
29182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29184 if (!SWIG_IsOK(res1)) {
29185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29186 }
29187 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29188 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29189 if (!SWIG_IsOK(res2)) {
29190 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29191 }
29192 if (!argp2) {
29193 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29194 }
29195 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29196 {
29197 PyThreadState* __tstate = wxPyBeginAllowThreads();
29198 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29199 wxPyEndAllowThreads(__tstate);
29200 if (PyErr_Occurred()) SWIG_fail;
29201 }
29202 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29203 return resultobj;
29204 fail:
29205 return NULL;
29206 }
29207
29208
29209 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29210 PyObject *resultobj = 0;
29211 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29212 int arg2 ;
29213 wxTimeSpan result;
29214 void *argp1 = 0 ;
29215 int res1 = 0 ;
29216 int val2 ;
29217 int ecode2 = 0 ;
29218 PyObject * obj0 = 0 ;
29219 PyObject * obj1 = 0 ;
29220 char * kwnames[] = {
29221 (char *) "self",(char *) "n", NULL
29222 };
29223
29224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29226 if (!SWIG_IsOK(res1)) {
29227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29228 }
29229 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29230 ecode2 = SWIG_AsVal_int(obj1, &val2);
29231 if (!SWIG_IsOK(ecode2)) {
29232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29233 }
29234 arg2 = static_cast< int >(val2);
29235 {
29236 PyThreadState* __tstate = wxPyBeginAllowThreads();
29237 result = wxTimeSpan___mul__(arg1,arg2);
29238 wxPyEndAllowThreads(__tstate);
29239 if (PyErr_Occurred()) SWIG_fail;
29240 }
29241 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29242 return resultobj;
29243 fail:
29244 return NULL;
29245 }
29246
29247
29248 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29249 PyObject *resultobj = 0;
29250 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29251 int arg2 ;
29252 wxTimeSpan result;
29253 void *argp1 = 0 ;
29254 int res1 = 0 ;
29255 int val2 ;
29256 int ecode2 = 0 ;
29257 PyObject * obj0 = 0 ;
29258 PyObject * obj1 = 0 ;
29259 char * kwnames[] = {
29260 (char *) "self",(char *) "n", NULL
29261 };
29262
29263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29265 if (!SWIG_IsOK(res1)) {
29266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29267 }
29268 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29269 ecode2 = SWIG_AsVal_int(obj1, &val2);
29270 if (!SWIG_IsOK(ecode2)) {
29271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29272 }
29273 arg2 = static_cast< int >(val2);
29274 {
29275 PyThreadState* __tstate = wxPyBeginAllowThreads();
29276 result = wxTimeSpan___rmul__(arg1,arg2);
29277 wxPyEndAllowThreads(__tstate);
29278 if (PyErr_Occurred()) SWIG_fail;
29279 }
29280 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29281 return resultobj;
29282 fail:
29283 return NULL;
29284 }
29285
29286
29287 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29288 PyObject *resultobj = 0;
29289 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29290 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29291 bool result;
29292 void *argp1 = 0 ;
29293 int res1 = 0 ;
29294 void *argp2 = 0 ;
29295 int res2 = 0 ;
29296 PyObject * obj0 = 0 ;
29297 PyObject * obj1 = 0 ;
29298 char * kwnames[] = {
29299 (char *) "self",(char *) "other", NULL
29300 };
29301
29302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29304 if (!SWIG_IsOK(res1)) {
29305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29306 }
29307 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29308 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29309 if (!SWIG_IsOK(res2)) {
29310 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29311 }
29312 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29313 {
29314 PyThreadState* __tstate = wxPyBeginAllowThreads();
29315 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29316 wxPyEndAllowThreads(__tstate);
29317 if (PyErr_Occurred()) SWIG_fail;
29318 }
29319 {
29320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29321 }
29322 return resultobj;
29323 fail:
29324 return NULL;
29325 }
29326
29327
29328 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29329 PyObject *resultobj = 0;
29330 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29331 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29332 bool result;
29333 void *argp1 = 0 ;
29334 int res1 = 0 ;
29335 void *argp2 = 0 ;
29336 int res2 = 0 ;
29337 PyObject * obj0 = 0 ;
29338 PyObject * obj1 = 0 ;
29339 char * kwnames[] = {
29340 (char *) "self",(char *) "other", NULL
29341 };
29342
29343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29345 if (!SWIG_IsOK(res1)) {
29346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29347 }
29348 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29349 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29350 if (!SWIG_IsOK(res2)) {
29351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29352 }
29353 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29354 {
29355 PyThreadState* __tstate = wxPyBeginAllowThreads();
29356 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29357 wxPyEndAllowThreads(__tstate);
29358 if (PyErr_Occurred()) SWIG_fail;
29359 }
29360 {
29361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29362 }
29363 return resultobj;
29364 fail:
29365 return NULL;
29366 }
29367
29368
29369 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29370 PyObject *resultobj = 0;
29371 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29372 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29373 bool result;
29374 void *argp1 = 0 ;
29375 int res1 = 0 ;
29376 void *argp2 = 0 ;
29377 int res2 = 0 ;
29378 PyObject * obj0 = 0 ;
29379 PyObject * obj1 = 0 ;
29380 char * kwnames[] = {
29381 (char *) "self",(char *) "other", NULL
29382 };
29383
29384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29386 if (!SWIG_IsOK(res1)) {
29387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29388 }
29389 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29390 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29391 if (!SWIG_IsOK(res2)) {
29392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29393 }
29394 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29395 {
29396 PyThreadState* __tstate = wxPyBeginAllowThreads();
29397 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29398 wxPyEndAllowThreads(__tstate);
29399 if (PyErr_Occurred()) SWIG_fail;
29400 }
29401 {
29402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29403 }
29404 return resultobj;
29405 fail:
29406 return NULL;
29407 }
29408
29409
29410 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29411 PyObject *resultobj = 0;
29412 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29413 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29414 bool result;
29415 void *argp1 = 0 ;
29416 int res1 = 0 ;
29417 void *argp2 = 0 ;
29418 int res2 = 0 ;
29419 PyObject * obj0 = 0 ;
29420 PyObject * obj1 = 0 ;
29421 char * kwnames[] = {
29422 (char *) "self",(char *) "other", NULL
29423 };
29424
29425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29427 if (!SWIG_IsOK(res1)) {
29428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29429 }
29430 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29431 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29432 if (!SWIG_IsOK(res2)) {
29433 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29434 }
29435 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29436 {
29437 PyThreadState* __tstate = wxPyBeginAllowThreads();
29438 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29439 wxPyEndAllowThreads(__tstate);
29440 if (PyErr_Occurred()) SWIG_fail;
29441 }
29442 {
29443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29444 }
29445 return resultobj;
29446 fail:
29447 return NULL;
29448 }
29449
29450
29451 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29452 PyObject *resultobj = 0;
29453 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29454 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29455 bool result;
29456 void *argp1 = 0 ;
29457 int res1 = 0 ;
29458 void *argp2 = 0 ;
29459 int res2 = 0 ;
29460 PyObject * obj0 = 0 ;
29461 PyObject * obj1 = 0 ;
29462 char * kwnames[] = {
29463 (char *) "self",(char *) "other", NULL
29464 };
29465
29466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29468 if (!SWIG_IsOK(res1)) {
29469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29470 }
29471 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29472 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29473 if (!SWIG_IsOK(res2)) {
29474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29475 }
29476 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29477 {
29478 PyThreadState* __tstate = wxPyBeginAllowThreads();
29479 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29480 wxPyEndAllowThreads(__tstate);
29481 if (PyErr_Occurred()) SWIG_fail;
29482 }
29483 {
29484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29485 }
29486 return resultobj;
29487 fail:
29488 return NULL;
29489 }
29490
29491
29492 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29493 PyObject *resultobj = 0;
29494 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29495 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29496 bool result;
29497 void *argp1 = 0 ;
29498 int res1 = 0 ;
29499 void *argp2 = 0 ;
29500 int res2 = 0 ;
29501 PyObject * obj0 = 0 ;
29502 PyObject * obj1 = 0 ;
29503 char * kwnames[] = {
29504 (char *) "self",(char *) "other", NULL
29505 };
29506
29507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29509 if (!SWIG_IsOK(res1)) {
29510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29511 }
29512 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29513 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29514 if (!SWIG_IsOK(res2)) {
29515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29516 }
29517 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29518 {
29519 PyThreadState* __tstate = wxPyBeginAllowThreads();
29520 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29521 wxPyEndAllowThreads(__tstate);
29522 if (PyErr_Occurred()) SWIG_fail;
29523 }
29524 {
29525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29526 }
29527 return resultobj;
29528 fail:
29529 return NULL;
29530 }
29531
29532
29533 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29534 PyObject *resultobj = 0;
29535 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29536 bool result;
29537 void *argp1 = 0 ;
29538 int res1 = 0 ;
29539 PyObject *swig_obj[1] ;
29540
29541 if (!args) SWIG_fail;
29542 swig_obj[0] = args;
29543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29544 if (!SWIG_IsOK(res1)) {
29545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29546 }
29547 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29548 {
29549 PyThreadState* __tstate = wxPyBeginAllowThreads();
29550 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29551 wxPyEndAllowThreads(__tstate);
29552 if (PyErr_Occurred()) SWIG_fail;
29553 }
29554 {
29555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29556 }
29557 return resultobj;
29558 fail:
29559 return NULL;
29560 }
29561
29562
29563 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29564 PyObject *resultobj = 0;
29565 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29566 bool result;
29567 void *argp1 = 0 ;
29568 int res1 = 0 ;
29569 PyObject *swig_obj[1] ;
29570
29571 if (!args) SWIG_fail;
29572 swig_obj[0] = args;
29573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29574 if (!SWIG_IsOK(res1)) {
29575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29576 }
29577 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29578 {
29579 PyThreadState* __tstate = wxPyBeginAllowThreads();
29580 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29581 wxPyEndAllowThreads(__tstate);
29582 if (PyErr_Occurred()) SWIG_fail;
29583 }
29584 {
29585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29586 }
29587 return resultobj;
29588 fail:
29589 return NULL;
29590 }
29591
29592
29593 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29594 PyObject *resultobj = 0;
29595 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29596 bool result;
29597 void *argp1 = 0 ;
29598 int res1 = 0 ;
29599 PyObject *swig_obj[1] ;
29600
29601 if (!args) SWIG_fail;
29602 swig_obj[0] = args;
29603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29604 if (!SWIG_IsOK(res1)) {
29605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29606 }
29607 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29608 {
29609 PyThreadState* __tstate = wxPyBeginAllowThreads();
29610 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29611 wxPyEndAllowThreads(__tstate);
29612 if (PyErr_Occurred()) SWIG_fail;
29613 }
29614 {
29615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29616 }
29617 return resultobj;
29618 fail:
29619 return NULL;
29620 }
29621
29622
29623 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29624 PyObject *resultobj = 0;
29625 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29626 wxTimeSpan *arg2 = 0 ;
29627 bool result;
29628 void *argp1 = 0 ;
29629 int res1 = 0 ;
29630 void *argp2 = 0 ;
29631 int res2 = 0 ;
29632 PyObject * obj0 = 0 ;
29633 PyObject * obj1 = 0 ;
29634 char * kwnames[] = {
29635 (char *) "self",(char *) "ts", NULL
29636 };
29637
29638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29640 if (!SWIG_IsOK(res1)) {
29641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29642 }
29643 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29644 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29645 if (!SWIG_IsOK(res2)) {
29646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29647 }
29648 if (!argp2) {
29649 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29650 }
29651 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29652 {
29653 PyThreadState* __tstate = wxPyBeginAllowThreads();
29654 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29655 wxPyEndAllowThreads(__tstate);
29656 if (PyErr_Occurred()) SWIG_fail;
29657 }
29658 {
29659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29660 }
29661 return resultobj;
29662 fail:
29663 return NULL;
29664 }
29665
29666
29667 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29668 PyObject *resultobj = 0;
29669 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29670 wxTimeSpan *arg2 = 0 ;
29671 bool result;
29672 void *argp1 = 0 ;
29673 int res1 = 0 ;
29674 void *argp2 = 0 ;
29675 int res2 = 0 ;
29676 PyObject * obj0 = 0 ;
29677 PyObject * obj1 = 0 ;
29678 char * kwnames[] = {
29679 (char *) "self",(char *) "ts", NULL
29680 };
29681
29682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29684 if (!SWIG_IsOK(res1)) {
29685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29686 }
29687 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29688 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29689 if (!SWIG_IsOK(res2)) {
29690 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29691 }
29692 if (!argp2) {
29693 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29694 }
29695 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29696 {
29697 PyThreadState* __tstate = wxPyBeginAllowThreads();
29698 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29699 wxPyEndAllowThreads(__tstate);
29700 if (PyErr_Occurred()) SWIG_fail;
29701 }
29702 {
29703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29704 }
29705 return resultobj;
29706 fail:
29707 return NULL;
29708 }
29709
29710
29711 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29712 PyObject *resultobj = 0;
29713 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29714 wxTimeSpan *arg2 = 0 ;
29715 bool result;
29716 void *argp1 = 0 ;
29717 int res1 = 0 ;
29718 void *argp2 = 0 ;
29719 int res2 = 0 ;
29720 PyObject * obj0 = 0 ;
29721 PyObject * obj1 = 0 ;
29722 char * kwnames[] = {
29723 (char *) "self",(char *) "t", NULL
29724 };
29725
29726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29728 if (!SWIG_IsOK(res1)) {
29729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29730 }
29731 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29732 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29733 if (!SWIG_IsOK(res2)) {
29734 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29735 }
29736 if (!argp2) {
29737 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29738 }
29739 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29740 {
29741 PyThreadState* __tstate = wxPyBeginAllowThreads();
29742 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
29743 wxPyEndAllowThreads(__tstate);
29744 if (PyErr_Occurred()) SWIG_fail;
29745 }
29746 {
29747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29748 }
29749 return resultobj;
29750 fail:
29751 return NULL;
29752 }
29753
29754
29755 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29756 PyObject *resultobj = 0;
29757 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29758 int result;
29759 void *argp1 = 0 ;
29760 int res1 = 0 ;
29761 PyObject *swig_obj[1] ;
29762
29763 if (!args) SWIG_fail;
29764 swig_obj[0] = args;
29765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29766 if (!SWIG_IsOK(res1)) {
29767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29768 }
29769 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29770 {
29771 PyThreadState* __tstate = wxPyBeginAllowThreads();
29772 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
29773 wxPyEndAllowThreads(__tstate);
29774 if (PyErr_Occurred()) SWIG_fail;
29775 }
29776 resultobj = SWIG_From_int(static_cast< int >(result));
29777 return resultobj;
29778 fail:
29779 return NULL;
29780 }
29781
29782
29783 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29784 PyObject *resultobj = 0;
29785 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29786 int result;
29787 void *argp1 = 0 ;
29788 int res1 = 0 ;
29789 PyObject *swig_obj[1] ;
29790
29791 if (!args) SWIG_fail;
29792 swig_obj[0] = args;
29793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29794 if (!SWIG_IsOK(res1)) {
29795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29796 }
29797 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29798 {
29799 PyThreadState* __tstate = wxPyBeginAllowThreads();
29800 result = (int)((wxTimeSpan const *)arg1)->GetDays();
29801 wxPyEndAllowThreads(__tstate);
29802 if (PyErr_Occurred()) SWIG_fail;
29803 }
29804 resultobj = SWIG_From_int(static_cast< int >(result));
29805 return resultobj;
29806 fail:
29807 return NULL;
29808 }
29809
29810
29811 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29812 PyObject *resultobj = 0;
29813 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29814 int result;
29815 void *argp1 = 0 ;
29816 int res1 = 0 ;
29817 PyObject *swig_obj[1] ;
29818
29819 if (!args) SWIG_fail;
29820 swig_obj[0] = args;
29821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29822 if (!SWIG_IsOK(res1)) {
29823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29824 }
29825 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29826 {
29827 PyThreadState* __tstate = wxPyBeginAllowThreads();
29828 result = (int)((wxTimeSpan const *)arg1)->GetHours();
29829 wxPyEndAllowThreads(__tstate);
29830 if (PyErr_Occurred()) SWIG_fail;
29831 }
29832 resultobj = SWIG_From_int(static_cast< int >(result));
29833 return resultobj;
29834 fail:
29835 return NULL;
29836 }
29837
29838
29839 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29840 PyObject *resultobj = 0;
29841 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29842 int result;
29843 void *argp1 = 0 ;
29844 int res1 = 0 ;
29845 PyObject *swig_obj[1] ;
29846
29847 if (!args) SWIG_fail;
29848 swig_obj[0] = args;
29849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29850 if (!SWIG_IsOK(res1)) {
29851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29852 }
29853 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29854 {
29855 PyThreadState* __tstate = wxPyBeginAllowThreads();
29856 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
29857 wxPyEndAllowThreads(__tstate);
29858 if (PyErr_Occurred()) SWIG_fail;
29859 }
29860 resultobj = SWIG_From_int(static_cast< int >(result));
29861 return resultobj;
29862 fail:
29863 return NULL;
29864 }
29865
29866
29867 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29868 PyObject *resultobj = 0;
29869 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29870 wxLongLong result;
29871 void *argp1 = 0 ;
29872 int res1 = 0 ;
29873 PyObject *swig_obj[1] ;
29874
29875 if (!args) SWIG_fail;
29876 swig_obj[0] = args;
29877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29878 if (!SWIG_IsOK(res1)) {
29879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29880 }
29881 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29882 {
29883 PyThreadState* __tstate = wxPyBeginAllowThreads();
29884 result = ((wxTimeSpan const *)arg1)->GetSeconds();
29885 wxPyEndAllowThreads(__tstate);
29886 if (PyErr_Occurred()) SWIG_fail;
29887 }
29888 {
29889 PyObject *hi, *lo, *shifter, *shifted;
29890 hi = PyLong_FromLong( (&result)->GetHi() );
29891 lo = PyLong_FromLong( (&result)->GetLo() );
29892 shifter = PyLong_FromLong(32);
29893 shifted = PyNumber_Lshift(hi, shifter);
29894 resultobj = PyNumber_Or(shifted, lo);
29895 Py_DECREF(hi);
29896 Py_DECREF(lo);
29897 Py_DECREF(shifter);
29898 Py_DECREF(shifted);
29899 }
29900 return resultobj;
29901 fail:
29902 return NULL;
29903 }
29904
29905
29906 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29907 PyObject *resultobj = 0;
29908 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29909 wxLongLong result;
29910 void *argp1 = 0 ;
29911 int res1 = 0 ;
29912 PyObject *swig_obj[1] ;
29913
29914 if (!args) SWIG_fail;
29915 swig_obj[0] = args;
29916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29917 if (!SWIG_IsOK(res1)) {
29918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29919 }
29920 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29921 {
29922 PyThreadState* __tstate = wxPyBeginAllowThreads();
29923 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
29924 wxPyEndAllowThreads(__tstate);
29925 if (PyErr_Occurred()) SWIG_fail;
29926 }
29927 {
29928 PyObject *hi, *lo, *shifter, *shifted;
29929 hi = PyLong_FromLong( (&result)->GetHi() );
29930 lo = PyLong_FromLong( (&result)->GetLo() );
29931 shifter = PyLong_FromLong(32);
29932 shifted = PyNumber_Lshift(hi, shifter);
29933 resultobj = PyNumber_Or(shifted, lo);
29934 Py_DECREF(hi);
29935 Py_DECREF(lo);
29936 Py_DECREF(shifter);
29937 Py_DECREF(shifted);
29938 }
29939 return resultobj;
29940 fail:
29941 return NULL;
29942 }
29943
29944
29945 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29946 PyObject *resultobj = 0;
29947 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29948 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
29949 wxString *arg2 = (wxString *) &arg2_defvalue ;
29950 wxString result;
29951 void *argp1 = 0 ;
29952 int res1 = 0 ;
29953 bool temp2 = false ;
29954 PyObject * obj0 = 0 ;
29955 PyObject * obj1 = 0 ;
29956 char * kwnames[] = {
29957 (char *) "self",(char *) "format", NULL
29958 };
29959
29960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
29961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29962 if (!SWIG_IsOK(res1)) {
29963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29964 }
29965 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29966 if (obj1) {
29967 {
29968 arg2 = wxString_in_helper(obj1);
29969 if (arg2 == NULL) SWIG_fail;
29970 temp2 = true;
29971 }
29972 }
29973 {
29974 PyThreadState* __tstate = wxPyBeginAllowThreads();
29975 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
29976 wxPyEndAllowThreads(__tstate);
29977 if (PyErr_Occurred()) SWIG_fail;
29978 }
29979 {
29980 #if wxUSE_UNICODE
29981 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29982 #else
29983 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29984 #endif
29985 }
29986 {
29987 if (temp2)
29988 delete arg2;
29989 }
29990 return resultobj;
29991 fail:
29992 {
29993 if (temp2)
29994 delete arg2;
29995 }
29996 return NULL;
29997 }
29998
29999
30000 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30001 PyObject *obj;
30002 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30003 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30004 return SWIG_Py_Void();
30005 }
30006
30007 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30008 return SWIG_Python_InitShadowInstance(args);
30009 }
30010
30011 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30012 PyObject *resultobj = 0;
30013 int arg1 = (int) 0 ;
30014 int arg2 = (int) 0 ;
30015 int arg3 = (int) 0 ;
30016 int arg4 = (int) 0 ;
30017 wxDateSpan *result = 0 ;
30018 int val1 ;
30019 int ecode1 = 0 ;
30020 int val2 ;
30021 int ecode2 = 0 ;
30022 int val3 ;
30023 int ecode3 = 0 ;
30024 int val4 ;
30025 int ecode4 = 0 ;
30026 PyObject * obj0 = 0 ;
30027 PyObject * obj1 = 0 ;
30028 PyObject * obj2 = 0 ;
30029 PyObject * obj3 = 0 ;
30030 char * kwnames[] = {
30031 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30032 };
30033
30034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30035 if (obj0) {
30036 ecode1 = SWIG_AsVal_int(obj0, &val1);
30037 if (!SWIG_IsOK(ecode1)) {
30038 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30039 }
30040 arg1 = static_cast< int >(val1);
30041 }
30042 if (obj1) {
30043 ecode2 = SWIG_AsVal_int(obj1, &val2);
30044 if (!SWIG_IsOK(ecode2)) {
30045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30046 }
30047 arg2 = static_cast< int >(val2);
30048 }
30049 if (obj2) {
30050 ecode3 = SWIG_AsVal_int(obj2, &val3);
30051 if (!SWIG_IsOK(ecode3)) {
30052 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30053 }
30054 arg3 = static_cast< int >(val3);
30055 }
30056 if (obj3) {
30057 ecode4 = SWIG_AsVal_int(obj3, &val4);
30058 if (!SWIG_IsOK(ecode4)) {
30059 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30060 }
30061 arg4 = static_cast< int >(val4);
30062 }
30063 {
30064 PyThreadState* __tstate = wxPyBeginAllowThreads();
30065 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30066 wxPyEndAllowThreads(__tstate);
30067 if (PyErr_Occurred()) SWIG_fail;
30068 }
30069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30070 return resultobj;
30071 fail:
30072 return NULL;
30073 }
30074
30075
30076 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30077 PyObject *resultobj = 0;
30078 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30079 void *argp1 = 0 ;
30080 int res1 = 0 ;
30081 PyObject *swig_obj[1] ;
30082
30083 if (!args) SWIG_fail;
30084 swig_obj[0] = args;
30085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30086 if (!SWIG_IsOK(res1)) {
30087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30088 }
30089 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30090 {
30091 PyThreadState* __tstate = wxPyBeginAllowThreads();
30092 delete arg1;
30093
30094 wxPyEndAllowThreads(__tstate);
30095 if (PyErr_Occurred()) SWIG_fail;
30096 }
30097 resultobj = SWIG_Py_Void();
30098 return resultobj;
30099 fail:
30100 return NULL;
30101 }
30102
30103
30104 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30105 PyObject *resultobj = 0;
30106 int arg1 ;
30107 wxDateSpan result;
30108 int val1 ;
30109 int ecode1 = 0 ;
30110 PyObject * obj0 = 0 ;
30111 char * kwnames[] = {
30112 (char *) "days", NULL
30113 };
30114
30115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30116 ecode1 = SWIG_AsVal_int(obj0, &val1);
30117 if (!SWIG_IsOK(ecode1)) {
30118 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30119 }
30120 arg1 = static_cast< int >(val1);
30121 {
30122 PyThreadState* __tstate = wxPyBeginAllowThreads();
30123 result = wxDateSpan::Days(arg1);
30124 wxPyEndAllowThreads(__tstate);
30125 if (PyErr_Occurred()) SWIG_fail;
30126 }
30127 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30128 return resultobj;
30129 fail:
30130 return NULL;
30131 }
30132
30133
30134 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30135 PyObject *resultobj = 0;
30136 wxDateSpan result;
30137
30138 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30139 {
30140 PyThreadState* __tstate = wxPyBeginAllowThreads();
30141 result = wxDateSpan::Day();
30142 wxPyEndAllowThreads(__tstate);
30143 if (PyErr_Occurred()) SWIG_fail;
30144 }
30145 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30146 return resultobj;
30147 fail:
30148 return NULL;
30149 }
30150
30151
30152 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30153 PyObject *resultobj = 0;
30154 int arg1 ;
30155 wxDateSpan result;
30156 int val1 ;
30157 int ecode1 = 0 ;
30158 PyObject * obj0 = 0 ;
30159 char * kwnames[] = {
30160 (char *) "weeks", NULL
30161 };
30162
30163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30164 ecode1 = SWIG_AsVal_int(obj0, &val1);
30165 if (!SWIG_IsOK(ecode1)) {
30166 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30167 }
30168 arg1 = static_cast< int >(val1);
30169 {
30170 PyThreadState* __tstate = wxPyBeginAllowThreads();
30171 result = wxDateSpan::Weeks(arg1);
30172 wxPyEndAllowThreads(__tstate);
30173 if (PyErr_Occurred()) SWIG_fail;
30174 }
30175 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30176 return resultobj;
30177 fail:
30178 return NULL;
30179 }
30180
30181
30182 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30183 PyObject *resultobj = 0;
30184 wxDateSpan result;
30185
30186 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30187 {
30188 PyThreadState* __tstate = wxPyBeginAllowThreads();
30189 result = wxDateSpan::Week();
30190 wxPyEndAllowThreads(__tstate);
30191 if (PyErr_Occurred()) SWIG_fail;
30192 }
30193 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30194 return resultobj;
30195 fail:
30196 return NULL;
30197 }
30198
30199
30200 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30201 PyObject *resultobj = 0;
30202 int arg1 ;
30203 wxDateSpan result;
30204 int val1 ;
30205 int ecode1 = 0 ;
30206 PyObject * obj0 = 0 ;
30207 char * kwnames[] = {
30208 (char *) "mon", NULL
30209 };
30210
30211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30212 ecode1 = SWIG_AsVal_int(obj0, &val1);
30213 if (!SWIG_IsOK(ecode1)) {
30214 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30215 }
30216 arg1 = static_cast< int >(val1);
30217 {
30218 PyThreadState* __tstate = wxPyBeginAllowThreads();
30219 result = wxDateSpan::Months(arg1);
30220 wxPyEndAllowThreads(__tstate);
30221 if (PyErr_Occurred()) SWIG_fail;
30222 }
30223 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30224 return resultobj;
30225 fail:
30226 return NULL;
30227 }
30228
30229
30230 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30231 PyObject *resultobj = 0;
30232 wxDateSpan result;
30233
30234 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30235 {
30236 PyThreadState* __tstate = wxPyBeginAllowThreads();
30237 result = wxDateSpan::Month();
30238 wxPyEndAllowThreads(__tstate);
30239 if (PyErr_Occurred()) SWIG_fail;
30240 }
30241 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30242 return resultobj;
30243 fail:
30244 return NULL;
30245 }
30246
30247
30248 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30249 PyObject *resultobj = 0;
30250 int arg1 ;
30251 wxDateSpan result;
30252 int val1 ;
30253 int ecode1 = 0 ;
30254 PyObject * obj0 = 0 ;
30255 char * kwnames[] = {
30256 (char *) "years", NULL
30257 };
30258
30259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30260 ecode1 = SWIG_AsVal_int(obj0, &val1);
30261 if (!SWIG_IsOK(ecode1)) {
30262 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30263 }
30264 arg1 = static_cast< int >(val1);
30265 {
30266 PyThreadState* __tstate = wxPyBeginAllowThreads();
30267 result = wxDateSpan::Years(arg1);
30268 wxPyEndAllowThreads(__tstate);
30269 if (PyErr_Occurred()) SWIG_fail;
30270 }
30271 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30272 return resultobj;
30273 fail:
30274 return NULL;
30275 }
30276
30277
30278 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30279 PyObject *resultobj = 0;
30280 wxDateSpan result;
30281
30282 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30283 {
30284 PyThreadState* __tstate = wxPyBeginAllowThreads();
30285 result = wxDateSpan::Year();
30286 wxPyEndAllowThreads(__tstate);
30287 if (PyErr_Occurred()) SWIG_fail;
30288 }
30289 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30290 return resultobj;
30291 fail:
30292 return NULL;
30293 }
30294
30295
30296 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30297 PyObject *resultobj = 0;
30298 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30299 int arg2 ;
30300 wxDateSpan *result = 0 ;
30301 void *argp1 = 0 ;
30302 int res1 = 0 ;
30303 int val2 ;
30304 int ecode2 = 0 ;
30305 PyObject * obj0 = 0 ;
30306 PyObject * obj1 = 0 ;
30307 char * kwnames[] = {
30308 (char *) "self",(char *) "n", NULL
30309 };
30310
30311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30313 if (!SWIG_IsOK(res1)) {
30314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30315 }
30316 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30317 ecode2 = SWIG_AsVal_int(obj1, &val2);
30318 if (!SWIG_IsOK(ecode2)) {
30319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30320 }
30321 arg2 = static_cast< int >(val2);
30322 {
30323 PyThreadState* __tstate = wxPyBeginAllowThreads();
30324 {
30325 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30326 result = (wxDateSpan *) &_result_ref;
30327 }
30328 wxPyEndAllowThreads(__tstate);
30329 if (PyErr_Occurred()) SWIG_fail;
30330 }
30331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30332 return resultobj;
30333 fail:
30334 return NULL;
30335 }
30336
30337
30338 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30339 PyObject *resultobj = 0;
30340 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30341 int arg2 ;
30342 wxDateSpan *result = 0 ;
30343 void *argp1 = 0 ;
30344 int res1 = 0 ;
30345 int val2 ;
30346 int ecode2 = 0 ;
30347 PyObject * obj0 = 0 ;
30348 PyObject * obj1 = 0 ;
30349 char * kwnames[] = {
30350 (char *) "self",(char *) "n", NULL
30351 };
30352
30353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30355 if (!SWIG_IsOK(res1)) {
30356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30357 }
30358 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30359 ecode2 = SWIG_AsVal_int(obj1, &val2);
30360 if (!SWIG_IsOK(ecode2)) {
30361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30362 }
30363 arg2 = static_cast< int >(val2);
30364 {
30365 PyThreadState* __tstate = wxPyBeginAllowThreads();
30366 {
30367 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30368 result = (wxDateSpan *) &_result_ref;
30369 }
30370 wxPyEndAllowThreads(__tstate);
30371 if (PyErr_Occurred()) SWIG_fail;
30372 }
30373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30374 return resultobj;
30375 fail:
30376 return NULL;
30377 }
30378
30379
30380 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30381 PyObject *resultobj = 0;
30382 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30383 int arg2 ;
30384 wxDateSpan *result = 0 ;
30385 void *argp1 = 0 ;
30386 int res1 = 0 ;
30387 int val2 ;
30388 int ecode2 = 0 ;
30389 PyObject * obj0 = 0 ;
30390 PyObject * obj1 = 0 ;
30391 char * kwnames[] = {
30392 (char *) "self",(char *) "n", NULL
30393 };
30394
30395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30397 if (!SWIG_IsOK(res1)) {
30398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30399 }
30400 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30401 ecode2 = SWIG_AsVal_int(obj1, &val2);
30402 if (!SWIG_IsOK(ecode2)) {
30403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30404 }
30405 arg2 = static_cast< int >(val2);
30406 {
30407 PyThreadState* __tstate = wxPyBeginAllowThreads();
30408 {
30409 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30410 result = (wxDateSpan *) &_result_ref;
30411 }
30412 wxPyEndAllowThreads(__tstate);
30413 if (PyErr_Occurred()) SWIG_fail;
30414 }
30415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30416 return resultobj;
30417 fail:
30418 return NULL;
30419 }
30420
30421
30422 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30423 PyObject *resultobj = 0;
30424 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30425 int arg2 ;
30426 wxDateSpan *result = 0 ;
30427 void *argp1 = 0 ;
30428 int res1 = 0 ;
30429 int val2 ;
30430 int ecode2 = 0 ;
30431 PyObject * obj0 = 0 ;
30432 PyObject * obj1 = 0 ;
30433 char * kwnames[] = {
30434 (char *) "self",(char *) "n", NULL
30435 };
30436
30437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30439 if (!SWIG_IsOK(res1)) {
30440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30441 }
30442 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30443 ecode2 = SWIG_AsVal_int(obj1, &val2);
30444 if (!SWIG_IsOK(ecode2)) {
30445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30446 }
30447 arg2 = static_cast< int >(val2);
30448 {
30449 PyThreadState* __tstate = wxPyBeginAllowThreads();
30450 {
30451 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30452 result = (wxDateSpan *) &_result_ref;
30453 }
30454 wxPyEndAllowThreads(__tstate);
30455 if (PyErr_Occurred()) SWIG_fail;
30456 }
30457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30458 return resultobj;
30459 fail:
30460 return NULL;
30461 }
30462
30463
30464 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30465 PyObject *resultobj = 0;
30466 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30467 int result;
30468 void *argp1 = 0 ;
30469 int res1 = 0 ;
30470 PyObject *swig_obj[1] ;
30471
30472 if (!args) SWIG_fail;
30473 swig_obj[0] = args;
30474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30475 if (!SWIG_IsOK(res1)) {
30476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30477 }
30478 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30479 {
30480 PyThreadState* __tstate = wxPyBeginAllowThreads();
30481 result = (int)((wxDateSpan const *)arg1)->GetYears();
30482 wxPyEndAllowThreads(__tstate);
30483 if (PyErr_Occurred()) SWIG_fail;
30484 }
30485 resultobj = SWIG_From_int(static_cast< int >(result));
30486 return resultobj;
30487 fail:
30488 return NULL;
30489 }
30490
30491
30492 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30493 PyObject *resultobj = 0;
30494 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30495 int result;
30496 void *argp1 = 0 ;
30497 int res1 = 0 ;
30498 PyObject *swig_obj[1] ;
30499
30500 if (!args) SWIG_fail;
30501 swig_obj[0] = args;
30502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30503 if (!SWIG_IsOK(res1)) {
30504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30505 }
30506 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30507 {
30508 PyThreadState* __tstate = wxPyBeginAllowThreads();
30509 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30510 wxPyEndAllowThreads(__tstate);
30511 if (PyErr_Occurred()) SWIG_fail;
30512 }
30513 resultobj = SWIG_From_int(static_cast< int >(result));
30514 return resultobj;
30515 fail:
30516 return NULL;
30517 }
30518
30519
30520 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30521 PyObject *resultobj = 0;
30522 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30523 int result;
30524 void *argp1 = 0 ;
30525 int res1 = 0 ;
30526 PyObject *swig_obj[1] ;
30527
30528 if (!args) SWIG_fail;
30529 swig_obj[0] = args;
30530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30531 if (!SWIG_IsOK(res1)) {
30532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30533 }
30534 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30535 {
30536 PyThreadState* __tstate = wxPyBeginAllowThreads();
30537 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30538 wxPyEndAllowThreads(__tstate);
30539 if (PyErr_Occurred()) SWIG_fail;
30540 }
30541 resultobj = SWIG_From_int(static_cast< int >(result));
30542 return resultobj;
30543 fail:
30544 return NULL;
30545 }
30546
30547
30548 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30549 PyObject *resultobj = 0;
30550 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30551 int result;
30552 void *argp1 = 0 ;
30553 int res1 = 0 ;
30554 PyObject *swig_obj[1] ;
30555
30556 if (!args) SWIG_fail;
30557 swig_obj[0] = args;
30558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30559 if (!SWIG_IsOK(res1)) {
30560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30561 }
30562 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30563 {
30564 PyThreadState* __tstate = wxPyBeginAllowThreads();
30565 result = (int)((wxDateSpan const *)arg1)->GetDays();
30566 wxPyEndAllowThreads(__tstate);
30567 if (PyErr_Occurred()) SWIG_fail;
30568 }
30569 resultobj = SWIG_From_int(static_cast< int >(result));
30570 return resultobj;
30571 fail:
30572 return NULL;
30573 }
30574
30575
30576 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30577 PyObject *resultobj = 0;
30578 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30579 int result;
30580 void *argp1 = 0 ;
30581 int res1 = 0 ;
30582 PyObject *swig_obj[1] ;
30583
30584 if (!args) SWIG_fail;
30585 swig_obj[0] = args;
30586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30587 if (!SWIG_IsOK(res1)) {
30588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30589 }
30590 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30591 {
30592 PyThreadState* __tstate = wxPyBeginAllowThreads();
30593 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30594 wxPyEndAllowThreads(__tstate);
30595 if (PyErr_Occurred()) SWIG_fail;
30596 }
30597 resultobj = SWIG_From_int(static_cast< int >(result));
30598 return resultobj;
30599 fail:
30600 return NULL;
30601 }
30602
30603
30604 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30605 PyObject *resultobj = 0;
30606 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30607 wxDateSpan *arg2 = 0 ;
30608 wxDateSpan *result = 0 ;
30609 void *argp1 = 0 ;
30610 int res1 = 0 ;
30611 void *argp2 = 0 ;
30612 int res2 = 0 ;
30613 PyObject * obj0 = 0 ;
30614 PyObject * obj1 = 0 ;
30615 char * kwnames[] = {
30616 (char *) "self",(char *) "other", NULL
30617 };
30618
30619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30621 if (!SWIG_IsOK(res1)) {
30622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30623 }
30624 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30625 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30626 if (!SWIG_IsOK(res2)) {
30627 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30628 }
30629 if (!argp2) {
30630 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30631 }
30632 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30633 {
30634 PyThreadState* __tstate = wxPyBeginAllowThreads();
30635 {
30636 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30637 result = (wxDateSpan *) &_result_ref;
30638 }
30639 wxPyEndAllowThreads(__tstate);
30640 if (PyErr_Occurred()) SWIG_fail;
30641 }
30642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30643 return resultobj;
30644 fail:
30645 return NULL;
30646 }
30647
30648
30649 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30650 PyObject *resultobj = 0;
30651 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30652 wxDateSpan *arg2 = 0 ;
30653 wxDateSpan *result = 0 ;
30654 void *argp1 = 0 ;
30655 int res1 = 0 ;
30656 void *argp2 = 0 ;
30657 int res2 = 0 ;
30658 PyObject * obj0 = 0 ;
30659 PyObject * obj1 = 0 ;
30660 char * kwnames[] = {
30661 (char *) "self",(char *) "other", NULL
30662 };
30663
30664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30666 if (!SWIG_IsOK(res1)) {
30667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30668 }
30669 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30670 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30671 if (!SWIG_IsOK(res2)) {
30672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30673 }
30674 if (!argp2) {
30675 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30676 }
30677 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30678 {
30679 PyThreadState* __tstate = wxPyBeginAllowThreads();
30680 {
30681 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30682 result = (wxDateSpan *) &_result_ref;
30683 }
30684 wxPyEndAllowThreads(__tstate);
30685 if (PyErr_Occurred()) SWIG_fail;
30686 }
30687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30688 return resultobj;
30689 fail:
30690 return NULL;
30691 }
30692
30693
30694 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30695 PyObject *resultobj = 0;
30696 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30697 wxDateSpan *result = 0 ;
30698 void *argp1 = 0 ;
30699 int res1 = 0 ;
30700 PyObject *swig_obj[1] ;
30701
30702 if (!args) SWIG_fail;
30703 swig_obj[0] = args;
30704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30705 if (!SWIG_IsOK(res1)) {
30706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30707 }
30708 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30709 {
30710 PyThreadState* __tstate = wxPyBeginAllowThreads();
30711 {
30712 wxDateSpan &_result_ref = (arg1)->Neg();
30713 result = (wxDateSpan *) &_result_ref;
30714 }
30715 wxPyEndAllowThreads(__tstate);
30716 if (PyErr_Occurred()) SWIG_fail;
30717 }
30718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30719 return resultobj;
30720 fail:
30721 return NULL;
30722 }
30723
30724
30725 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30726 PyObject *resultobj = 0;
30727 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30728 int arg2 ;
30729 wxDateSpan *result = 0 ;
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 *) "factor", NULL
30738 };
30739
30740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
30741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30742 if (!SWIG_IsOK(res1)) {
30743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30744 }
30745 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30746 ecode2 = SWIG_AsVal_int(obj1, &val2);
30747 if (!SWIG_IsOK(ecode2)) {
30748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
30749 }
30750 arg2 = static_cast< int >(val2);
30751 {
30752 PyThreadState* __tstate = wxPyBeginAllowThreads();
30753 {
30754 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
30755 result = (wxDateSpan *) &_result_ref;
30756 }
30757 wxPyEndAllowThreads(__tstate);
30758 if (PyErr_Occurred()) SWIG_fail;
30759 }
30760 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30761 return resultobj;
30762 fail:
30763 return NULL;
30764 }
30765
30766
30767 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30768 PyObject *resultobj = 0;
30769 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30770 wxDateSpan *arg2 = 0 ;
30771 wxDateSpan *result = 0 ;
30772 void *argp1 = 0 ;
30773 int res1 = 0 ;
30774 void *argp2 = 0 ;
30775 int res2 = 0 ;
30776 PyObject * obj0 = 0 ;
30777 PyObject * obj1 = 0 ;
30778 char * kwnames[] = {
30779 (char *) "self",(char *) "other", NULL
30780 };
30781
30782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
30783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30784 if (!SWIG_IsOK(res1)) {
30785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30786 }
30787 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30788 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30789 if (!SWIG_IsOK(res2)) {
30790 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30791 }
30792 if (!argp2) {
30793 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30794 }
30795 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30796 {
30797 PyThreadState* __tstate = wxPyBeginAllowThreads();
30798 {
30799 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
30800 result = (wxDateSpan *) &_result_ref;
30801 }
30802 wxPyEndAllowThreads(__tstate);
30803 if (PyErr_Occurred()) SWIG_fail;
30804 }
30805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30806 return resultobj;
30807 fail:
30808 return NULL;
30809 }
30810
30811
30812 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30813 PyObject *resultobj = 0;
30814 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30815 wxDateSpan *arg2 = 0 ;
30816 wxDateSpan *result = 0 ;
30817 void *argp1 = 0 ;
30818 int res1 = 0 ;
30819 void *argp2 = 0 ;
30820 int res2 = 0 ;
30821 PyObject * obj0 = 0 ;
30822 PyObject * obj1 = 0 ;
30823 char * kwnames[] = {
30824 (char *) "self",(char *) "other", NULL
30825 };
30826
30827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
30828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30829 if (!SWIG_IsOK(res1)) {
30830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30831 }
30832 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30833 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30834 if (!SWIG_IsOK(res2)) {
30835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30836 }
30837 if (!argp2) {
30838 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30839 }
30840 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30841 {
30842 PyThreadState* __tstate = wxPyBeginAllowThreads();
30843 {
30844 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
30845 result = (wxDateSpan *) &_result_ref;
30846 }
30847 wxPyEndAllowThreads(__tstate);
30848 if (PyErr_Occurred()) SWIG_fail;
30849 }
30850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30851 return resultobj;
30852 fail:
30853 return NULL;
30854 }
30855
30856
30857 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30858 PyObject *resultobj = 0;
30859 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30860 wxDateSpan *result = 0 ;
30861 void *argp1 = 0 ;
30862 int res1 = 0 ;
30863 PyObject *swig_obj[1] ;
30864
30865 if (!args) SWIG_fail;
30866 swig_obj[0] = args;
30867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30868 if (!SWIG_IsOK(res1)) {
30869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30870 }
30871 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30872 {
30873 PyThreadState* __tstate = wxPyBeginAllowThreads();
30874 {
30875 wxDateSpan &_result_ref = (arg1)->operator -();
30876 result = (wxDateSpan *) &_result_ref;
30877 }
30878 wxPyEndAllowThreads(__tstate);
30879 if (PyErr_Occurred()) SWIG_fail;
30880 }
30881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30882 return resultobj;
30883 fail:
30884 return NULL;
30885 }
30886
30887
30888 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30889 PyObject *resultobj = 0;
30890 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30891 int arg2 ;
30892 wxDateSpan *result = 0 ;
30893 void *argp1 = 0 ;
30894 int res1 = 0 ;
30895 int val2 ;
30896 int ecode2 = 0 ;
30897 PyObject * obj0 = 0 ;
30898 PyObject * obj1 = 0 ;
30899 char * kwnames[] = {
30900 (char *) "self",(char *) "factor", NULL
30901 };
30902
30903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
30904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30905 if (!SWIG_IsOK(res1)) {
30906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30907 }
30908 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30909 ecode2 = SWIG_AsVal_int(obj1, &val2);
30910 if (!SWIG_IsOK(ecode2)) {
30911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
30912 }
30913 arg2 = static_cast< int >(val2);
30914 {
30915 PyThreadState* __tstate = wxPyBeginAllowThreads();
30916 {
30917 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
30918 result = (wxDateSpan *) &_result_ref;
30919 }
30920 wxPyEndAllowThreads(__tstate);
30921 if (PyErr_Occurred()) SWIG_fail;
30922 }
30923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30924 return resultobj;
30925 fail:
30926 return NULL;
30927 }
30928
30929
30930 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30931 PyObject *resultobj = 0;
30932 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30933 wxDateSpan *arg2 = 0 ;
30934 wxDateSpan result;
30935 void *argp1 = 0 ;
30936 int res1 = 0 ;
30937 void *argp2 = 0 ;
30938 int res2 = 0 ;
30939 PyObject * obj0 = 0 ;
30940 PyObject * obj1 = 0 ;
30941 char * kwnames[] = {
30942 (char *) "self",(char *) "other", NULL
30943 };
30944
30945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
30946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30947 if (!SWIG_IsOK(res1)) {
30948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30949 }
30950 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30951 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30952 if (!SWIG_IsOK(res2)) {
30953 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30954 }
30955 if (!argp2) {
30956 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30957 }
30958 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30959 {
30960 PyThreadState* __tstate = wxPyBeginAllowThreads();
30961 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
30962 wxPyEndAllowThreads(__tstate);
30963 if (PyErr_Occurred()) SWIG_fail;
30964 }
30965 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30966 return resultobj;
30967 fail:
30968 return NULL;
30969 }
30970
30971
30972 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30973 PyObject *resultobj = 0;
30974 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30975 wxDateSpan *arg2 = 0 ;
30976 wxDateSpan result;
30977 void *argp1 = 0 ;
30978 int res1 = 0 ;
30979 void *argp2 = 0 ;
30980 int res2 = 0 ;
30981 PyObject * obj0 = 0 ;
30982 PyObject * obj1 = 0 ;
30983 char * kwnames[] = {
30984 (char *) "self",(char *) "other", NULL
30985 };
30986
30987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
30988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30989 if (!SWIG_IsOK(res1)) {
30990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30991 }
30992 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30993 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30994 if (!SWIG_IsOK(res2)) {
30995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30996 }
30997 if (!argp2) {
30998 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30999 }
31000 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31001 {
31002 PyThreadState* __tstate = wxPyBeginAllowThreads();
31003 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31004 wxPyEndAllowThreads(__tstate);
31005 if (PyErr_Occurred()) SWIG_fail;
31006 }
31007 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31008 return resultobj;
31009 fail:
31010 return NULL;
31011 }
31012
31013
31014 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31015 PyObject *resultobj = 0;
31016 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31017 int arg2 ;
31018 wxDateSpan result;
31019 void *argp1 = 0 ;
31020 int res1 = 0 ;
31021 int val2 ;
31022 int ecode2 = 0 ;
31023 PyObject * obj0 = 0 ;
31024 PyObject * obj1 = 0 ;
31025 char * kwnames[] = {
31026 (char *) "self",(char *) "n", NULL
31027 };
31028
31029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31031 if (!SWIG_IsOK(res1)) {
31032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31033 }
31034 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31035 ecode2 = SWIG_AsVal_int(obj1, &val2);
31036 if (!SWIG_IsOK(ecode2)) {
31037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31038 }
31039 arg2 = static_cast< int >(val2);
31040 {
31041 PyThreadState* __tstate = wxPyBeginAllowThreads();
31042 result = wxDateSpan___mul__(arg1,arg2);
31043 wxPyEndAllowThreads(__tstate);
31044 if (PyErr_Occurred()) SWIG_fail;
31045 }
31046 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31047 return resultobj;
31048 fail:
31049 return NULL;
31050 }
31051
31052
31053 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31054 PyObject *resultobj = 0;
31055 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31056 int arg2 ;
31057 wxDateSpan result;
31058 void *argp1 = 0 ;
31059 int res1 = 0 ;
31060 int val2 ;
31061 int ecode2 = 0 ;
31062 PyObject * obj0 = 0 ;
31063 PyObject * obj1 = 0 ;
31064 char * kwnames[] = {
31065 (char *) "self",(char *) "n", NULL
31066 };
31067
31068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31070 if (!SWIG_IsOK(res1)) {
31071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31072 }
31073 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31074 ecode2 = SWIG_AsVal_int(obj1, &val2);
31075 if (!SWIG_IsOK(ecode2)) {
31076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31077 }
31078 arg2 = static_cast< int >(val2);
31079 {
31080 PyThreadState* __tstate = wxPyBeginAllowThreads();
31081 result = wxDateSpan___rmul__(arg1,arg2);
31082 wxPyEndAllowThreads(__tstate);
31083 if (PyErr_Occurred()) SWIG_fail;
31084 }
31085 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31086 return resultobj;
31087 fail:
31088 return NULL;
31089 }
31090
31091
31092 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31093 PyObject *resultobj = 0;
31094 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31095 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31096 bool result;
31097 void *argp1 = 0 ;
31098 int res1 = 0 ;
31099 void *argp2 = 0 ;
31100 int res2 = 0 ;
31101 PyObject * obj0 = 0 ;
31102 PyObject * obj1 = 0 ;
31103 char * kwnames[] = {
31104 (char *) "self",(char *) "other", NULL
31105 };
31106
31107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31109 if (!SWIG_IsOK(res1)) {
31110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31111 }
31112 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31113 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31114 if (!SWIG_IsOK(res2)) {
31115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31116 }
31117 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31118 {
31119 PyThreadState* __tstate = wxPyBeginAllowThreads();
31120 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31121 wxPyEndAllowThreads(__tstate);
31122 if (PyErr_Occurred()) SWIG_fail;
31123 }
31124 {
31125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31126 }
31127 return resultobj;
31128 fail:
31129 return NULL;
31130 }
31131
31132
31133 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31134 PyObject *resultobj = 0;
31135 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31136 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31137 bool result;
31138 void *argp1 = 0 ;
31139 int res1 = 0 ;
31140 void *argp2 = 0 ;
31141 int res2 = 0 ;
31142 PyObject * obj0 = 0 ;
31143 PyObject * obj1 = 0 ;
31144 char * kwnames[] = {
31145 (char *) "self",(char *) "other", NULL
31146 };
31147
31148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31150 if (!SWIG_IsOK(res1)) {
31151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31152 }
31153 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31154 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31155 if (!SWIG_IsOK(res2)) {
31156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31157 }
31158 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31159 {
31160 PyThreadState* __tstate = wxPyBeginAllowThreads();
31161 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31162 wxPyEndAllowThreads(__tstate);
31163 if (PyErr_Occurred()) SWIG_fail;
31164 }
31165 {
31166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31167 }
31168 return resultobj;
31169 fail:
31170 return NULL;
31171 }
31172
31173
31174 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31175 PyObject *obj;
31176 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31177 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31178 return SWIG_Py_Void();
31179 }
31180
31181 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31182 return SWIG_Python_InitShadowInstance(args);
31183 }
31184
31185 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31186 PyObject *resultobj = 0;
31187 long result;
31188
31189 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31190 {
31191 PyThreadState* __tstate = wxPyBeginAllowThreads();
31192 result = (long)wxGetLocalTime();
31193 wxPyEndAllowThreads(__tstate);
31194 if (PyErr_Occurred()) SWIG_fail;
31195 }
31196 resultobj = SWIG_From_long(static_cast< long >(result));
31197 return resultobj;
31198 fail:
31199 return NULL;
31200 }
31201
31202
31203 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31204 PyObject *resultobj = 0;
31205 long result;
31206
31207 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31208 {
31209 PyThreadState* __tstate = wxPyBeginAllowThreads();
31210 result = (long)wxGetUTCTime();
31211 wxPyEndAllowThreads(__tstate);
31212 if (PyErr_Occurred()) SWIG_fail;
31213 }
31214 resultobj = SWIG_From_long(static_cast< long >(result));
31215 return resultobj;
31216 fail:
31217 return NULL;
31218 }
31219
31220
31221 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31222 PyObject *resultobj = 0;
31223 long result;
31224
31225 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31226 {
31227 PyThreadState* __tstate = wxPyBeginAllowThreads();
31228 result = (long)wxGetCurrentTime();
31229 wxPyEndAllowThreads(__tstate);
31230 if (PyErr_Occurred()) SWIG_fail;
31231 }
31232 resultobj = SWIG_From_long(static_cast< long >(result));
31233 return resultobj;
31234 fail:
31235 return NULL;
31236 }
31237
31238
31239 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31240 PyObject *resultobj = 0;
31241 wxLongLong result;
31242
31243 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31244 {
31245 PyThreadState* __tstate = wxPyBeginAllowThreads();
31246 result = wxGetLocalTimeMillis();
31247 wxPyEndAllowThreads(__tstate);
31248 if (PyErr_Occurred()) SWIG_fail;
31249 }
31250 {
31251 PyObject *hi, *lo, *shifter, *shifted;
31252 hi = PyLong_FromLong( (&result)->GetHi() );
31253 lo = PyLong_FromLong( (&result)->GetLo() );
31254 shifter = PyLong_FromLong(32);
31255 shifted = PyNumber_Lshift(hi, shifter);
31256 resultobj = PyNumber_Or(shifted, lo);
31257 Py_DECREF(hi);
31258 Py_DECREF(lo);
31259 Py_DECREF(shifter);
31260 Py_DECREF(shifted);
31261 }
31262 return resultobj;
31263 fail:
31264 return NULL;
31265 }
31266
31267
31268 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31269 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31270 return 1;
31271 }
31272
31273
31274 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31275 PyObject *pyobj = 0;
31276
31277 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31278 return pyobj;
31279 }
31280
31281
31282 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31283 PyObject *resultobj = 0;
31284 wxDataFormatId arg1 ;
31285 wxDataFormat *result = 0 ;
31286 int val1 ;
31287 int ecode1 = 0 ;
31288 PyObject * obj0 = 0 ;
31289 char * kwnames[] = {
31290 (char *) "type", NULL
31291 };
31292
31293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31294 ecode1 = SWIG_AsVal_int(obj0, &val1);
31295 if (!SWIG_IsOK(ecode1)) {
31296 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31297 }
31298 arg1 = static_cast< wxDataFormatId >(val1);
31299 {
31300 PyThreadState* __tstate = wxPyBeginAllowThreads();
31301 result = (wxDataFormat *)new wxDataFormat(arg1);
31302 wxPyEndAllowThreads(__tstate);
31303 if (PyErr_Occurred()) SWIG_fail;
31304 }
31305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31306 return resultobj;
31307 fail:
31308 return NULL;
31309 }
31310
31311
31312 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31313 PyObject *resultobj = 0;
31314 wxString *arg1 = 0 ;
31315 wxDataFormat *result = 0 ;
31316 bool temp1 = false ;
31317 PyObject * obj0 = 0 ;
31318 char * kwnames[] = {
31319 (char *) "format", NULL
31320 };
31321
31322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31323 {
31324 arg1 = wxString_in_helper(obj0);
31325 if (arg1 == NULL) SWIG_fail;
31326 temp1 = true;
31327 }
31328 {
31329 PyThreadState* __tstate = wxPyBeginAllowThreads();
31330 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31331 wxPyEndAllowThreads(__tstate);
31332 if (PyErr_Occurred()) SWIG_fail;
31333 }
31334 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31335 {
31336 if (temp1)
31337 delete arg1;
31338 }
31339 return resultobj;
31340 fail:
31341 {
31342 if (temp1)
31343 delete arg1;
31344 }
31345 return NULL;
31346 }
31347
31348
31349 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31350 PyObject *resultobj = 0;
31351 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31352 void *argp1 = 0 ;
31353 int res1 = 0 ;
31354 PyObject *swig_obj[1] ;
31355
31356 if (!args) SWIG_fail;
31357 swig_obj[0] = args;
31358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31359 if (!SWIG_IsOK(res1)) {
31360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31361 }
31362 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31363 {
31364 PyThreadState* __tstate = wxPyBeginAllowThreads();
31365 delete arg1;
31366
31367 wxPyEndAllowThreads(__tstate);
31368 if (PyErr_Occurred()) SWIG_fail;
31369 }
31370 resultobj = SWIG_Py_Void();
31371 return resultobj;
31372 fail:
31373 return NULL;
31374 }
31375
31376
31377 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31378 PyObject *resultobj = 0;
31379 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31380 wxDataFormatId arg2 ;
31381 bool result;
31382 void *argp1 = 0 ;
31383 int res1 = 0 ;
31384 int val2 ;
31385 int ecode2 = 0 ;
31386
31387 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31389 if (!SWIG_IsOK(res1)) {
31390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31391 }
31392 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31393 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31394 if (!SWIG_IsOK(ecode2)) {
31395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31396 }
31397 arg2 = static_cast< wxDataFormatId >(val2);
31398 {
31399 PyThreadState* __tstate = wxPyBeginAllowThreads();
31400 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31401 wxPyEndAllowThreads(__tstate);
31402 if (PyErr_Occurred()) SWIG_fail;
31403 }
31404 {
31405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31406 }
31407 return resultobj;
31408 fail:
31409 return NULL;
31410 }
31411
31412
31413 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31414 PyObject *resultobj = 0;
31415 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31416 wxDataFormatId arg2 ;
31417 bool result;
31418 void *argp1 = 0 ;
31419 int res1 = 0 ;
31420 int val2 ;
31421 int ecode2 = 0 ;
31422
31423 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31425 if (!SWIG_IsOK(res1)) {
31426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31427 }
31428 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31429 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31430 if (!SWIG_IsOK(ecode2)) {
31431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31432 }
31433 arg2 = static_cast< wxDataFormatId >(val2);
31434 {
31435 PyThreadState* __tstate = wxPyBeginAllowThreads();
31436 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31437 wxPyEndAllowThreads(__tstate);
31438 if (PyErr_Occurred()) SWIG_fail;
31439 }
31440 {
31441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31442 }
31443 return resultobj;
31444 fail:
31445 return NULL;
31446 }
31447
31448
31449 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31450 PyObject *resultobj = 0;
31451 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31452 wxDataFormat *arg2 = 0 ;
31453 bool result;
31454 void *argp1 = 0 ;
31455 int res1 = 0 ;
31456 void *argp2 = 0 ;
31457 int res2 = 0 ;
31458
31459 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31461 if (!SWIG_IsOK(res1)) {
31462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31463 }
31464 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31465 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31466 if (!SWIG_IsOK(res2)) {
31467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31468 }
31469 if (!argp2) {
31470 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31471 }
31472 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31473 {
31474 PyThreadState* __tstate = wxPyBeginAllowThreads();
31475 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31476 wxPyEndAllowThreads(__tstate);
31477 if (PyErr_Occurred()) SWIG_fail;
31478 }
31479 {
31480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31481 }
31482 return resultobj;
31483 fail:
31484 return NULL;
31485 }
31486
31487
31488 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31489 int argc;
31490 PyObject *argv[3];
31491
31492 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31493 --argc;
31494 if (argc == 2) {
31495 int _v = 0;
31496 {
31497 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31498 _v = SWIG_CheckState(res);
31499 }
31500 if (!_v) goto check_1;
31501 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31502 }
31503 check_1:
31504
31505 if (argc == 2) {
31506 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31507 }
31508
31509 fail:
31510 Py_INCREF(Py_NotImplemented);
31511 return Py_NotImplemented;
31512 }
31513
31514
31515 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31516 PyObject *resultobj = 0;
31517 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31518 wxDataFormat *arg2 = 0 ;
31519 bool result;
31520 void *argp1 = 0 ;
31521 int res1 = 0 ;
31522 void *argp2 = 0 ;
31523 int res2 = 0 ;
31524
31525 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31527 if (!SWIG_IsOK(res1)) {
31528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31529 }
31530 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31531 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31532 if (!SWIG_IsOK(res2)) {
31533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31534 }
31535 if (!argp2) {
31536 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31537 }
31538 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31539 {
31540 PyThreadState* __tstate = wxPyBeginAllowThreads();
31541 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31542 wxPyEndAllowThreads(__tstate);
31543 if (PyErr_Occurred()) SWIG_fail;
31544 }
31545 {
31546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31547 }
31548 return resultobj;
31549 fail:
31550 return NULL;
31551 }
31552
31553
31554 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31555 int argc;
31556 PyObject *argv[3];
31557
31558 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31559 --argc;
31560 if (argc == 2) {
31561 int _v = 0;
31562 {
31563 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31564 _v = SWIG_CheckState(res);
31565 }
31566 if (!_v) goto check_1;
31567 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31568 }
31569 check_1:
31570
31571 if (argc == 2) {
31572 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31573 }
31574
31575 fail:
31576 Py_INCREF(Py_NotImplemented);
31577 return Py_NotImplemented;
31578 }
31579
31580
31581 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31582 PyObject *resultobj = 0;
31583 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31584 wxDataFormatId arg2 ;
31585 void *argp1 = 0 ;
31586 int res1 = 0 ;
31587 int val2 ;
31588 int ecode2 = 0 ;
31589 PyObject * obj0 = 0 ;
31590 PyObject * obj1 = 0 ;
31591 char * kwnames[] = {
31592 (char *) "self",(char *) "format", NULL
31593 };
31594
31595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31597 if (!SWIG_IsOK(res1)) {
31598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31599 }
31600 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31601 ecode2 = SWIG_AsVal_int(obj1, &val2);
31602 if (!SWIG_IsOK(ecode2)) {
31603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31604 }
31605 arg2 = static_cast< wxDataFormatId >(val2);
31606 {
31607 PyThreadState* __tstate = wxPyBeginAllowThreads();
31608 (arg1)->SetType(arg2);
31609 wxPyEndAllowThreads(__tstate);
31610 if (PyErr_Occurred()) SWIG_fail;
31611 }
31612 resultobj = SWIG_Py_Void();
31613 return resultobj;
31614 fail:
31615 return NULL;
31616 }
31617
31618
31619 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31620 PyObject *resultobj = 0;
31621 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31622 wxDataFormatId result;
31623 void *argp1 = 0 ;
31624 int res1 = 0 ;
31625 PyObject *swig_obj[1] ;
31626
31627 if (!args) SWIG_fail;
31628 swig_obj[0] = args;
31629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31630 if (!SWIG_IsOK(res1)) {
31631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31632 }
31633 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31634 {
31635 PyThreadState* __tstate = wxPyBeginAllowThreads();
31636 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31637 wxPyEndAllowThreads(__tstate);
31638 if (PyErr_Occurred()) SWIG_fail;
31639 }
31640 resultobj = SWIG_From_int(static_cast< int >(result));
31641 return resultobj;
31642 fail:
31643 return NULL;
31644 }
31645
31646
31647 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31648 PyObject *resultobj = 0;
31649 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31650 wxString result;
31651 void *argp1 = 0 ;
31652 int res1 = 0 ;
31653 PyObject *swig_obj[1] ;
31654
31655 if (!args) SWIG_fail;
31656 swig_obj[0] = args;
31657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31658 if (!SWIG_IsOK(res1)) {
31659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31660 }
31661 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31662 {
31663 PyThreadState* __tstate = wxPyBeginAllowThreads();
31664 result = ((wxDataFormat const *)arg1)->GetId();
31665 wxPyEndAllowThreads(__tstate);
31666 if (PyErr_Occurred()) SWIG_fail;
31667 }
31668 {
31669 #if wxUSE_UNICODE
31670 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31671 #else
31672 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31673 #endif
31674 }
31675 return resultobj;
31676 fail:
31677 return NULL;
31678 }
31679
31680
31681 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31682 PyObject *resultobj = 0;
31683 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31684 wxString *arg2 = 0 ;
31685 void *argp1 = 0 ;
31686 int res1 = 0 ;
31687 bool temp2 = false ;
31688 PyObject * obj0 = 0 ;
31689 PyObject * obj1 = 0 ;
31690 char * kwnames[] = {
31691 (char *) "self",(char *) "format", NULL
31692 };
31693
31694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31696 if (!SWIG_IsOK(res1)) {
31697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31698 }
31699 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31700 {
31701 arg2 = wxString_in_helper(obj1);
31702 if (arg2 == NULL) SWIG_fail;
31703 temp2 = true;
31704 }
31705 {
31706 PyThreadState* __tstate = wxPyBeginAllowThreads();
31707 (arg1)->SetId((wxString const &)*arg2);
31708 wxPyEndAllowThreads(__tstate);
31709 if (PyErr_Occurred()) SWIG_fail;
31710 }
31711 resultobj = SWIG_Py_Void();
31712 {
31713 if (temp2)
31714 delete arg2;
31715 }
31716 return resultobj;
31717 fail:
31718 {
31719 if (temp2)
31720 delete arg2;
31721 }
31722 return NULL;
31723 }
31724
31725
31726 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31727 PyObject *obj;
31728 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31729 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
31730 return SWIG_Py_Void();
31731 }
31732
31733 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31734 return SWIG_Python_InitShadowInstance(args);
31735 }
31736
31737 SWIGINTERN int FormatInvalid_set(PyObject *) {
31738 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
31739 return 1;
31740 }
31741
31742
31743 SWIGINTERN PyObject *FormatInvalid_get(void) {
31744 PyObject *pyobj = 0;
31745
31746 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
31747 return pyobj;
31748 }
31749
31750
31751 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31752 PyObject *resultobj = 0;
31753 wxDataObject *arg1 = (wxDataObject *) 0 ;
31754 void *argp1 = 0 ;
31755 int res1 = 0 ;
31756 PyObject *swig_obj[1] ;
31757
31758 if (!args) SWIG_fail;
31759 swig_obj[0] = args;
31760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
31761 if (!SWIG_IsOK(res1)) {
31762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
31763 }
31764 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31765 {
31766 PyThreadState* __tstate = wxPyBeginAllowThreads();
31767 delete arg1;
31768
31769 wxPyEndAllowThreads(__tstate);
31770 if (PyErr_Occurred()) SWIG_fail;
31771 }
31772 resultobj = SWIG_Py_Void();
31773 return resultobj;
31774 fail:
31775 return NULL;
31776 }
31777
31778
31779 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31780 PyObject *resultobj = 0;
31781 wxDataObject *arg1 = (wxDataObject *) 0 ;
31782 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31783 SwigValueWrapper<wxDataFormat > result;
31784 void *argp1 = 0 ;
31785 int res1 = 0 ;
31786 int val2 ;
31787 int ecode2 = 0 ;
31788 PyObject * obj0 = 0 ;
31789 PyObject * obj1 = 0 ;
31790 char * kwnames[] = {
31791 (char *) "self",(char *) "dir", NULL
31792 };
31793
31794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31796 if (!SWIG_IsOK(res1)) {
31797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31798 }
31799 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31800 if (obj1) {
31801 ecode2 = SWIG_AsVal_int(obj1, &val2);
31802 if (!SWIG_IsOK(ecode2)) {
31803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31804 }
31805 arg2 = static_cast< wxDataObject::Direction >(val2);
31806 }
31807 {
31808 PyThreadState* __tstate = wxPyBeginAllowThreads();
31809 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
31810 wxPyEndAllowThreads(__tstate);
31811 if (PyErr_Occurred()) SWIG_fail;
31812 }
31813 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31814 return resultobj;
31815 fail:
31816 return NULL;
31817 }
31818
31819
31820 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31821 PyObject *resultobj = 0;
31822 wxDataObject *arg1 = (wxDataObject *) 0 ;
31823 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31824 size_t result;
31825 void *argp1 = 0 ;
31826 int res1 = 0 ;
31827 int val2 ;
31828 int ecode2 = 0 ;
31829 PyObject * obj0 = 0 ;
31830 PyObject * obj1 = 0 ;
31831 char * kwnames[] = {
31832 (char *) "self",(char *) "dir", NULL
31833 };
31834
31835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
31836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31837 if (!SWIG_IsOK(res1)) {
31838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31839 }
31840 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31841 if (obj1) {
31842 ecode2 = SWIG_AsVal_int(obj1, &val2);
31843 if (!SWIG_IsOK(ecode2)) {
31844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31845 }
31846 arg2 = static_cast< wxDataObject::Direction >(val2);
31847 }
31848 {
31849 PyThreadState* __tstate = wxPyBeginAllowThreads();
31850 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
31851 wxPyEndAllowThreads(__tstate);
31852 if (PyErr_Occurred()) SWIG_fail;
31853 }
31854 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31855 return resultobj;
31856 fail:
31857 return NULL;
31858 }
31859
31860
31861 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31862 PyObject *resultobj = 0;
31863 wxDataObject *arg1 = (wxDataObject *) 0 ;
31864 wxDataFormat *arg2 = 0 ;
31865 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
31866 bool result;
31867 void *argp1 = 0 ;
31868 int res1 = 0 ;
31869 void *argp2 = 0 ;
31870 int res2 = 0 ;
31871 int val3 ;
31872 int ecode3 = 0 ;
31873 PyObject * obj0 = 0 ;
31874 PyObject * obj1 = 0 ;
31875 PyObject * obj2 = 0 ;
31876 char * kwnames[] = {
31877 (char *) "self",(char *) "format",(char *) "dir", NULL
31878 };
31879
31880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31882 if (!SWIG_IsOK(res1)) {
31883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31884 }
31885 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31886 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31887 if (!SWIG_IsOK(res2)) {
31888 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31889 }
31890 if (!argp2) {
31891 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31892 }
31893 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31894 if (obj2) {
31895 ecode3 = SWIG_AsVal_int(obj2, &val3);
31896 if (!SWIG_IsOK(ecode3)) {
31897 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
31898 }
31899 arg3 = static_cast< wxDataObject::Direction >(val3);
31900 }
31901 {
31902 PyThreadState* __tstate = wxPyBeginAllowThreads();
31903 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
31904 wxPyEndAllowThreads(__tstate);
31905 if (PyErr_Occurred()) SWIG_fail;
31906 }
31907 {
31908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31909 }
31910 return resultobj;
31911 fail:
31912 return NULL;
31913 }
31914
31915
31916 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31917 PyObject *resultobj = 0;
31918 wxDataObject *arg1 = (wxDataObject *) 0 ;
31919 wxDataFormat *arg2 = 0 ;
31920 size_t result;
31921 void *argp1 = 0 ;
31922 int res1 = 0 ;
31923 void *argp2 = 0 ;
31924 int res2 = 0 ;
31925 PyObject * obj0 = 0 ;
31926 PyObject * obj1 = 0 ;
31927 char * kwnames[] = {
31928 (char *) "self",(char *) "format", NULL
31929 };
31930
31931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
31932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31933 if (!SWIG_IsOK(res1)) {
31934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31935 }
31936 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31937 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31938 if (!SWIG_IsOK(res2)) {
31939 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31940 }
31941 if (!argp2) {
31942 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31943 }
31944 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31945 {
31946 PyThreadState* __tstate = wxPyBeginAllowThreads();
31947 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
31948 wxPyEndAllowThreads(__tstate);
31949 if (PyErr_Occurred()) SWIG_fail;
31950 }
31951 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31952 return resultobj;
31953 fail:
31954 return NULL;
31955 }
31956
31957
31958 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31959 PyObject *resultobj = 0;
31960 wxDataObject *arg1 = (wxDataObject *) 0 ;
31961 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31962 PyObject *result = 0 ;
31963 void *argp1 = 0 ;
31964 int res1 = 0 ;
31965 int val2 ;
31966 int ecode2 = 0 ;
31967 PyObject * obj0 = 0 ;
31968 PyObject * obj1 = 0 ;
31969 char * kwnames[] = {
31970 (char *) "self",(char *) "dir", NULL
31971 };
31972
31973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
31974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31975 if (!SWIG_IsOK(res1)) {
31976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
31977 }
31978 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31979 if (obj1) {
31980 ecode2 = SWIG_AsVal_int(obj1, &val2);
31981 if (!SWIG_IsOK(ecode2)) {
31982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31983 }
31984 arg2 = static_cast< wxDataObject::Direction >(val2);
31985 }
31986 {
31987 PyThreadState* __tstate = wxPyBeginAllowThreads();
31988 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
31989 wxPyEndAllowThreads(__tstate);
31990 if (PyErr_Occurred()) SWIG_fail;
31991 }
31992 resultobj = result;
31993 return resultobj;
31994 fail:
31995 return NULL;
31996 }
31997
31998
31999 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32000 PyObject *resultobj = 0;
32001 wxDataObject *arg1 = (wxDataObject *) 0 ;
32002 wxDataFormat *arg2 = 0 ;
32003 PyObject *result = 0 ;
32004 void *argp1 = 0 ;
32005 int res1 = 0 ;
32006 void *argp2 = 0 ;
32007 int res2 = 0 ;
32008 PyObject * obj0 = 0 ;
32009 PyObject * obj1 = 0 ;
32010 char * kwnames[] = {
32011 (char *) "self",(char *) "format", NULL
32012 };
32013
32014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32016 if (!SWIG_IsOK(res1)) {
32017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32018 }
32019 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32020 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32021 if (!SWIG_IsOK(res2)) {
32022 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32023 }
32024 if (!argp2) {
32025 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32026 }
32027 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32028 {
32029 PyThreadState* __tstate = wxPyBeginAllowThreads();
32030 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32031 wxPyEndAllowThreads(__tstate);
32032 if (PyErr_Occurred()) SWIG_fail;
32033 }
32034 resultobj = result;
32035 return resultobj;
32036 fail:
32037 return NULL;
32038 }
32039
32040
32041 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32042 PyObject *resultobj = 0;
32043 wxDataObject *arg1 = (wxDataObject *) 0 ;
32044 wxDataFormat *arg2 = 0 ;
32045 PyObject *arg3 = (PyObject *) 0 ;
32046 bool result;
32047 void *argp1 = 0 ;
32048 int res1 = 0 ;
32049 void *argp2 = 0 ;
32050 int res2 = 0 ;
32051 PyObject * obj0 = 0 ;
32052 PyObject * obj1 = 0 ;
32053 PyObject * obj2 = 0 ;
32054 char * kwnames[] = {
32055 (char *) "self",(char *) "format",(char *) "data", NULL
32056 };
32057
32058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32060 if (!SWIG_IsOK(res1)) {
32061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32062 }
32063 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32064 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32065 if (!SWIG_IsOK(res2)) {
32066 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32067 }
32068 if (!argp2) {
32069 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32070 }
32071 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32072 arg3 = obj2;
32073 {
32074 PyThreadState* __tstate = wxPyBeginAllowThreads();
32075 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32076 wxPyEndAllowThreads(__tstate);
32077 if (PyErr_Occurred()) SWIG_fail;
32078 }
32079 {
32080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32081 }
32082 return resultobj;
32083 fail:
32084 return NULL;
32085 }
32086
32087
32088 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32089 PyObject *obj;
32090 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32091 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32092 return SWIG_Py_Void();
32093 }
32094
32095 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32096 PyObject *resultobj = 0;
32097 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32098 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32099 wxDataObjectSimple *result = 0 ;
32100 void *argp1 = 0 ;
32101 int res1 = 0 ;
32102 PyObject * obj0 = 0 ;
32103 char * kwnames[] = {
32104 (char *) "format", NULL
32105 };
32106
32107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32108 if (obj0) {
32109 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32110 if (!SWIG_IsOK(res1)) {
32111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32112 }
32113 if (!argp1) {
32114 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32115 }
32116 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32117 }
32118 {
32119 PyThreadState* __tstate = wxPyBeginAllowThreads();
32120 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32121 wxPyEndAllowThreads(__tstate);
32122 if (PyErr_Occurred()) SWIG_fail;
32123 }
32124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32125 return resultobj;
32126 fail:
32127 return NULL;
32128 }
32129
32130
32131 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32132 PyObject *resultobj = 0;
32133 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32134 wxDataFormat *result = 0 ;
32135 void *argp1 = 0 ;
32136 int res1 = 0 ;
32137 PyObject *swig_obj[1] ;
32138
32139 if (!args) SWIG_fail;
32140 swig_obj[0] = args;
32141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32142 if (!SWIG_IsOK(res1)) {
32143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32144 }
32145 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32146 {
32147 PyThreadState* __tstate = wxPyBeginAllowThreads();
32148 {
32149 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32150 result = (wxDataFormat *) &_result_ref;
32151 }
32152 wxPyEndAllowThreads(__tstate);
32153 if (PyErr_Occurred()) SWIG_fail;
32154 }
32155 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32156 return resultobj;
32157 fail:
32158 return NULL;
32159 }
32160
32161
32162 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32163 PyObject *resultobj = 0;
32164 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32165 wxDataFormat *arg2 = 0 ;
32166 void *argp1 = 0 ;
32167 int res1 = 0 ;
32168 void *argp2 = 0 ;
32169 int res2 = 0 ;
32170 PyObject * obj0 = 0 ;
32171 PyObject * obj1 = 0 ;
32172 char * kwnames[] = {
32173 (char *) "self",(char *) "format", NULL
32174 };
32175
32176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32178 if (!SWIG_IsOK(res1)) {
32179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32180 }
32181 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32182 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32183 if (!SWIG_IsOK(res2)) {
32184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32185 }
32186 if (!argp2) {
32187 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32188 }
32189 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32190 {
32191 PyThreadState* __tstate = wxPyBeginAllowThreads();
32192 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32193 wxPyEndAllowThreads(__tstate);
32194 if (PyErr_Occurred()) SWIG_fail;
32195 }
32196 resultobj = SWIG_Py_Void();
32197 return resultobj;
32198 fail:
32199 return NULL;
32200 }
32201
32202
32203 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32204 PyObject *resultobj = 0;
32205 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32206 size_t result;
32207 void *argp1 = 0 ;
32208 int res1 = 0 ;
32209 PyObject *swig_obj[1] ;
32210
32211 if (!args) SWIG_fail;
32212 swig_obj[0] = args;
32213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32214 if (!SWIG_IsOK(res1)) {
32215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32216 }
32217 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32218 {
32219 PyThreadState* __tstate = wxPyBeginAllowThreads();
32220 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32221 wxPyEndAllowThreads(__tstate);
32222 if (PyErr_Occurred()) SWIG_fail;
32223 }
32224 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32225 return resultobj;
32226 fail:
32227 return NULL;
32228 }
32229
32230
32231 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32232 PyObject *resultobj = 0;
32233 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32234 PyObject *result = 0 ;
32235 void *argp1 = 0 ;
32236 int res1 = 0 ;
32237 PyObject *swig_obj[1] ;
32238
32239 if (!args) SWIG_fail;
32240 swig_obj[0] = args;
32241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32242 if (!SWIG_IsOK(res1)) {
32243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32244 }
32245 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32246 {
32247 PyThreadState* __tstate = wxPyBeginAllowThreads();
32248 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32249 wxPyEndAllowThreads(__tstate);
32250 if (PyErr_Occurred()) SWIG_fail;
32251 }
32252 resultobj = result;
32253 return resultobj;
32254 fail:
32255 return NULL;
32256 }
32257
32258
32259 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32260 PyObject *resultobj = 0;
32261 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32262 PyObject *arg2 = (PyObject *) 0 ;
32263 bool result;
32264 void *argp1 = 0 ;
32265 int res1 = 0 ;
32266 PyObject * obj0 = 0 ;
32267 PyObject * obj1 = 0 ;
32268 char * kwnames[] = {
32269 (char *) "self",(char *) "data", NULL
32270 };
32271
32272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32274 if (!SWIG_IsOK(res1)) {
32275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32276 }
32277 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32278 arg2 = obj1;
32279 {
32280 PyThreadState* __tstate = wxPyBeginAllowThreads();
32281 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32282 wxPyEndAllowThreads(__tstate);
32283 if (PyErr_Occurred()) SWIG_fail;
32284 }
32285 {
32286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32287 }
32288 return resultobj;
32289 fail:
32290 return NULL;
32291 }
32292
32293
32294 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32295 PyObject *obj;
32296 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32297 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32298 return SWIG_Py_Void();
32299 }
32300
32301 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32302 return SWIG_Python_InitShadowInstance(args);
32303 }
32304
32305 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32306 PyObject *resultobj = 0;
32307 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32308 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32309 wxPyDataObjectSimple *result = 0 ;
32310 void *argp1 = 0 ;
32311 int res1 = 0 ;
32312 PyObject * obj0 = 0 ;
32313 char * kwnames[] = {
32314 (char *) "format", NULL
32315 };
32316
32317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32318 if (obj0) {
32319 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32320 if (!SWIG_IsOK(res1)) {
32321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32322 }
32323 if (!argp1) {
32324 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32325 }
32326 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32327 }
32328 {
32329 PyThreadState* __tstate = wxPyBeginAllowThreads();
32330 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32331 wxPyEndAllowThreads(__tstate);
32332 if (PyErr_Occurred()) SWIG_fail;
32333 }
32334 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32335 return resultobj;
32336 fail:
32337 return NULL;
32338 }
32339
32340
32341 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32342 PyObject *resultobj = 0;
32343 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32344 PyObject *arg2 = (PyObject *) 0 ;
32345 PyObject *arg3 = (PyObject *) 0 ;
32346 void *argp1 = 0 ;
32347 int res1 = 0 ;
32348 PyObject * obj0 = 0 ;
32349 PyObject * obj1 = 0 ;
32350 PyObject * obj2 = 0 ;
32351 char * kwnames[] = {
32352 (char *) "self",(char *) "self",(char *) "_class", NULL
32353 };
32354
32355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32357 if (!SWIG_IsOK(res1)) {
32358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32359 }
32360 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32361 arg2 = obj1;
32362 arg3 = obj2;
32363 {
32364 PyThreadState* __tstate = wxPyBeginAllowThreads();
32365 (arg1)->_setCallbackInfo(arg2,arg3);
32366 wxPyEndAllowThreads(__tstate);
32367 if (PyErr_Occurred()) SWIG_fail;
32368 }
32369 resultobj = SWIG_Py_Void();
32370 return resultobj;
32371 fail:
32372 return NULL;
32373 }
32374
32375
32376 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32377 PyObject *obj;
32378 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32379 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32380 return SWIG_Py_Void();
32381 }
32382
32383 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32384 return SWIG_Python_InitShadowInstance(args);
32385 }
32386
32387 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32388 PyObject *resultobj = 0;
32389 wxDataObjectComposite *result = 0 ;
32390
32391 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32392 {
32393 PyThreadState* __tstate = wxPyBeginAllowThreads();
32394 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32395 wxPyEndAllowThreads(__tstate);
32396 if (PyErr_Occurred()) SWIG_fail;
32397 }
32398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32399 return resultobj;
32400 fail:
32401 return NULL;
32402 }
32403
32404
32405 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32406 PyObject *resultobj = 0;
32407 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32408 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32409 bool arg3 = (bool) false ;
32410 void *argp1 = 0 ;
32411 int res1 = 0 ;
32412 int res2 = 0 ;
32413 bool val3 ;
32414 int ecode3 = 0 ;
32415 PyObject * obj0 = 0 ;
32416 PyObject * obj1 = 0 ;
32417 PyObject * obj2 = 0 ;
32418 char * kwnames[] = {
32419 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32420 };
32421
32422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32424 if (!SWIG_IsOK(res1)) {
32425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32426 }
32427 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32428 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32429 if (!SWIG_IsOK(res2)) {
32430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32431 }
32432 if (obj2) {
32433 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32434 if (!SWIG_IsOK(ecode3)) {
32435 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32436 }
32437 arg3 = static_cast< bool >(val3);
32438 }
32439 {
32440 PyThreadState* __tstate = wxPyBeginAllowThreads();
32441 (arg1)->Add(arg2,arg3);
32442 wxPyEndAllowThreads(__tstate);
32443 if (PyErr_Occurred()) SWIG_fail;
32444 }
32445 resultobj = SWIG_Py_Void();
32446 return resultobj;
32447 fail:
32448 return NULL;
32449 }
32450
32451
32452 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32453 PyObject *resultobj = 0;
32454 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32455 SwigValueWrapper<wxDataFormat > result;
32456 void *argp1 = 0 ;
32457 int res1 = 0 ;
32458 PyObject *swig_obj[1] ;
32459
32460 if (!args) SWIG_fail;
32461 swig_obj[0] = args;
32462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32463 if (!SWIG_IsOK(res1)) {
32464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32465 }
32466 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32467 {
32468 PyThreadState* __tstate = wxPyBeginAllowThreads();
32469 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32470 wxPyEndAllowThreads(__tstate);
32471 if (PyErr_Occurred()) SWIG_fail;
32472 }
32473 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32474 return resultobj;
32475 fail:
32476 return NULL;
32477 }
32478
32479
32480 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32481 PyObject *obj;
32482 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32483 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32484 return SWIG_Py_Void();
32485 }
32486
32487 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32488 return SWIG_Python_InitShadowInstance(args);
32489 }
32490
32491 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32492 PyObject *resultobj = 0;
32493 wxString const &arg1_defvalue = wxPyEmptyString ;
32494 wxString *arg1 = (wxString *) &arg1_defvalue ;
32495 wxTextDataObject *result = 0 ;
32496 bool temp1 = false ;
32497 PyObject * obj0 = 0 ;
32498 char * kwnames[] = {
32499 (char *) "text", NULL
32500 };
32501
32502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32503 if (obj0) {
32504 {
32505 arg1 = wxString_in_helper(obj0);
32506 if (arg1 == NULL) SWIG_fail;
32507 temp1 = true;
32508 }
32509 }
32510 {
32511 PyThreadState* __tstate = wxPyBeginAllowThreads();
32512 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32513 wxPyEndAllowThreads(__tstate);
32514 if (PyErr_Occurred()) SWIG_fail;
32515 }
32516 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32517 {
32518 if (temp1)
32519 delete arg1;
32520 }
32521 return resultobj;
32522 fail:
32523 {
32524 if (temp1)
32525 delete arg1;
32526 }
32527 return NULL;
32528 }
32529
32530
32531 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32532 PyObject *resultobj = 0;
32533 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32534 size_t result;
32535 void *argp1 = 0 ;
32536 int res1 = 0 ;
32537 PyObject *swig_obj[1] ;
32538
32539 if (!args) SWIG_fail;
32540 swig_obj[0] = args;
32541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32542 if (!SWIG_IsOK(res1)) {
32543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32544 }
32545 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32546 {
32547 PyThreadState* __tstate = wxPyBeginAllowThreads();
32548 result = (size_t)(arg1)->GetTextLength();
32549 wxPyEndAllowThreads(__tstate);
32550 if (PyErr_Occurred()) SWIG_fail;
32551 }
32552 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32553 return resultobj;
32554 fail:
32555 return NULL;
32556 }
32557
32558
32559 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32560 PyObject *resultobj = 0;
32561 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32562 wxString result;
32563 void *argp1 = 0 ;
32564 int res1 = 0 ;
32565 PyObject *swig_obj[1] ;
32566
32567 if (!args) SWIG_fail;
32568 swig_obj[0] = args;
32569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32570 if (!SWIG_IsOK(res1)) {
32571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32572 }
32573 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32574 {
32575 PyThreadState* __tstate = wxPyBeginAllowThreads();
32576 result = (arg1)->GetText();
32577 wxPyEndAllowThreads(__tstate);
32578 if (PyErr_Occurred()) SWIG_fail;
32579 }
32580 {
32581 #if wxUSE_UNICODE
32582 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32583 #else
32584 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32585 #endif
32586 }
32587 return resultobj;
32588 fail:
32589 return NULL;
32590 }
32591
32592
32593 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32594 PyObject *resultobj = 0;
32595 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32596 wxString *arg2 = 0 ;
32597 void *argp1 = 0 ;
32598 int res1 = 0 ;
32599 bool temp2 = false ;
32600 PyObject * obj0 = 0 ;
32601 PyObject * obj1 = 0 ;
32602 char * kwnames[] = {
32603 (char *) "self",(char *) "text", NULL
32604 };
32605
32606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32608 if (!SWIG_IsOK(res1)) {
32609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32610 }
32611 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32612 {
32613 arg2 = wxString_in_helper(obj1);
32614 if (arg2 == NULL) SWIG_fail;
32615 temp2 = true;
32616 }
32617 {
32618 PyThreadState* __tstate = wxPyBeginAllowThreads();
32619 (arg1)->SetText((wxString const &)*arg2);
32620 wxPyEndAllowThreads(__tstate);
32621 if (PyErr_Occurred()) SWIG_fail;
32622 }
32623 resultobj = SWIG_Py_Void();
32624 {
32625 if (temp2)
32626 delete arg2;
32627 }
32628 return resultobj;
32629 fail:
32630 {
32631 if (temp2)
32632 delete arg2;
32633 }
32634 return NULL;
32635 }
32636
32637
32638 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32639 PyObject *obj;
32640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32641 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32642 return SWIG_Py_Void();
32643 }
32644
32645 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32646 return SWIG_Python_InitShadowInstance(args);
32647 }
32648
32649 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32650 PyObject *resultobj = 0;
32651 wxString const &arg1_defvalue = wxPyEmptyString ;
32652 wxString *arg1 = (wxString *) &arg1_defvalue ;
32653 wxPyTextDataObject *result = 0 ;
32654 bool temp1 = false ;
32655 PyObject * obj0 = 0 ;
32656 char * kwnames[] = {
32657 (char *) "text", NULL
32658 };
32659
32660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32661 if (obj0) {
32662 {
32663 arg1 = wxString_in_helper(obj0);
32664 if (arg1 == NULL) SWIG_fail;
32665 temp1 = true;
32666 }
32667 }
32668 {
32669 PyThreadState* __tstate = wxPyBeginAllowThreads();
32670 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32671 wxPyEndAllowThreads(__tstate);
32672 if (PyErr_Occurred()) SWIG_fail;
32673 }
32674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32675 {
32676 if (temp1)
32677 delete arg1;
32678 }
32679 return resultobj;
32680 fail:
32681 {
32682 if (temp1)
32683 delete arg1;
32684 }
32685 return NULL;
32686 }
32687
32688
32689 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32690 PyObject *resultobj = 0;
32691 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32692 PyObject *arg2 = (PyObject *) 0 ;
32693 PyObject *arg3 = (PyObject *) 0 ;
32694 void *argp1 = 0 ;
32695 int res1 = 0 ;
32696 PyObject * obj0 = 0 ;
32697 PyObject * obj1 = 0 ;
32698 PyObject * obj2 = 0 ;
32699 char * kwnames[] = {
32700 (char *) "self",(char *) "self",(char *) "_class", NULL
32701 };
32702
32703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32705 if (!SWIG_IsOK(res1)) {
32706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32707 }
32708 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32709 arg2 = obj1;
32710 arg3 = obj2;
32711 {
32712 PyThreadState* __tstate = wxPyBeginAllowThreads();
32713 (arg1)->_setCallbackInfo(arg2,arg3);
32714 wxPyEndAllowThreads(__tstate);
32715 if (PyErr_Occurred()) SWIG_fail;
32716 }
32717 resultobj = SWIG_Py_Void();
32718 return resultobj;
32719 fail:
32720 return NULL;
32721 }
32722
32723
32724 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32725 PyObject *obj;
32726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32727 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32728 return SWIG_Py_Void();
32729 }
32730
32731 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32732 return SWIG_Python_InitShadowInstance(args);
32733 }
32734
32735 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32736 PyObject *resultobj = 0;
32737 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32738 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32739 wxBitmapDataObject *result = 0 ;
32740 void *argp1 = 0 ;
32741 int res1 = 0 ;
32742 PyObject * obj0 = 0 ;
32743 char * kwnames[] = {
32744 (char *) "bitmap", NULL
32745 };
32746
32747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
32748 if (obj0) {
32749 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
32750 if (!SWIG_IsOK(res1)) {
32751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32752 }
32753 if (!argp1) {
32754 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32755 }
32756 arg1 = reinterpret_cast< wxBitmap * >(argp1);
32757 }
32758 {
32759 PyThreadState* __tstate = wxPyBeginAllowThreads();
32760 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
32761 wxPyEndAllowThreads(__tstate);
32762 if (PyErr_Occurred()) SWIG_fail;
32763 }
32764 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
32765 return resultobj;
32766 fail:
32767 return NULL;
32768 }
32769
32770
32771 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32772 PyObject *resultobj = 0;
32773 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32774 wxBitmap result;
32775 void *argp1 = 0 ;
32776 int res1 = 0 ;
32777 PyObject *swig_obj[1] ;
32778
32779 if (!args) SWIG_fail;
32780 swig_obj[0] = args;
32781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
32782 if (!SWIG_IsOK(res1)) {
32783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
32784 }
32785 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
32786 {
32787 PyThreadState* __tstate = wxPyBeginAllowThreads();
32788 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
32789 wxPyEndAllowThreads(__tstate);
32790 if (PyErr_Occurred()) SWIG_fail;
32791 }
32792 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
32793 return resultobj;
32794 fail:
32795 return NULL;
32796 }
32797
32798
32799 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32800 PyObject *resultobj = 0;
32801 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32802 wxBitmap *arg2 = 0 ;
32803 void *argp1 = 0 ;
32804 int res1 = 0 ;
32805 void *argp2 = 0 ;
32806 int res2 = 0 ;
32807 PyObject * obj0 = 0 ;
32808 PyObject * obj1 = 0 ;
32809 char * kwnames[] = {
32810 (char *) "self",(char *) "bitmap", NULL
32811 };
32812
32813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
32814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
32815 if (!SWIG_IsOK(res1)) {
32816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
32817 }
32818 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
32819 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
32820 if (!SWIG_IsOK(res2)) {
32821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
32822 }
32823 if (!argp2) {
32824 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
32825 }
32826 arg2 = reinterpret_cast< wxBitmap * >(argp2);
32827 {
32828 PyThreadState* __tstate = wxPyBeginAllowThreads();
32829 (arg1)->SetBitmap((wxBitmap const &)*arg2);
32830 wxPyEndAllowThreads(__tstate);
32831 if (PyErr_Occurred()) SWIG_fail;
32832 }
32833 resultobj = SWIG_Py_Void();
32834 return resultobj;
32835 fail:
32836 return NULL;
32837 }
32838
32839
32840 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32841 PyObject *obj;
32842 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32843 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
32844 return SWIG_Py_Void();
32845 }
32846
32847 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32848 return SWIG_Python_InitShadowInstance(args);
32849 }
32850
32851 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32852 PyObject *resultobj = 0;
32853 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32854 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32855 wxPyBitmapDataObject *result = 0 ;
32856 void *argp1 = 0 ;
32857 int res1 = 0 ;
32858 PyObject * obj0 = 0 ;
32859 char * kwnames[] = {
32860 (char *) "bitmap", NULL
32861 };
32862
32863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
32864 if (obj0) {
32865 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
32866 if (!SWIG_IsOK(res1)) {
32867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32868 }
32869 if (!argp1) {
32870 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32871 }
32872 arg1 = reinterpret_cast< wxBitmap * >(argp1);
32873 }
32874 {
32875 PyThreadState* __tstate = wxPyBeginAllowThreads();
32876 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
32877 wxPyEndAllowThreads(__tstate);
32878 if (PyErr_Occurred()) SWIG_fail;
32879 }
32880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
32881 return resultobj;
32882 fail:
32883 return NULL;
32884 }
32885
32886
32887 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32888 PyObject *resultobj = 0;
32889 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
32890 PyObject *arg2 = (PyObject *) 0 ;
32891 PyObject *arg3 = (PyObject *) 0 ;
32892 void *argp1 = 0 ;
32893 int res1 = 0 ;
32894 PyObject * obj0 = 0 ;
32895 PyObject * obj1 = 0 ;
32896 PyObject * obj2 = 0 ;
32897 char * kwnames[] = {
32898 (char *) "self",(char *) "self",(char *) "_class", NULL
32899 };
32900
32901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
32903 if (!SWIG_IsOK(res1)) {
32904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
32905 }
32906 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
32907 arg2 = obj1;
32908 arg3 = obj2;
32909 {
32910 PyThreadState* __tstate = wxPyBeginAllowThreads();
32911 (arg1)->_setCallbackInfo(arg2,arg3);
32912 wxPyEndAllowThreads(__tstate);
32913 if (PyErr_Occurred()) SWIG_fail;
32914 }
32915 resultobj = SWIG_Py_Void();
32916 return resultobj;
32917 fail:
32918 return NULL;
32919 }
32920
32921
32922 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32923 PyObject *obj;
32924 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32925 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
32926 return SWIG_Py_Void();
32927 }
32928
32929 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32930 return SWIG_Python_InitShadowInstance(args);
32931 }
32932
32933 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32934 PyObject *resultobj = 0;
32935 wxFileDataObject *result = 0 ;
32936
32937 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
32938 {
32939 PyThreadState* __tstate = wxPyBeginAllowThreads();
32940 result = (wxFileDataObject *)new wxFileDataObject();
32941 wxPyEndAllowThreads(__tstate);
32942 if (PyErr_Occurred()) SWIG_fail;
32943 }
32944 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
32945 return resultobj;
32946 fail:
32947 return NULL;
32948 }
32949
32950
32951 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32952 PyObject *resultobj = 0;
32953 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
32954 wxArrayString *result = 0 ;
32955 void *argp1 = 0 ;
32956 int res1 = 0 ;
32957 PyObject *swig_obj[1] ;
32958
32959 if (!args) SWIG_fail;
32960 swig_obj[0] = args;
32961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
32962 if (!SWIG_IsOK(res1)) {
32963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
32964 }
32965 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
32966 {
32967 PyThreadState* __tstate = wxPyBeginAllowThreads();
32968 {
32969 wxArrayString const &_result_ref = (arg1)->GetFilenames();
32970 result = (wxArrayString *) &_result_ref;
32971 }
32972 wxPyEndAllowThreads(__tstate);
32973 if (PyErr_Occurred()) SWIG_fail;
32974 }
32975 {
32976 resultobj = wxArrayString2PyList_helper(*result);
32977 }
32978 return resultobj;
32979 fail:
32980 return NULL;
32981 }
32982
32983
32984 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32985 PyObject *resultobj = 0;
32986 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
32987 wxString *arg2 = 0 ;
32988 void *argp1 = 0 ;
32989 int res1 = 0 ;
32990 bool temp2 = false ;
32991 PyObject * obj0 = 0 ;
32992 PyObject * obj1 = 0 ;
32993 char * kwnames[] = {
32994 (char *) "self",(char *) "filename", NULL
32995 };
32996
32997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
32998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
32999 if (!SWIG_IsOK(res1)) {
33000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33001 }
33002 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33003 {
33004 arg2 = wxString_in_helper(obj1);
33005 if (arg2 == NULL) SWIG_fail;
33006 temp2 = true;
33007 }
33008 {
33009 PyThreadState* __tstate = wxPyBeginAllowThreads();
33010 (arg1)->AddFile((wxString const &)*arg2);
33011 wxPyEndAllowThreads(__tstate);
33012 if (PyErr_Occurred()) SWIG_fail;
33013 }
33014 resultobj = SWIG_Py_Void();
33015 {
33016 if (temp2)
33017 delete arg2;
33018 }
33019 return resultobj;
33020 fail:
33021 {
33022 if (temp2)
33023 delete arg2;
33024 }
33025 return NULL;
33026 }
33027
33028
33029 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33030 PyObject *obj;
33031 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33032 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33033 return SWIG_Py_Void();
33034 }
33035
33036 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33037 return SWIG_Python_InitShadowInstance(args);
33038 }
33039
33040 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33041 PyObject *resultobj = 0;
33042 wxDataFormat *arg1 = 0 ;
33043 wxCustomDataObject *result = 0 ;
33044 void *argp1 = 0 ;
33045 int res1 = 0 ;
33046
33047 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33049 if (!SWIG_IsOK(res1)) {
33050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33051 }
33052 if (!argp1) {
33053 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33054 }
33055 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33056 {
33057 PyThreadState* __tstate = wxPyBeginAllowThreads();
33058 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33059 wxPyEndAllowThreads(__tstate);
33060 if (PyErr_Occurred()) SWIG_fail;
33061 }
33062 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33063 return resultobj;
33064 fail:
33065 return NULL;
33066 }
33067
33068
33069 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33070 PyObject *resultobj = 0;
33071 wxString *arg1 = 0 ;
33072 wxCustomDataObject *result = 0 ;
33073 bool temp1 = false ;
33074
33075 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33076 {
33077 arg1 = wxString_in_helper(swig_obj[0]);
33078 if (arg1 == NULL) SWIG_fail;
33079 temp1 = true;
33080 }
33081 {
33082 PyThreadState* __tstate = wxPyBeginAllowThreads();
33083 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33084 wxPyEndAllowThreads(__tstate);
33085 if (PyErr_Occurred()) SWIG_fail;
33086 }
33087 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33088 {
33089 if (temp1)
33090 delete arg1;
33091 }
33092 return resultobj;
33093 fail:
33094 {
33095 if (temp1)
33096 delete arg1;
33097 }
33098 return NULL;
33099 }
33100
33101
33102 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33103 PyObject *resultobj = 0;
33104 wxCustomDataObject *result = 0 ;
33105
33106 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33107 {
33108 PyThreadState* __tstate = wxPyBeginAllowThreads();
33109 result = (wxCustomDataObject *)new wxCustomDataObject();
33110 wxPyEndAllowThreads(__tstate);
33111 if (PyErr_Occurred()) SWIG_fail;
33112 }
33113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33114 return resultobj;
33115 fail:
33116 return NULL;
33117 }
33118
33119
33120 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33121 int argc;
33122 PyObject *argv[2];
33123
33124 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33125 --argc;
33126 if (argc == 0) {
33127 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33128 }
33129 if (argc == 1) {
33130 int _v = 0;
33131 {
33132 {
33133 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33134 }
33135 }
33136 if (!_v) goto check_2;
33137 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33138 }
33139 check_2:
33140
33141 if (argc == 1) {
33142 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33143 }
33144
33145 fail:
33146 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33147 return NULL;
33148 }
33149
33150
33151 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33152 PyObject *resultobj = 0;
33153 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33154 PyObject *arg2 = (PyObject *) 0 ;
33155 bool result;
33156 void *argp1 = 0 ;
33157 int res1 = 0 ;
33158 PyObject * obj0 = 0 ;
33159 PyObject * obj1 = 0 ;
33160 char * kwnames[] = {
33161 (char *) "self",(char *) "data", NULL
33162 };
33163
33164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33166 if (!SWIG_IsOK(res1)) {
33167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33168 }
33169 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33170 arg2 = obj1;
33171 {
33172 PyThreadState* __tstate = wxPyBeginAllowThreads();
33173 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33174 wxPyEndAllowThreads(__tstate);
33175 if (PyErr_Occurred()) SWIG_fail;
33176 }
33177 {
33178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33179 }
33180 return resultobj;
33181 fail:
33182 return NULL;
33183 }
33184
33185
33186 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33187 PyObject *resultobj = 0;
33188 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33189 size_t result;
33190 void *argp1 = 0 ;
33191 int res1 = 0 ;
33192 PyObject *swig_obj[1] ;
33193
33194 if (!args) SWIG_fail;
33195 swig_obj[0] = args;
33196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33197 if (!SWIG_IsOK(res1)) {
33198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33199 }
33200 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33201 {
33202 PyThreadState* __tstate = wxPyBeginAllowThreads();
33203 result = (size_t)(arg1)->GetSize();
33204 wxPyEndAllowThreads(__tstate);
33205 if (PyErr_Occurred()) SWIG_fail;
33206 }
33207 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33208 return resultobj;
33209 fail:
33210 return NULL;
33211 }
33212
33213
33214 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33215 PyObject *resultobj = 0;
33216 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33217 PyObject *result = 0 ;
33218 void *argp1 = 0 ;
33219 int res1 = 0 ;
33220 PyObject *swig_obj[1] ;
33221
33222 if (!args) SWIG_fail;
33223 swig_obj[0] = args;
33224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33225 if (!SWIG_IsOK(res1)) {
33226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33227 }
33228 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33229 {
33230 PyThreadState* __tstate = wxPyBeginAllowThreads();
33231 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33232 wxPyEndAllowThreads(__tstate);
33233 if (PyErr_Occurred()) SWIG_fail;
33234 }
33235 resultobj = result;
33236 return resultobj;
33237 fail:
33238 return NULL;
33239 }
33240
33241
33242 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33243 PyObject *obj;
33244 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33245 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33246 return SWIG_Py_Void();
33247 }
33248
33249 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33250 return SWIG_Python_InitShadowInstance(args);
33251 }
33252
33253 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33254 PyObject *resultobj = 0;
33255 wxString const &arg1_defvalue = wxPyEmptyString ;
33256 wxString *arg1 = (wxString *) &arg1_defvalue ;
33257 wxURLDataObject *result = 0 ;
33258 bool temp1 = false ;
33259 PyObject * obj0 = 0 ;
33260 char * kwnames[] = {
33261 (char *) "url", NULL
33262 };
33263
33264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33265 if (obj0) {
33266 {
33267 arg1 = wxString_in_helper(obj0);
33268 if (arg1 == NULL) SWIG_fail;
33269 temp1 = true;
33270 }
33271 }
33272 {
33273 PyThreadState* __tstate = wxPyBeginAllowThreads();
33274 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33275 wxPyEndAllowThreads(__tstate);
33276 if (PyErr_Occurred()) SWIG_fail;
33277 }
33278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33279 {
33280 if (temp1)
33281 delete arg1;
33282 }
33283 return resultobj;
33284 fail:
33285 {
33286 if (temp1)
33287 delete arg1;
33288 }
33289 return NULL;
33290 }
33291
33292
33293 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33294 PyObject *resultobj = 0;
33295 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33296 wxString result;
33297 void *argp1 = 0 ;
33298 int res1 = 0 ;
33299 PyObject *swig_obj[1] ;
33300
33301 if (!args) SWIG_fail;
33302 swig_obj[0] = args;
33303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33304 if (!SWIG_IsOK(res1)) {
33305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33306 }
33307 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33308 {
33309 PyThreadState* __tstate = wxPyBeginAllowThreads();
33310 result = (arg1)->GetURL();
33311 wxPyEndAllowThreads(__tstate);
33312 if (PyErr_Occurred()) SWIG_fail;
33313 }
33314 {
33315 #if wxUSE_UNICODE
33316 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33317 #else
33318 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33319 #endif
33320 }
33321 return resultobj;
33322 fail:
33323 return NULL;
33324 }
33325
33326
33327 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33328 PyObject *resultobj = 0;
33329 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33330 wxString *arg2 = 0 ;
33331 void *argp1 = 0 ;
33332 int res1 = 0 ;
33333 bool temp2 = false ;
33334 PyObject * obj0 = 0 ;
33335 PyObject * obj1 = 0 ;
33336 char * kwnames[] = {
33337 (char *) "self",(char *) "url", NULL
33338 };
33339
33340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33342 if (!SWIG_IsOK(res1)) {
33343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33344 }
33345 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33346 {
33347 arg2 = wxString_in_helper(obj1);
33348 if (arg2 == NULL) SWIG_fail;
33349 temp2 = true;
33350 }
33351 {
33352 PyThreadState* __tstate = wxPyBeginAllowThreads();
33353 (arg1)->SetURL((wxString const &)*arg2);
33354 wxPyEndAllowThreads(__tstate);
33355 if (PyErr_Occurred()) SWIG_fail;
33356 }
33357 resultobj = SWIG_Py_Void();
33358 {
33359 if (temp2)
33360 delete arg2;
33361 }
33362 return resultobj;
33363 fail:
33364 {
33365 if (temp2)
33366 delete arg2;
33367 }
33368 return NULL;
33369 }
33370
33371
33372 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33373 PyObject *obj;
33374 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33375 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33376 return SWIG_Py_Void();
33377 }
33378
33379 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33380 return SWIG_Python_InitShadowInstance(args);
33381 }
33382
33383 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33384 PyObject *resultobj = 0;
33385 wxMetafileDataObject *result = 0 ;
33386
33387 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33388 {
33389 PyThreadState* __tstate = wxPyBeginAllowThreads();
33390 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33391 wxPyEndAllowThreads(__tstate);
33392 if (PyErr_Occurred()) SWIG_fail;
33393 }
33394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33395 return resultobj;
33396 fail:
33397 return NULL;
33398 }
33399
33400
33401 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33402 PyObject *resultobj = 0;
33403 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33404 wxMetafile *arg2 = 0 ;
33405 void *argp1 = 0 ;
33406 int res1 = 0 ;
33407 void *argp2 = 0 ;
33408 int res2 = 0 ;
33409 PyObject * obj0 = 0 ;
33410 PyObject * obj1 = 0 ;
33411 char * kwnames[] = {
33412 (char *) "self",(char *) "metafile", NULL
33413 };
33414
33415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
33416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33417 if (!SWIG_IsOK(res1)) {
33418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
33419 }
33420 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33421 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
33422 if (!SWIG_IsOK(res2)) {
33423 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33424 }
33425 if (!argp2) {
33426 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33427 }
33428 arg2 = reinterpret_cast< wxMetafile * >(argp2);
33429 {
33430 PyThreadState* __tstate = wxPyBeginAllowThreads();
33431 (arg1)->SetMetafile((wxMetafile const &)*arg2);
33432 wxPyEndAllowThreads(__tstate);
33433 if (PyErr_Occurred()) SWIG_fail;
33434 }
33435 resultobj = SWIG_Py_Void();
33436 return resultobj;
33437 fail:
33438 return NULL;
33439 }
33440
33441
33442 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33443 PyObject *resultobj = 0;
33444 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33445 wxMetafile result;
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_wxMetafileDataObject, 0 | 0 );
33453 if (!SWIG_IsOK(res1)) {
33454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
33455 }
33456 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33457 {
33458 PyThreadState* __tstate = wxPyBeginAllowThreads();
33459 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
33460 wxPyEndAllowThreads(__tstate);
33461 if (PyErr_Occurred()) SWIG_fail;
33462 }
33463 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
33464 return resultobj;
33465 fail:
33466 return NULL;
33467 }
33468
33469
33470 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33471 PyObject *obj;
33472 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33473 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33474 return SWIG_Py_Void();
33475 }
33476
33477 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33478 return SWIG_Python_InitShadowInstance(args);
33479 }
33480
33481 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33482 PyObject *resultobj = 0;
33483 wxDragResult arg1 ;
33484 bool result;
33485 int val1 ;
33486 int ecode1 = 0 ;
33487 PyObject * obj0 = 0 ;
33488 char * kwnames[] = {
33489 (char *) "res", NULL
33490 };
33491
33492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33493 ecode1 = SWIG_AsVal_int(obj0, &val1);
33494 if (!SWIG_IsOK(ecode1)) {
33495 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33496 }
33497 arg1 = static_cast< wxDragResult >(val1);
33498 {
33499 PyThreadState* __tstate = wxPyBeginAllowThreads();
33500 result = (bool)wxIsDragResultOk(arg1);
33501 wxPyEndAllowThreads(__tstate);
33502 if (PyErr_Occurred()) SWIG_fail;
33503 }
33504 {
33505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33506 }
33507 return resultobj;
33508 fail:
33509 return NULL;
33510 }
33511
33512
33513 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33514 PyObject *resultobj = 0;
33515 wxWindow *arg1 = (wxWindow *) 0 ;
33516 wxCursor const &arg2_defvalue = wxNullCursor ;
33517 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
33518 wxCursor const &arg3_defvalue = wxNullCursor ;
33519 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
33520 wxCursor const &arg4_defvalue = wxNullCursor ;
33521 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
33522 wxPyDropSource *result = 0 ;
33523 void *argp1 = 0 ;
33524 int res1 = 0 ;
33525 void *argp2 = 0 ;
33526 int res2 = 0 ;
33527 void *argp3 = 0 ;
33528 int res3 = 0 ;
33529 void *argp4 = 0 ;
33530 int res4 = 0 ;
33531 PyObject * obj0 = 0 ;
33532 PyObject * obj1 = 0 ;
33533 PyObject * obj2 = 0 ;
33534 PyObject * obj3 = 0 ;
33535 char * kwnames[] = {
33536 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33537 };
33538
33539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33541 if (!SWIG_IsOK(res1)) {
33542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33543 }
33544 arg1 = reinterpret_cast< wxWindow * >(argp1);
33545 if (obj1) {
33546 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
33547 if (!SWIG_IsOK(res2)) {
33548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33549 }
33550 if (!argp2) {
33551 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33552 }
33553 arg2 = reinterpret_cast< wxCursor * >(argp2);
33554 }
33555 if (obj2) {
33556 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33557 if (!SWIG_IsOK(res3)) {
33558 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33559 }
33560 if (!argp3) {
33561 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33562 }
33563 arg3 = reinterpret_cast< wxCursor * >(argp3);
33564 }
33565 if (obj3) {
33566 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
33567 if (!SWIG_IsOK(res4)) {
33568 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33569 }
33570 if (!argp4) {
33571 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33572 }
33573 arg4 = reinterpret_cast< wxCursor * >(argp4);
33574 }
33575 {
33576 PyThreadState* __tstate = wxPyBeginAllowThreads();
33577 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
33578 wxPyEndAllowThreads(__tstate);
33579 if (PyErr_Occurred()) SWIG_fail;
33580 }
33581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33582 return resultobj;
33583 fail:
33584 return NULL;
33585 }
33586
33587
33588 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33589 PyObject *resultobj = 0;
33590 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33591 PyObject *arg2 = (PyObject *) 0 ;
33592 PyObject *arg3 = (PyObject *) 0 ;
33593 int arg4 ;
33594 void *argp1 = 0 ;
33595 int res1 = 0 ;
33596 int val4 ;
33597 int ecode4 = 0 ;
33598 PyObject * obj0 = 0 ;
33599 PyObject * obj1 = 0 ;
33600 PyObject * obj2 = 0 ;
33601 PyObject * obj3 = 0 ;
33602 char * kwnames[] = {
33603 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33604 };
33605
33606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33608 if (!SWIG_IsOK(res1)) {
33609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33610 }
33611 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33612 arg2 = obj1;
33613 arg3 = obj2;
33614 ecode4 = SWIG_AsVal_int(obj3, &val4);
33615 if (!SWIG_IsOK(ecode4)) {
33616 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33617 }
33618 arg4 = static_cast< int >(val4);
33619 {
33620 PyThreadState* __tstate = wxPyBeginAllowThreads();
33621 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33622 wxPyEndAllowThreads(__tstate);
33623 if (PyErr_Occurred()) SWIG_fail;
33624 }
33625 resultobj = SWIG_Py_Void();
33626 return resultobj;
33627 fail:
33628 return NULL;
33629 }
33630
33631
33632 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33633 PyObject *resultobj = 0;
33634 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33635 void *argp1 = 0 ;
33636 int res1 = 0 ;
33637 PyObject *swig_obj[1] ;
33638
33639 if (!args) SWIG_fail;
33640 swig_obj[0] = args;
33641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33642 if (!SWIG_IsOK(res1)) {
33643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33644 }
33645 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33646 {
33647 PyThreadState* __tstate = wxPyBeginAllowThreads();
33648 delete arg1;
33649
33650 wxPyEndAllowThreads(__tstate);
33651 if (PyErr_Occurred()) SWIG_fail;
33652 }
33653 resultobj = SWIG_Py_Void();
33654 return resultobj;
33655 fail:
33656 return NULL;
33657 }
33658
33659
33660 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33661 PyObject *resultobj = 0;
33662 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33663 wxDataObject *arg2 = 0 ;
33664 void *argp1 = 0 ;
33665 int res1 = 0 ;
33666 void *argp2 = 0 ;
33667 int res2 = 0 ;
33668 PyObject * obj0 = 0 ;
33669 PyObject * obj1 = 0 ;
33670 char * kwnames[] = {
33671 (char *) "self",(char *) "data", NULL
33672 };
33673
33674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33676 if (!SWIG_IsOK(res1)) {
33677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33678 }
33679 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33680 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33681 if (!SWIG_IsOK(res2)) {
33682 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33683 }
33684 if (!argp2) {
33685 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33686 }
33687 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33688 {
33689 PyThreadState* __tstate = wxPyBeginAllowThreads();
33690 (arg1)->SetData(*arg2);
33691 wxPyEndAllowThreads(__tstate);
33692 if (PyErr_Occurred()) SWIG_fail;
33693 }
33694 resultobj = SWIG_Py_Void();
33695 return resultobj;
33696 fail:
33697 return NULL;
33698 }
33699
33700
33701 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33702 PyObject *resultobj = 0;
33703 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33704 wxDataObject *result = 0 ;
33705 void *argp1 = 0 ;
33706 int res1 = 0 ;
33707 PyObject *swig_obj[1] ;
33708
33709 if (!args) SWIG_fail;
33710 swig_obj[0] = args;
33711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33712 if (!SWIG_IsOK(res1)) {
33713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33714 }
33715 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33716 {
33717 PyThreadState* __tstate = wxPyBeginAllowThreads();
33718 result = (wxDataObject *)(arg1)->GetDataObject();
33719 wxPyEndAllowThreads(__tstate);
33720 if (PyErr_Occurred()) SWIG_fail;
33721 }
33722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33723 return resultobj;
33724 fail:
33725 return NULL;
33726 }
33727
33728
33729 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33730 PyObject *resultobj = 0;
33731 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33732 wxDragResult arg2 ;
33733 wxCursor *arg3 = 0 ;
33734 void *argp1 = 0 ;
33735 int res1 = 0 ;
33736 int val2 ;
33737 int ecode2 = 0 ;
33738 void *argp3 = 0 ;
33739 int res3 = 0 ;
33740 PyObject * obj0 = 0 ;
33741 PyObject * obj1 = 0 ;
33742 PyObject * obj2 = 0 ;
33743 char * kwnames[] = {
33744 (char *) "self",(char *) "res",(char *) "cursor", NULL
33745 };
33746
33747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33749 if (!SWIG_IsOK(res1)) {
33750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33751 }
33752 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33753 ecode2 = SWIG_AsVal_int(obj1, &val2);
33754 if (!SWIG_IsOK(ecode2)) {
33755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
33756 }
33757 arg2 = static_cast< wxDragResult >(val2);
33758 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33759 if (!SWIG_IsOK(res3)) {
33760 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33761 }
33762 if (!argp3) {
33763 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33764 }
33765 arg3 = reinterpret_cast< wxCursor * >(argp3);
33766 {
33767 PyThreadState* __tstate = wxPyBeginAllowThreads();
33768 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
33769 wxPyEndAllowThreads(__tstate);
33770 if (PyErr_Occurred()) SWIG_fail;
33771 }
33772 resultobj = SWIG_Py_Void();
33773 return resultobj;
33774 fail:
33775 return NULL;
33776 }
33777
33778
33779 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33780 PyObject *resultobj = 0;
33781 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33782 int arg2 = (int) wxDrag_CopyOnly ;
33783 wxDragResult result;
33784 void *argp1 = 0 ;
33785 int res1 = 0 ;
33786 int val2 ;
33787 int ecode2 = 0 ;
33788 PyObject * obj0 = 0 ;
33789 PyObject * obj1 = 0 ;
33790 char * kwnames[] = {
33791 (char *) "self",(char *) "flags", NULL
33792 };
33793
33794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
33795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33796 if (!SWIG_IsOK(res1)) {
33797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33798 }
33799 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33800 if (obj1) {
33801 ecode2 = SWIG_AsVal_int(obj1, &val2);
33802 if (!SWIG_IsOK(ecode2)) {
33803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
33804 }
33805 arg2 = static_cast< int >(val2);
33806 }
33807 {
33808 PyThreadState* __tstate = wxPyBeginAllowThreads();
33809 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
33810 wxPyEndAllowThreads(__tstate);
33811 if (PyErr_Occurred()) SWIG_fail;
33812 }
33813 resultobj = SWIG_From_int(static_cast< int >(result));
33814 return resultobj;
33815 fail:
33816 return NULL;
33817 }
33818
33819
33820 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33821 PyObject *resultobj = 0;
33822 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33823 wxDragResult arg2 ;
33824 bool result;
33825 void *argp1 = 0 ;
33826 int res1 = 0 ;
33827 int val2 ;
33828 int ecode2 = 0 ;
33829 PyObject * obj0 = 0 ;
33830 PyObject * obj1 = 0 ;
33831 char * kwnames[] = {
33832 (char *) "self",(char *) "effect", NULL
33833 };
33834
33835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
33836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33837 if (!SWIG_IsOK(res1)) {
33838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33839 }
33840 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33841 ecode2 = SWIG_AsVal_int(obj1, &val2);
33842 if (!SWIG_IsOK(ecode2)) {
33843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
33844 }
33845 arg2 = static_cast< wxDragResult >(val2);
33846 {
33847 PyThreadState* __tstate = wxPyBeginAllowThreads();
33848 result = (bool)(arg1)->GiveFeedback(arg2);
33849 wxPyEndAllowThreads(__tstate);
33850 if (PyErr_Occurred()) SWIG_fail;
33851 }
33852 {
33853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33854 }
33855 return resultobj;
33856 fail:
33857 return NULL;
33858 }
33859
33860
33861 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33862 PyObject *obj;
33863 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33864 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
33865 return SWIG_Py_Void();
33866 }
33867
33868 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33869 return SWIG_Python_InitShadowInstance(args);
33870 }
33871
33872 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33873 PyObject *resultobj = 0;
33874 wxDataObject *arg1 = (wxDataObject *) NULL ;
33875 wxPyDropTarget *result = 0 ;
33876 int res1 = 0 ;
33877 PyObject * obj0 = 0 ;
33878 char * kwnames[] = {
33879 (char *) "dataObject", NULL
33880 };
33881
33882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
33883 if (obj0) {
33884 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
33885 if (!SWIG_IsOK(res1)) {
33886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
33887 }
33888 }
33889 {
33890 PyThreadState* __tstate = wxPyBeginAllowThreads();
33891 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
33892 wxPyEndAllowThreads(__tstate);
33893 if (PyErr_Occurred()) SWIG_fail;
33894 }
33895 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
33896 return resultobj;
33897 fail:
33898 return NULL;
33899 }
33900
33901
33902 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33903 PyObject *resultobj = 0;
33904 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33905 PyObject *arg2 = (PyObject *) 0 ;
33906 PyObject *arg3 = (PyObject *) 0 ;
33907 void *argp1 = 0 ;
33908 int res1 = 0 ;
33909 PyObject * obj0 = 0 ;
33910 PyObject * obj1 = 0 ;
33911 PyObject * obj2 = 0 ;
33912 char * kwnames[] = {
33913 (char *) "self",(char *) "self",(char *) "_class", NULL
33914 };
33915
33916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33918 if (!SWIG_IsOK(res1)) {
33919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33920 }
33921 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33922 arg2 = obj1;
33923 arg3 = obj2;
33924 {
33925 PyThreadState* __tstate = wxPyBeginAllowThreads();
33926 (arg1)->_setCallbackInfo(arg2,arg3);
33927 wxPyEndAllowThreads(__tstate);
33928 if (PyErr_Occurred()) SWIG_fail;
33929 }
33930 resultobj = SWIG_Py_Void();
33931 return resultobj;
33932 fail:
33933 return NULL;
33934 }
33935
33936
33937 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33938 PyObject *resultobj = 0;
33939 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33940 void *argp1 = 0 ;
33941 int res1 = 0 ;
33942 PyObject *swig_obj[1] ;
33943
33944 if (!args) SWIG_fail;
33945 swig_obj[0] = args;
33946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
33947 if (!SWIG_IsOK(res1)) {
33948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33949 }
33950 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33951 {
33952 PyThreadState* __tstate = wxPyBeginAllowThreads();
33953 delete arg1;
33954
33955 wxPyEndAllowThreads(__tstate);
33956 if (PyErr_Occurred()) SWIG_fail;
33957 }
33958 resultobj = SWIG_Py_Void();
33959 return resultobj;
33960 fail:
33961 return NULL;
33962 }
33963
33964
33965 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33966 PyObject *resultobj = 0;
33967 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33968 wxDataObject *result = 0 ;
33969 void *argp1 = 0 ;
33970 int res1 = 0 ;
33971 PyObject *swig_obj[1] ;
33972
33973 if (!args) SWIG_fail;
33974 swig_obj[0] = args;
33975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33976 if (!SWIG_IsOK(res1)) {
33977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33978 }
33979 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33980 {
33981 PyThreadState* __tstate = wxPyBeginAllowThreads();
33982 result = (wxDataObject *)(arg1)->GetDataObject();
33983 wxPyEndAllowThreads(__tstate);
33984 if (PyErr_Occurred()) SWIG_fail;
33985 }
33986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33987 return resultobj;
33988 fail:
33989 return NULL;
33990 }
33991
33992
33993 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33994 PyObject *resultobj = 0;
33995 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33996 wxDataObject *arg2 = (wxDataObject *) 0 ;
33997 void *argp1 = 0 ;
33998 int res1 = 0 ;
33999 int res2 = 0 ;
34000 PyObject * obj0 = 0 ;
34001 PyObject * obj1 = 0 ;
34002 char * kwnames[] = {
34003 (char *) "self",(char *) "dataObject", NULL
34004 };
34005
34006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34008 if (!SWIG_IsOK(res1)) {
34009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34010 }
34011 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34012 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34013 if (!SWIG_IsOK(res2)) {
34014 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34015 }
34016 {
34017 PyThreadState* __tstate = wxPyBeginAllowThreads();
34018 (arg1)->SetDataObject(arg2);
34019 wxPyEndAllowThreads(__tstate);
34020 if (PyErr_Occurred()) SWIG_fail;
34021 }
34022 resultobj = SWIG_Py_Void();
34023 return resultobj;
34024 fail:
34025 return NULL;
34026 }
34027
34028
34029 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34030 PyObject *resultobj = 0;
34031 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34032 int arg2 ;
34033 int arg3 ;
34034 wxDragResult arg4 ;
34035 wxDragResult result;
34036 void *argp1 = 0 ;
34037 int res1 = 0 ;
34038 int val2 ;
34039 int ecode2 = 0 ;
34040 int val3 ;
34041 int ecode3 = 0 ;
34042 int val4 ;
34043 int ecode4 = 0 ;
34044 PyObject * obj0 = 0 ;
34045 PyObject * obj1 = 0 ;
34046 PyObject * obj2 = 0 ;
34047 PyObject * obj3 = 0 ;
34048 char * kwnames[] = {
34049 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34050 };
34051
34052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34054 if (!SWIG_IsOK(res1)) {
34055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34056 }
34057 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34058 ecode2 = SWIG_AsVal_int(obj1, &val2);
34059 if (!SWIG_IsOK(ecode2)) {
34060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34061 }
34062 arg2 = static_cast< int >(val2);
34063 ecode3 = SWIG_AsVal_int(obj2, &val3);
34064 if (!SWIG_IsOK(ecode3)) {
34065 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34066 }
34067 arg3 = static_cast< int >(val3);
34068 ecode4 = SWIG_AsVal_int(obj3, &val4);
34069 if (!SWIG_IsOK(ecode4)) {
34070 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34071 }
34072 arg4 = static_cast< wxDragResult >(val4);
34073 {
34074 PyThreadState* __tstate = wxPyBeginAllowThreads();
34075 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34076 wxPyEndAllowThreads(__tstate);
34077 if (PyErr_Occurred()) SWIG_fail;
34078 }
34079 resultobj = SWIG_From_int(static_cast< int >(result));
34080 return resultobj;
34081 fail:
34082 return NULL;
34083 }
34084
34085
34086 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34087 PyObject *resultobj = 0;
34088 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34089 int arg2 ;
34090 int arg3 ;
34091 wxDragResult arg4 ;
34092 wxDragResult result;
34093 void *argp1 = 0 ;
34094 int res1 = 0 ;
34095 int val2 ;
34096 int ecode2 = 0 ;
34097 int val3 ;
34098 int ecode3 = 0 ;
34099 int val4 ;
34100 int ecode4 = 0 ;
34101 PyObject * obj0 = 0 ;
34102 PyObject * obj1 = 0 ;
34103 PyObject * obj2 = 0 ;
34104 PyObject * obj3 = 0 ;
34105 char * kwnames[] = {
34106 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34107 };
34108
34109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34111 if (!SWIG_IsOK(res1)) {
34112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34113 }
34114 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34115 ecode2 = SWIG_AsVal_int(obj1, &val2);
34116 if (!SWIG_IsOK(ecode2)) {
34117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34118 }
34119 arg2 = static_cast< int >(val2);
34120 ecode3 = SWIG_AsVal_int(obj2, &val3);
34121 if (!SWIG_IsOK(ecode3)) {
34122 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34123 }
34124 arg3 = static_cast< int >(val3);
34125 ecode4 = SWIG_AsVal_int(obj3, &val4);
34126 if (!SWIG_IsOK(ecode4)) {
34127 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34128 }
34129 arg4 = static_cast< wxDragResult >(val4);
34130 {
34131 PyThreadState* __tstate = wxPyBeginAllowThreads();
34132 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34133 wxPyEndAllowThreads(__tstate);
34134 if (PyErr_Occurred()) SWIG_fail;
34135 }
34136 resultobj = SWIG_From_int(static_cast< int >(result));
34137 return resultobj;
34138 fail:
34139 return NULL;
34140 }
34141
34142
34143 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34144 PyObject *resultobj = 0;
34145 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34146 void *argp1 = 0 ;
34147 int res1 = 0 ;
34148 PyObject *swig_obj[1] ;
34149
34150 if (!args) SWIG_fail;
34151 swig_obj[0] = args;
34152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34153 if (!SWIG_IsOK(res1)) {
34154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34155 }
34156 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34157 {
34158 PyThreadState* __tstate = wxPyBeginAllowThreads();
34159 (arg1)->OnLeave();
34160 wxPyEndAllowThreads(__tstate);
34161 if (PyErr_Occurred()) SWIG_fail;
34162 }
34163 resultobj = SWIG_Py_Void();
34164 return resultobj;
34165 fail:
34166 return NULL;
34167 }
34168
34169
34170 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34171 PyObject *resultobj = 0;
34172 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34173 int arg2 ;
34174 int arg3 ;
34175 bool result;
34176 void *argp1 = 0 ;
34177 int res1 = 0 ;
34178 int val2 ;
34179 int ecode2 = 0 ;
34180 int val3 ;
34181 int ecode3 = 0 ;
34182 PyObject * obj0 = 0 ;
34183 PyObject * obj1 = 0 ;
34184 PyObject * obj2 = 0 ;
34185 char * kwnames[] = {
34186 (char *) "self",(char *) "x",(char *) "y", NULL
34187 };
34188
34189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34191 if (!SWIG_IsOK(res1)) {
34192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34193 }
34194 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34195 ecode2 = SWIG_AsVal_int(obj1, &val2);
34196 if (!SWIG_IsOK(ecode2)) {
34197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34198 }
34199 arg2 = static_cast< int >(val2);
34200 ecode3 = SWIG_AsVal_int(obj2, &val3);
34201 if (!SWIG_IsOK(ecode3)) {
34202 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34203 }
34204 arg3 = static_cast< int >(val3);
34205 {
34206 PyThreadState* __tstate = wxPyBeginAllowThreads();
34207 result = (bool)(arg1)->OnDrop(arg2,arg3);
34208 wxPyEndAllowThreads(__tstate);
34209 if (PyErr_Occurred()) SWIG_fail;
34210 }
34211 {
34212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34213 }
34214 return resultobj;
34215 fail:
34216 return NULL;
34217 }
34218
34219
34220 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34221 PyObject *resultobj = 0;
34222 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34223 bool result;
34224 void *argp1 = 0 ;
34225 int res1 = 0 ;
34226 PyObject *swig_obj[1] ;
34227
34228 if (!args) SWIG_fail;
34229 swig_obj[0] = args;
34230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34231 if (!SWIG_IsOK(res1)) {
34232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34233 }
34234 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34235 {
34236 PyThreadState* __tstate = wxPyBeginAllowThreads();
34237 result = (bool)(arg1)->GetData();
34238 wxPyEndAllowThreads(__tstate);
34239 if (PyErr_Occurred()) SWIG_fail;
34240 }
34241 {
34242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34243 }
34244 return resultobj;
34245 fail:
34246 return NULL;
34247 }
34248
34249
34250 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34251 PyObject *resultobj = 0;
34252 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34253 wxDragResult arg2 ;
34254 void *argp1 = 0 ;
34255 int res1 = 0 ;
34256 int val2 ;
34257 int ecode2 = 0 ;
34258 PyObject * obj0 = 0 ;
34259 PyObject * obj1 = 0 ;
34260 char * kwnames[] = {
34261 (char *) "self",(char *) "action", NULL
34262 };
34263
34264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34266 if (!SWIG_IsOK(res1)) {
34267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34268 }
34269 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34270 ecode2 = SWIG_AsVal_int(obj1, &val2);
34271 if (!SWIG_IsOK(ecode2)) {
34272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34273 }
34274 arg2 = static_cast< wxDragResult >(val2);
34275 {
34276 PyThreadState* __tstate = wxPyBeginAllowThreads();
34277 (arg1)->SetDefaultAction(arg2);
34278 wxPyEndAllowThreads(__tstate);
34279 if (PyErr_Occurred()) SWIG_fail;
34280 }
34281 resultobj = SWIG_Py_Void();
34282 return resultobj;
34283 fail:
34284 return NULL;
34285 }
34286
34287
34288 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34289 PyObject *resultobj = 0;
34290 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34291 wxDragResult result;
34292 void *argp1 = 0 ;
34293 int res1 = 0 ;
34294 PyObject *swig_obj[1] ;
34295
34296 if (!args) SWIG_fail;
34297 swig_obj[0] = args;
34298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34299 if (!SWIG_IsOK(res1)) {
34300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34301 }
34302 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34303 {
34304 PyThreadState* __tstate = wxPyBeginAllowThreads();
34305 result = (wxDragResult)(arg1)->GetDefaultAction();
34306 wxPyEndAllowThreads(__tstate);
34307 if (PyErr_Occurred()) SWIG_fail;
34308 }
34309 resultobj = SWIG_From_int(static_cast< int >(result));
34310 return resultobj;
34311 fail:
34312 return NULL;
34313 }
34314
34315
34316 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34317 PyObject *obj;
34318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34319 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34320 return SWIG_Py_Void();
34321 }
34322
34323 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34324 return SWIG_Python_InitShadowInstance(args);
34325 }
34326
34327 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34328 PyObject *resultobj = 0;
34329 wxPyTextDropTarget *result = 0 ;
34330
34331 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34332 {
34333 PyThreadState* __tstate = wxPyBeginAllowThreads();
34334 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34335 wxPyEndAllowThreads(__tstate);
34336 if (PyErr_Occurred()) SWIG_fail;
34337 }
34338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34339 return resultobj;
34340 fail:
34341 return NULL;
34342 }
34343
34344
34345 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34346 PyObject *resultobj = 0;
34347 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34348 PyObject *arg2 = (PyObject *) 0 ;
34349 PyObject *arg3 = (PyObject *) 0 ;
34350 void *argp1 = 0 ;
34351 int res1 = 0 ;
34352 PyObject * obj0 = 0 ;
34353 PyObject * obj1 = 0 ;
34354 PyObject * obj2 = 0 ;
34355 char * kwnames[] = {
34356 (char *) "self",(char *) "self",(char *) "_class", NULL
34357 };
34358
34359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34361 if (!SWIG_IsOK(res1)) {
34362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34363 }
34364 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34365 arg2 = obj1;
34366 arg3 = obj2;
34367 {
34368 PyThreadState* __tstate = wxPyBeginAllowThreads();
34369 (arg1)->_setCallbackInfo(arg2,arg3);
34370 wxPyEndAllowThreads(__tstate);
34371 if (PyErr_Occurred()) SWIG_fail;
34372 }
34373 resultobj = SWIG_Py_Void();
34374 return resultobj;
34375 fail:
34376 return NULL;
34377 }
34378
34379
34380 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34381 PyObject *resultobj = 0;
34382 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34383 int arg2 ;
34384 int arg3 ;
34385 wxString *arg4 = 0 ;
34386 bool result;
34387 void *argp1 = 0 ;
34388 int res1 = 0 ;
34389 int val2 ;
34390 int ecode2 = 0 ;
34391 int val3 ;
34392 int ecode3 = 0 ;
34393 bool temp4 = false ;
34394 PyObject * obj0 = 0 ;
34395 PyObject * obj1 = 0 ;
34396 PyObject * obj2 = 0 ;
34397 PyObject * obj3 = 0 ;
34398 char * kwnames[] = {
34399 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34400 };
34401
34402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34404 if (!SWIG_IsOK(res1)) {
34405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34406 }
34407 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34408 ecode2 = SWIG_AsVal_int(obj1, &val2);
34409 if (!SWIG_IsOK(ecode2)) {
34410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34411 }
34412 arg2 = static_cast< int >(val2);
34413 ecode3 = SWIG_AsVal_int(obj2, &val3);
34414 if (!SWIG_IsOK(ecode3)) {
34415 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34416 }
34417 arg3 = static_cast< int >(val3);
34418 {
34419 arg4 = wxString_in_helper(obj3);
34420 if (arg4 == NULL) SWIG_fail;
34421 temp4 = true;
34422 }
34423 {
34424 PyThreadState* __tstate = wxPyBeginAllowThreads();
34425 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34426 wxPyEndAllowThreads(__tstate);
34427 if (PyErr_Occurred()) SWIG_fail;
34428 }
34429 {
34430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34431 }
34432 {
34433 if (temp4)
34434 delete arg4;
34435 }
34436 return resultobj;
34437 fail:
34438 {
34439 if (temp4)
34440 delete arg4;
34441 }
34442 return NULL;
34443 }
34444
34445
34446 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34447 PyObject *resultobj = 0;
34448 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34449 int arg2 ;
34450 int arg3 ;
34451 wxDragResult arg4 ;
34452 wxDragResult result;
34453 void *argp1 = 0 ;
34454 int res1 = 0 ;
34455 int val2 ;
34456 int ecode2 = 0 ;
34457 int val3 ;
34458 int ecode3 = 0 ;
34459 int val4 ;
34460 int ecode4 = 0 ;
34461 PyObject * obj0 = 0 ;
34462 PyObject * obj1 = 0 ;
34463 PyObject * obj2 = 0 ;
34464 PyObject * obj3 = 0 ;
34465 char * kwnames[] = {
34466 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34467 };
34468
34469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34471 if (!SWIG_IsOK(res1)) {
34472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34473 }
34474 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34475 ecode2 = SWIG_AsVal_int(obj1, &val2);
34476 if (!SWIG_IsOK(ecode2)) {
34477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34478 }
34479 arg2 = static_cast< int >(val2);
34480 ecode3 = SWIG_AsVal_int(obj2, &val3);
34481 if (!SWIG_IsOK(ecode3)) {
34482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34483 }
34484 arg3 = static_cast< int >(val3);
34485 ecode4 = SWIG_AsVal_int(obj3, &val4);
34486 if (!SWIG_IsOK(ecode4)) {
34487 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34488 }
34489 arg4 = static_cast< wxDragResult >(val4);
34490 {
34491 PyThreadState* __tstate = wxPyBeginAllowThreads();
34492 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34493 wxPyEndAllowThreads(__tstate);
34494 if (PyErr_Occurred()) SWIG_fail;
34495 }
34496 resultobj = SWIG_From_int(static_cast< int >(result));
34497 return resultobj;
34498 fail:
34499 return NULL;
34500 }
34501
34502
34503 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34504 PyObject *resultobj = 0;
34505 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34506 int arg2 ;
34507 int arg3 ;
34508 wxDragResult arg4 ;
34509 wxDragResult result;
34510 void *argp1 = 0 ;
34511 int res1 = 0 ;
34512 int val2 ;
34513 int ecode2 = 0 ;
34514 int val3 ;
34515 int ecode3 = 0 ;
34516 int val4 ;
34517 int ecode4 = 0 ;
34518 PyObject * obj0 = 0 ;
34519 PyObject * obj1 = 0 ;
34520 PyObject * obj2 = 0 ;
34521 PyObject * obj3 = 0 ;
34522 char * kwnames[] = {
34523 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34524 };
34525
34526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34528 if (!SWIG_IsOK(res1)) {
34529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34530 }
34531 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34532 ecode2 = SWIG_AsVal_int(obj1, &val2);
34533 if (!SWIG_IsOK(ecode2)) {
34534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34535 }
34536 arg2 = static_cast< int >(val2);
34537 ecode3 = SWIG_AsVal_int(obj2, &val3);
34538 if (!SWIG_IsOK(ecode3)) {
34539 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34540 }
34541 arg3 = static_cast< int >(val3);
34542 ecode4 = SWIG_AsVal_int(obj3, &val4);
34543 if (!SWIG_IsOK(ecode4)) {
34544 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34545 }
34546 arg4 = static_cast< wxDragResult >(val4);
34547 {
34548 PyThreadState* __tstate = wxPyBeginAllowThreads();
34549 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34550 wxPyEndAllowThreads(__tstate);
34551 if (PyErr_Occurred()) SWIG_fail;
34552 }
34553 resultobj = SWIG_From_int(static_cast< int >(result));
34554 return resultobj;
34555 fail:
34556 return NULL;
34557 }
34558
34559
34560 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34561 PyObject *resultobj = 0;
34562 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34563 void *argp1 = 0 ;
34564 int res1 = 0 ;
34565 PyObject *swig_obj[1] ;
34566
34567 if (!args) SWIG_fail;
34568 swig_obj[0] = args;
34569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34570 if (!SWIG_IsOK(res1)) {
34571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34572 }
34573 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34574 {
34575 PyThreadState* __tstate = wxPyBeginAllowThreads();
34576 (arg1)->OnLeave();
34577 wxPyEndAllowThreads(__tstate);
34578 if (PyErr_Occurred()) SWIG_fail;
34579 }
34580 resultobj = SWIG_Py_Void();
34581 return resultobj;
34582 fail:
34583 return NULL;
34584 }
34585
34586
34587 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34588 PyObject *resultobj = 0;
34589 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34590 int arg2 ;
34591 int arg3 ;
34592 bool result;
34593 void *argp1 = 0 ;
34594 int res1 = 0 ;
34595 int val2 ;
34596 int ecode2 = 0 ;
34597 int val3 ;
34598 int ecode3 = 0 ;
34599 PyObject * obj0 = 0 ;
34600 PyObject * obj1 = 0 ;
34601 PyObject * obj2 = 0 ;
34602 char * kwnames[] = {
34603 (char *) "self",(char *) "x",(char *) "y", NULL
34604 };
34605
34606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34608 if (!SWIG_IsOK(res1)) {
34609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34610 }
34611 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34612 ecode2 = SWIG_AsVal_int(obj1, &val2);
34613 if (!SWIG_IsOK(ecode2)) {
34614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34615 }
34616 arg2 = static_cast< int >(val2);
34617 ecode3 = SWIG_AsVal_int(obj2, &val3);
34618 if (!SWIG_IsOK(ecode3)) {
34619 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34620 }
34621 arg3 = static_cast< int >(val3);
34622 {
34623 PyThreadState* __tstate = wxPyBeginAllowThreads();
34624 result = (bool)(arg1)->OnDrop(arg2,arg3);
34625 wxPyEndAllowThreads(__tstate);
34626 if (PyErr_Occurred()) SWIG_fail;
34627 }
34628 {
34629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34630 }
34631 return resultobj;
34632 fail:
34633 return NULL;
34634 }
34635
34636
34637 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34638 PyObject *resultobj = 0;
34639 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34640 int arg2 ;
34641 int arg3 ;
34642 wxDragResult arg4 ;
34643 wxDragResult result;
34644 void *argp1 = 0 ;
34645 int res1 = 0 ;
34646 int val2 ;
34647 int ecode2 = 0 ;
34648 int val3 ;
34649 int ecode3 = 0 ;
34650 int val4 ;
34651 int ecode4 = 0 ;
34652 PyObject * obj0 = 0 ;
34653 PyObject * obj1 = 0 ;
34654 PyObject * obj2 = 0 ;
34655 PyObject * obj3 = 0 ;
34656 char * kwnames[] = {
34657 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34658 };
34659
34660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34662 if (!SWIG_IsOK(res1)) {
34663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34664 }
34665 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34666 ecode2 = SWIG_AsVal_int(obj1, &val2);
34667 if (!SWIG_IsOK(ecode2)) {
34668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34669 }
34670 arg2 = static_cast< int >(val2);
34671 ecode3 = SWIG_AsVal_int(obj2, &val3);
34672 if (!SWIG_IsOK(ecode3)) {
34673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34674 }
34675 arg3 = static_cast< int >(val3);
34676 ecode4 = SWIG_AsVal_int(obj3, &val4);
34677 if (!SWIG_IsOK(ecode4)) {
34678 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34679 }
34680 arg4 = static_cast< wxDragResult >(val4);
34681 {
34682 PyThreadState* __tstate = wxPyBeginAllowThreads();
34683 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34684 wxPyEndAllowThreads(__tstate);
34685 if (PyErr_Occurred()) SWIG_fail;
34686 }
34687 resultobj = SWIG_From_int(static_cast< int >(result));
34688 return resultobj;
34689 fail:
34690 return NULL;
34691 }
34692
34693
34694 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34695 PyObject *obj;
34696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34697 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34698 return SWIG_Py_Void();
34699 }
34700
34701 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34702 return SWIG_Python_InitShadowInstance(args);
34703 }
34704
34705 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34706 PyObject *resultobj = 0;
34707 wxPyFileDropTarget *result = 0 ;
34708
34709 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34710 {
34711 PyThreadState* __tstate = wxPyBeginAllowThreads();
34712 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34713 wxPyEndAllowThreads(__tstate);
34714 if (PyErr_Occurred()) SWIG_fail;
34715 }
34716 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34717 return resultobj;
34718 fail:
34719 return NULL;
34720 }
34721
34722
34723 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34724 PyObject *resultobj = 0;
34725 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34726 PyObject *arg2 = (PyObject *) 0 ;
34727 PyObject *arg3 = (PyObject *) 0 ;
34728 void *argp1 = 0 ;
34729 int res1 = 0 ;
34730 PyObject * obj0 = 0 ;
34731 PyObject * obj1 = 0 ;
34732 PyObject * obj2 = 0 ;
34733 char * kwnames[] = {
34734 (char *) "self",(char *) "self",(char *) "_class", NULL
34735 };
34736
34737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34739 if (!SWIG_IsOK(res1)) {
34740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34741 }
34742 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34743 arg2 = obj1;
34744 arg3 = obj2;
34745 {
34746 PyThreadState* __tstate = wxPyBeginAllowThreads();
34747 (arg1)->_setCallbackInfo(arg2,arg3);
34748 wxPyEndAllowThreads(__tstate);
34749 if (PyErr_Occurred()) SWIG_fail;
34750 }
34751 resultobj = SWIG_Py_Void();
34752 return resultobj;
34753 fail:
34754 return NULL;
34755 }
34756
34757
34758 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34759 PyObject *resultobj = 0;
34760 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34761 int arg2 ;
34762 int arg3 ;
34763 wxArrayString *arg4 = 0 ;
34764 bool result;
34765 void *argp1 = 0 ;
34766 int res1 = 0 ;
34767 int val2 ;
34768 int ecode2 = 0 ;
34769 int val3 ;
34770 int ecode3 = 0 ;
34771 bool temp4 = false ;
34772 PyObject * obj0 = 0 ;
34773 PyObject * obj1 = 0 ;
34774 PyObject * obj2 = 0 ;
34775 PyObject * obj3 = 0 ;
34776 char * kwnames[] = {
34777 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
34778 };
34779
34780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34782 if (!SWIG_IsOK(res1)) {
34783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34784 }
34785 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34786 ecode2 = SWIG_AsVal_int(obj1, &val2);
34787 if (!SWIG_IsOK(ecode2)) {
34788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
34789 }
34790 arg2 = static_cast< int >(val2);
34791 ecode3 = SWIG_AsVal_int(obj2, &val3);
34792 if (!SWIG_IsOK(ecode3)) {
34793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
34794 }
34795 arg3 = static_cast< int >(val3);
34796 {
34797 if (! PySequence_Check(obj3)) {
34798 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
34799 SWIG_fail;
34800 }
34801 arg4 = new wxArrayString;
34802 temp4 = true;
34803 int i, len=PySequence_Length(obj3);
34804 for (i=0; i<len; i++) {
34805 PyObject* item = PySequence_GetItem(obj3, i);
34806 wxString* s = wxString_in_helper(item);
34807 if (PyErr_Occurred()) SWIG_fail;
34808 arg4->Add(*s);
34809 delete s;
34810 Py_DECREF(item);
34811 }
34812 }
34813 {
34814 PyThreadState* __tstate = wxPyBeginAllowThreads();
34815 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
34816 wxPyEndAllowThreads(__tstate);
34817 if (PyErr_Occurred()) SWIG_fail;
34818 }
34819 {
34820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34821 }
34822 {
34823 if (temp4) delete arg4;
34824 }
34825 return resultobj;
34826 fail:
34827 {
34828 if (temp4) delete arg4;
34829 }
34830 return NULL;
34831 }
34832
34833
34834 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34835 PyObject *resultobj = 0;
34836 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34837 int arg2 ;
34838 int arg3 ;
34839 wxDragResult arg4 ;
34840 wxDragResult result;
34841 void *argp1 = 0 ;
34842 int res1 = 0 ;
34843 int val2 ;
34844 int ecode2 = 0 ;
34845 int val3 ;
34846 int ecode3 = 0 ;
34847 int val4 ;
34848 int ecode4 = 0 ;
34849 PyObject * obj0 = 0 ;
34850 PyObject * obj1 = 0 ;
34851 PyObject * obj2 = 0 ;
34852 PyObject * obj3 = 0 ;
34853 char * kwnames[] = {
34854 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34855 };
34856
34857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34859 if (!SWIG_IsOK(res1)) {
34860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34861 }
34862 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34863 ecode2 = SWIG_AsVal_int(obj1, &val2);
34864 if (!SWIG_IsOK(ecode2)) {
34865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34866 }
34867 arg2 = static_cast< int >(val2);
34868 ecode3 = SWIG_AsVal_int(obj2, &val3);
34869 if (!SWIG_IsOK(ecode3)) {
34870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34871 }
34872 arg3 = static_cast< int >(val3);
34873 ecode4 = SWIG_AsVal_int(obj3, &val4);
34874 if (!SWIG_IsOK(ecode4)) {
34875 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34876 }
34877 arg4 = static_cast< wxDragResult >(val4);
34878 {
34879 PyThreadState* __tstate = wxPyBeginAllowThreads();
34880 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34881 wxPyEndAllowThreads(__tstate);
34882 if (PyErr_Occurred()) SWIG_fail;
34883 }
34884 resultobj = SWIG_From_int(static_cast< int >(result));
34885 return resultobj;
34886 fail:
34887 return NULL;
34888 }
34889
34890
34891 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34892 PyObject *resultobj = 0;
34893 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34894 int arg2 ;
34895 int arg3 ;
34896 wxDragResult arg4 ;
34897 wxDragResult result;
34898 void *argp1 = 0 ;
34899 int res1 = 0 ;
34900 int val2 ;
34901 int ecode2 = 0 ;
34902 int val3 ;
34903 int ecode3 = 0 ;
34904 int val4 ;
34905 int ecode4 = 0 ;
34906 PyObject * obj0 = 0 ;
34907 PyObject * obj1 = 0 ;
34908 PyObject * obj2 = 0 ;
34909 PyObject * obj3 = 0 ;
34910 char * kwnames[] = {
34911 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34912 };
34913
34914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34916 if (!SWIG_IsOK(res1)) {
34917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34918 }
34919 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34920 ecode2 = SWIG_AsVal_int(obj1, &val2);
34921 if (!SWIG_IsOK(ecode2)) {
34922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34923 }
34924 arg2 = static_cast< int >(val2);
34925 ecode3 = SWIG_AsVal_int(obj2, &val3);
34926 if (!SWIG_IsOK(ecode3)) {
34927 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34928 }
34929 arg3 = static_cast< int >(val3);
34930 ecode4 = SWIG_AsVal_int(obj3, &val4);
34931 if (!SWIG_IsOK(ecode4)) {
34932 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34933 }
34934 arg4 = static_cast< wxDragResult >(val4);
34935 {
34936 PyThreadState* __tstate = wxPyBeginAllowThreads();
34937 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34938 wxPyEndAllowThreads(__tstate);
34939 if (PyErr_Occurred()) SWIG_fail;
34940 }
34941 resultobj = SWIG_From_int(static_cast< int >(result));
34942 return resultobj;
34943 fail:
34944 return NULL;
34945 }
34946
34947
34948 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34949 PyObject *resultobj = 0;
34950 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34951 void *argp1 = 0 ;
34952 int res1 = 0 ;
34953 PyObject *swig_obj[1] ;
34954
34955 if (!args) SWIG_fail;
34956 swig_obj[0] = args;
34957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34958 if (!SWIG_IsOK(res1)) {
34959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34960 }
34961 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34962 {
34963 PyThreadState* __tstate = wxPyBeginAllowThreads();
34964 (arg1)->OnLeave();
34965 wxPyEndAllowThreads(__tstate);
34966 if (PyErr_Occurred()) SWIG_fail;
34967 }
34968 resultobj = SWIG_Py_Void();
34969 return resultobj;
34970 fail:
34971 return NULL;
34972 }
34973
34974
34975 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34976 PyObject *resultobj = 0;
34977 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34978 int arg2 ;
34979 int arg3 ;
34980 bool result;
34981 void *argp1 = 0 ;
34982 int res1 = 0 ;
34983 int val2 ;
34984 int ecode2 = 0 ;
34985 int val3 ;
34986 int ecode3 = 0 ;
34987 PyObject * obj0 = 0 ;
34988 PyObject * obj1 = 0 ;
34989 PyObject * obj2 = 0 ;
34990 char * kwnames[] = {
34991 (char *) "self",(char *) "x",(char *) "y", NULL
34992 };
34993
34994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34996 if (!SWIG_IsOK(res1)) {
34997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34998 }
34999 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35000 ecode2 = SWIG_AsVal_int(obj1, &val2);
35001 if (!SWIG_IsOK(ecode2)) {
35002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35003 }
35004 arg2 = static_cast< int >(val2);
35005 ecode3 = SWIG_AsVal_int(obj2, &val3);
35006 if (!SWIG_IsOK(ecode3)) {
35007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35008 }
35009 arg3 = static_cast< int >(val3);
35010 {
35011 PyThreadState* __tstate = wxPyBeginAllowThreads();
35012 result = (bool)(arg1)->OnDrop(arg2,arg3);
35013 wxPyEndAllowThreads(__tstate);
35014 if (PyErr_Occurred()) SWIG_fail;
35015 }
35016 {
35017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35018 }
35019 return resultobj;
35020 fail:
35021 return NULL;
35022 }
35023
35024
35025 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35026 PyObject *resultobj = 0;
35027 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35028 int arg2 ;
35029 int arg3 ;
35030 wxDragResult arg4 ;
35031 wxDragResult result;
35032 void *argp1 = 0 ;
35033 int res1 = 0 ;
35034 int val2 ;
35035 int ecode2 = 0 ;
35036 int val3 ;
35037 int ecode3 = 0 ;
35038 int val4 ;
35039 int ecode4 = 0 ;
35040 PyObject * obj0 = 0 ;
35041 PyObject * obj1 = 0 ;
35042 PyObject * obj2 = 0 ;
35043 PyObject * obj3 = 0 ;
35044 char * kwnames[] = {
35045 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35046 };
35047
35048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35050 if (!SWIG_IsOK(res1)) {
35051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35052 }
35053 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35054 ecode2 = SWIG_AsVal_int(obj1, &val2);
35055 if (!SWIG_IsOK(ecode2)) {
35056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35057 }
35058 arg2 = static_cast< int >(val2);
35059 ecode3 = SWIG_AsVal_int(obj2, &val3);
35060 if (!SWIG_IsOK(ecode3)) {
35061 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35062 }
35063 arg3 = static_cast< int >(val3);
35064 ecode4 = SWIG_AsVal_int(obj3, &val4);
35065 if (!SWIG_IsOK(ecode4)) {
35066 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35067 }
35068 arg4 = static_cast< wxDragResult >(val4);
35069 {
35070 PyThreadState* __tstate = wxPyBeginAllowThreads();
35071 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35072 wxPyEndAllowThreads(__tstate);
35073 if (PyErr_Occurred()) SWIG_fail;
35074 }
35075 resultobj = SWIG_From_int(static_cast< int >(result));
35076 return resultobj;
35077 fail:
35078 return NULL;
35079 }
35080
35081
35082 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35083 PyObject *obj;
35084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35085 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35086 return SWIG_Py_Void();
35087 }
35088
35089 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35090 return SWIG_Python_InitShadowInstance(args);
35091 }
35092
35093 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35094 PyObject *resultobj = 0;
35095 wxClipboard *result = 0 ;
35096
35097 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35098 {
35099 PyThreadState* __tstate = wxPyBeginAllowThreads();
35100 result = (wxClipboard *)new wxClipboard();
35101 wxPyEndAllowThreads(__tstate);
35102 if (PyErr_Occurred()) SWIG_fail;
35103 }
35104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35105 return resultobj;
35106 fail:
35107 return NULL;
35108 }
35109
35110
35111 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35112 PyObject *resultobj = 0;
35113 wxClipboard *arg1 = (wxClipboard *) 0 ;
35114 void *argp1 = 0 ;
35115 int res1 = 0 ;
35116 PyObject *swig_obj[1] ;
35117
35118 if (!args) SWIG_fail;
35119 swig_obj[0] = args;
35120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35121 if (!SWIG_IsOK(res1)) {
35122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35123 }
35124 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35125 {
35126 PyThreadState* __tstate = wxPyBeginAllowThreads();
35127 delete arg1;
35128
35129 wxPyEndAllowThreads(__tstate);
35130 if (PyErr_Occurred()) SWIG_fail;
35131 }
35132 resultobj = SWIG_Py_Void();
35133 return resultobj;
35134 fail:
35135 return NULL;
35136 }
35137
35138
35139 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35140 PyObject *resultobj = 0;
35141 wxClipboard *arg1 = (wxClipboard *) 0 ;
35142 bool result;
35143 void *argp1 = 0 ;
35144 int res1 = 0 ;
35145 PyObject *swig_obj[1] ;
35146
35147 if (!args) SWIG_fail;
35148 swig_obj[0] = args;
35149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35150 if (!SWIG_IsOK(res1)) {
35151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35152 }
35153 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35154 {
35155 PyThreadState* __tstate = wxPyBeginAllowThreads();
35156 result = (bool)(arg1)->Open();
35157 wxPyEndAllowThreads(__tstate);
35158 if (PyErr_Occurred()) SWIG_fail;
35159 }
35160 {
35161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35162 }
35163 return resultobj;
35164 fail:
35165 return NULL;
35166 }
35167
35168
35169 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35170 PyObject *resultobj = 0;
35171 wxClipboard *arg1 = (wxClipboard *) 0 ;
35172 void *argp1 = 0 ;
35173 int res1 = 0 ;
35174 PyObject *swig_obj[1] ;
35175
35176 if (!args) SWIG_fail;
35177 swig_obj[0] = args;
35178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35179 if (!SWIG_IsOK(res1)) {
35180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35181 }
35182 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35183 {
35184 PyThreadState* __tstate = wxPyBeginAllowThreads();
35185 (arg1)->Close();
35186 wxPyEndAllowThreads(__tstate);
35187 if (PyErr_Occurred()) SWIG_fail;
35188 }
35189 resultobj = SWIG_Py_Void();
35190 return resultobj;
35191 fail:
35192 return NULL;
35193 }
35194
35195
35196 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35197 PyObject *resultobj = 0;
35198 wxClipboard *arg1 = (wxClipboard *) 0 ;
35199 bool result;
35200 void *argp1 = 0 ;
35201 int res1 = 0 ;
35202 PyObject *swig_obj[1] ;
35203
35204 if (!args) SWIG_fail;
35205 swig_obj[0] = args;
35206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35207 if (!SWIG_IsOK(res1)) {
35208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35209 }
35210 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35211 {
35212 PyThreadState* __tstate = wxPyBeginAllowThreads();
35213 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35214 wxPyEndAllowThreads(__tstate);
35215 if (PyErr_Occurred()) SWIG_fail;
35216 }
35217 {
35218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35219 }
35220 return resultobj;
35221 fail:
35222 return NULL;
35223 }
35224
35225
35226 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35227 PyObject *resultobj = 0;
35228 wxClipboard *arg1 = (wxClipboard *) 0 ;
35229 wxDataObject *arg2 = (wxDataObject *) 0 ;
35230 bool result;
35231 void *argp1 = 0 ;
35232 int res1 = 0 ;
35233 int res2 = 0 ;
35234 PyObject * obj0 = 0 ;
35235 PyObject * obj1 = 0 ;
35236 char * kwnames[] = {
35237 (char *) "self",(char *) "data", NULL
35238 };
35239
35240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35242 if (!SWIG_IsOK(res1)) {
35243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35244 }
35245 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35246 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35247 if (!SWIG_IsOK(res2)) {
35248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35249 }
35250 {
35251 PyThreadState* __tstate = wxPyBeginAllowThreads();
35252 result = (bool)(arg1)->AddData(arg2);
35253 wxPyEndAllowThreads(__tstate);
35254 if (PyErr_Occurred()) SWIG_fail;
35255 }
35256 {
35257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35258 }
35259 return resultobj;
35260 fail:
35261 return NULL;
35262 }
35263
35264
35265 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35266 PyObject *resultobj = 0;
35267 wxClipboard *arg1 = (wxClipboard *) 0 ;
35268 wxDataObject *arg2 = (wxDataObject *) 0 ;
35269 bool result;
35270 void *argp1 = 0 ;
35271 int res1 = 0 ;
35272 int res2 = 0 ;
35273 PyObject * obj0 = 0 ;
35274 PyObject * obj1 = 0 ;
35275 char * kwnames[] = {
35276 (char *) "self",(char *) "data", NULL
35277 };
35278
35279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35281 if (!SWIG_IsOK(res1)) {
35282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35283 }
35284 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35285 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35286 if (!SWIG_IsOK(res2)) {
35287 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35288 }
35289 {
35290 PyThreadState* __tstate = wxPyBeginAllowThreads();
35291 result = (bool)(arg1)->SetData(arg2);
35292 wxPyEndAllowThreads(__tstate);
35293 if (PyErr_Occurred()) SWIG_fail;
35294 }
35295 {
35296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35297 }
35298 return resultobj;
35299 fail:
35300 return NULL;
35301 }
35302
35303
35304 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35305 PyObject *resultobj = 0;
35306 wxClipboard *arg1 = (wxClipboard *) 0 ;
35307 wxDataFormat *arg2 = 0 ;
35308 bool result;
35309 void *argp1 = 0 ;
35310 int res1 = 0 ;
35311 void *argp2 = 0 ;
35312 int res2 = 0 ;
35313 PyObject * obj0 = 0 ;
35314 PyObject * obj1 = 0 ;
35315 char * kwnames[] = {
35316 (char *) "self",(char *) "format", NULL
35317 };
35318
35319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35321 if (!SWIG_IsOK(res1)) {
35322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35323 }
35324 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35325 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35326 if (!SWIG_IsOK(res2)) {
35327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35328 }
35329 if (!argp2) {
35330 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35331 }
35332 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35333 {
35334 PyThreadState* __tstate = wxPyBeginAllowThreads();
35335 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35336 wxPyEndAllowThreads(__tstate);
35337 if (PyErr_Occurred()) SWIG_fail;
35338 }
35339 {
35340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35341 }
35342 return resultobj;
35343 fail:
35344 return NULL;
35345 }
35346
35347
35348 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35349 PyObject *resultobj = 0;
35350 wxClipboard *arg1 = (wxClipboard *) 0 ;
35351 wxDataObject *arg2 = 0 ;
35352 bool result;
35353 void *argp1 = 0 ;
35354 int res1 = 0 ;
35355 void *argp2 = 0 ;
35356 int res2 = 0 ;
35357 PyObject * obj0 = 0 ;
35358 PyObject * obj1 = 0 ;
35359 char * kwnames[] = {
35360 (char *) "self",(char *) "data", NULL
35361 };
35362
35363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35365 if (!SWIG_IsOK(res1)) {
35366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35367 }
35368 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35369 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35370 if (!SWIG_IsOK(res2)) {
35371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35372 }
35373 if (!argp2) {
35374 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35375 }
35376 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35377 {
35378 PyThreadState* __tstate = wxPyBeginAllowThreads();
35379 result = (bool)(arg1)->GetData(*arg2);
35380 wxPyEndAllowThreads(__tstate);
35381 if (PyErr_Occurred()) SWIG_fail;
35382 }
35383 {
35384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35385 }
35386 return resultobj;
35387 fail:
35388 return NULL;
35389 }
35390
35391
35392 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35393 PyObject *resultobj = 0;
35394 wxClipboard *arg1 = (wxClipboard *) 0 ;
35395 void *argp1 = 0 ;
35396 int res1 = 0 ;
35397 PyObject *swig_obj[1] ;
35398
35399 if (!args) SWIG_fail;
35400 swig_obj[0] = args;
35401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35402 if (!SWIG_IsOK(res1)) {
35403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35404 }
35405 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35406 {
35407 PyThreadState* __tstate = wxPyBeginAllowThreads();
35408 (arg1)->Clear();
35409 wxPyEndAllowThreads(__tstate);
35410 if (PyErr_Occurred()) SWIG_fail;
35411 }
35412 resultobj = SWIG_Py_Void();
35413 return resultobj;
35414 fail:
35415 return NULL;
35416 }
35417
35418
35419 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35420 PyObject *resultobj = 0;
35421 wxClipboard *arg1 = (wxClipboard *) 0 ;
35422 bool result;
35423 void *argp1 = 0 ;
35424 int res1 = 0 ;
35425 PyObject *swig_obj[1] ;
35426
35427 if (!args) SWIG_fail;
35428 swig_obj[0] = args;
35429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35430 if (!SWIG_IsOK(res1)) {
35431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35432 }
35433 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35434 {
35435 PyThreadState* __tstate = wxPyBeginAllowThreads();
35436 result = (bool)(arg1)->Flush();
35437 wxPyEndAllowThreads(__tstate);
35438 if (PyErr_Occurred()) SWIG_fail;
35439 }
35440 {
35441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35442 }
35443 return resultobj;
35444 fail:
35445 return NULL;
35446 }
35447
35448
35449 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35450 PyObject *resultobj = 0;
35451 wxClipboard *arg1 = (wxClipboard *) 0 ;
35452 bool arg2 = (bool) true ;
35453 void *argp1 = 0 ;
35454 int res1 = 0 ;
35455 bool val2 ;
35456 int ecode2 = 0 ;
35457 PyObject * obj0 = 0 ;
35458 PyObject * obj1 = 0 ;
35459 char * kwnames[] = {
35460 (char *) "self",(char *) "primary", NULL
35461 };
35462
35463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35465 if (!SWIG_IsOK(res1)) {
35466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35467 }
35468 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35469 if (obj1) {
35470 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35471 if (!SWIG_IsOK(ecode2)) {
35472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35473 }
35474 arg2 = static_cast< bool >(val2);
35475 }
35476 {
35477 PyThreadState* __tstate = wxPyBeginAllowThreads();
35478 (arg1)->UsePrimarySelection(arg2);
35479 wxPyEndAllowThreads(__tstate);
35480 if (PyErr_Occurred()) SWIG_fail;
35481 }
35482 resultobj = SWIG_Py_Void();
35483 return resultobj;
35484 fail:
35485 return NULL;
35486 }
35487
35488
35489 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35490 PyObject *resultobj = 0;
35491 wxClipboard *result = 0 ;
35492
35493 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35494 {
35495 PyThreadState* __tstate = wxPyBeginAllowThreads();
35496 result = (wxClipboard *)wxClipboard::Get();
35497 wxPyEndAllowThreads(__tstate);
35498 if (PyErr_Occurred()) SWIG_fail;
35499 }
35500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35501 return resultobj;
35502 fail:
35503 return NULL;
35504 }
35505
35506
35507 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35508 PyObject *obj;
35509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35510 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35511 return SWIG_Py_Void();
35512 }
35513
35514 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35515 return SWIG_Python_InitShadowInstance(args);
35516 }
35517
35518 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35519 PyObject *resultobj = 0;
35520 wxClipboard *arg1 = (wxClipboard *) NULL ;
35521 wxClipboardLocker *result = 0 ;
35522 void *argp1 = 0 ;
35523 int res1 = 0 ;
35524 PyObject * obj0 = 0 ;
35525 char * kwnames[] = {
35526 (char *) "clipboard", NULL
35527 };
35528
35529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35530 if (obj0) {
35531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35532 if (!SWIG_IsOK(res1)) {
35533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35534 }
35535 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35536 }
35537 {
35538 PyThreadState* __tstate = wxPyBeginAllowThreads();
35539 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35540 wxPyEndAllowThreads(__tstate);
35541 if (PyErr_Occurred()) SWIG_fail;
35542 }
35543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35544 return resultobj;
35545 fail:
35546 return NULL;
35547 }
35548
35549
35550 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35551 PyObject *resultobj = 0;
35552 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35553 void *argp1 = 0 ;
35554 int res1 = 0 ;
35555 PyObject *swig_obj[1] ;
35556
35557 if (!args) SWIG_fail;
35558 swig_obj[0] = args;
35559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35560 if (!SWIG_IsOK(res1)) {
35561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35562 }
35563 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35564 {
35565 PyThreadState* __tstate = wxPyBeginAllowThreads();
35566 delete arg1;
35567
35568 wxPyEndAllowThreads(__tstate);
35569 if (PyErr_Occurred()) SWIG_fail;
35570 }
35571 resultobj = SWIG_Py_Void();
35572 return resultobj;
35573 fail:
35574 return NULL;
35575 }
35576
35577
35578 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35579 PyObject *resultobj = 0;
35580 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35581 bool result;
35582 void *argp1 = 0 ;
35583 int res1 = 0 ;
35584 PyObject *swig_obj[1] ;
35585
35586 if (!args) SWIG_fail;
35587 swig_obj[0] = args;
35588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35589 if (!SWIG_IsOK(res1)) {
35590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35591 }
35592 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35593 {
35594 PyThreadState* __tstate = wxPyBeginAllowThreads();
35595 result = (bool)wxClipboardLocker___nonzero__(arg1);
35596 wxPyEndAllowThreads(__tstate);
35597 if (PyErr_Occurred()) SWIG_fail;
35598 }
35599 {
35600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35601 }
35602 return resultobj;
35603 fail:
35604 return NULL;
35605 }
35606
35607
35608 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35609 PyObject *obj;
35610 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35611 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35612 return SWIG_Py_Void();
35613 }
35614
35615 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35616 return SWIG_Python_InitShadowInstance(args);
35617 }
35618
35619 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35620 PyObject *resultobj = 0;
35621 int arg1 = (int) 0 ;
35622 int arg2 = (int) 0 ;
35623 int arg3 = (int) 0 ;
35624 int arg4 = (int) 0 ;
35625 wxVideoMode *result = 0 ;
35626 int val1 ;
35627 int ecode1 = 0 ;
35628 int val2 ;
35629 int ecode2 = 0 ;
35630 int val3 ;
35631 int ecode3 = 0 ;
35632 int val4 ;
35633 int ecode4 = 0 ;
35634 PyObject * obj0 = 0 ;
35635 PyObject * obj1 = 0 ;
35636 PyObject * obj2 = 0 ;
35637 PyObject * obj3 = 0 ;
35638 char * kwnames[] = {
35639 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35640 };
35641
35642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35643 if (obj0) {
35644 ecode1 = SWIG_AsVal_int(obj0, &val1);
35645 if (!SWIG_IsOK(ecode1)) {
35646 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35647 }
35648 arg1 = static_cast< int >(val1);
35649 }
35650 if (obj1) {
35651 ecode2 = SWIG_AsVal_int(obj1, &val2);
35652 if (!SWIG_IsOK(ecode2)) {
35653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35654 }
35655 arg2 = static_cast< int >(val2);
35656 }
35657 if (obj2) {
35658 ecode3 = SWIG_AsVal_int(obj2, &val3);
35659 if (!SWIG_IsOK(ecode3)) {
35660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35661 }
35662 arg3 = static_cast< int >(val3);
35663 }
35664 if (obj3) {
35665 ecode4 = SWIG_AsVal_int(obj3, &val4);
35666 if (!SWIG_IsOK(ecode4)) {
35667 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35668 }
35669 arg4 = static_cast< int >(val4);
35670 }
35671 {
35672 PyThreadState* __tstate = wxPyBeginAllowThreads();
35673 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35674 wxPyEndAllowThreads(__tstate);
35675 if (PyErr_Occurred()) SWIG_fail;
35676 }
35677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35678 return resultobj;
35679 fail:
35680 return NULL;
35681 }
35682
35683
35684 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35685 PyObject *resultobj = 0;
35686 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35687 void *argp1 = 0 ;
35688 int res1 = 0 ;
35689 PyObject *swig_obj[1] ;
35690
35691 if (!args) SWIG_fail;
35692 swig_obj[0] = args;
35693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35694 if (!SWIG_IsOK(res1)) {
35695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35696 }
35697 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35698 {
35699 PyThreadState* __tstate = wxPyBeginAllowThreads();
35700 delete arg1;
35701
35702 wxPyEndAllowThreads(__tstate);
35703 if (PyErr_Occurred()) SWIG_fail;
35704 }
35705 resultobj = SWIG_Py_Void();
35706 return resultobj;
35707 fail:
35708 return NULL;
35709 }
35710
35711
35712 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35713 PyObject *resultobj = 0;
35714 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35715 wxVideoMode *arg2 = 0 ;
35716 bool result;
35717 void *argp1 = 0 ;
35718 int res1 = 0 ;
35719 void *argp2 = 0 ;
35720 int res2 = 0 ;
35721 PyObject * obj0 = 0 ;
35722 PyObject * obj1 = 0 ;
35723 char * kwnames[] = {
35724 (char *) "self",(char *) "other", NULL
35725 };
35726
35727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35729 if (!SWIG_IsOK(res1)) {
35730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35731 }
35732 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35733 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35734 if (!SWIG_IsOK(res2)) {
35735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35736 }
35737 if (!argp2) {
35738 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35739 }
35740 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35741 {
35742 PyThreadState* __tstate = wxPyBeginAllowThreads();
35743 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35744 wxPyEndAllowThreads(__tstate);
35745 if (PyErr_Occurred()) SWIG_fail;
35746 }
35747 {
35748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35749 }
35750 return resultobj;
35751 fail:
35752 return NULL;
35753 }
35754
35755
35756 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35757 PyObject *resultobj = 0;
35758 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35759 int result;
35760 void *argp1 = 0 ;
35761 int res1 = 0 ;
35762 PyObject *swig_obj[1] ;
35763
35764 if (!args) SWIG_fail;
35765 swig_obj[0] = args;
35766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35767 if (!SWIG_IsOK(res1)) {
35768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35769 }
35770 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35771 {
35772 PyThreadState* __tstate = wxPyBeginAllowThreads();
35773 result = (int)((wxVideoMode const *)arg1)->GetWidth();
35774 wxPyEndAllowThreads(__tstate);
35775 if (PyErr_Occurred()) SWIG_fail;
35776 }
35777 resultobj = SWIG_From_int(static_cast< int >(result));
35778 return resultobj;
35779 fail:
35780 return NULL;
35781 }
35782
35783
35784 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35785 PyObject *resultobj = 0;
35786 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35787 int result;
35788 void *argp1 = 0 ;
35789 int res1 = 0 ;
35790 PyObject *swig_obj[1] ;
35791
35792 if (!args) SWIG_fail;
35793 swig_obj[0] = args;
35794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35795 if (!SWIG_IsOK(res1)) {
35796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35797 }
35798 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35799 {
35800 PyThreadState* __tstate = wxPyBeginAllowThreads();
35801 result = (int)((wxVideoMode const *)arg1)->GetHeight();
35802 wxPyEndAllowThreads(__tstate);
35803 if (PyErr_Occurred()) SWIG_fail;
35804 }
35805 resultobj = SWIG_From_int(static_cast< int >(result));
35806 return resultobj;
35807 fail:
35808 return NULL;
35809 }
35810
35811
35812 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35813 PyObject *resultobj = 0;
35814 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35815 int result;
35816 void *argp1 = 0 ;
35817 int res1 = 0 ;
35818 PyObject *swig_obj[1] ;
35819
35820 if (!args) SWIG_fail;
35821 swig_obj[0] = args;
35822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35823 if (!SWIG_IsOK(res1)) {
35824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35825 }
35826 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35827 {
35828 PyThreadState* __tstate = wxPyBeginAllowThreads();
35829 result = (int)((wxVideoMode const *)arg1)->GetDepth();
35830 wxPyEndAllowThreads(__tstate);
35831 if (PyErr_Occurred()) SWIG_fail;
35832 }
35833 resultobj = SWIG_From_int(static_cast< int >(result));
35834 return resultobj;
35835 fail:
35836 return NULL;
35837 }
35838
35839
35840 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35841 PyObject *resultobj = 0;
35842 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35843 bool result;
35844 void *argp1 = 0 ;
35845 int res1 = 0 ;
35846 PyObject *swig_obj[1] ;
35847
35848 if (!args) SWIG_fail;
35849 swig_obj[0] = args;
35850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35851 if (!SWIG_IsOK(res1)) {
35852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35853 }
35854 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35855 {
35856 PyThreadState* __tstate = wxPyBeginAllowThreads();
35857 result = (bool)((wxVideoMode const *)arg1)->IsOk();
35858 wxPyEndAllowThreads(__tstate);
35859 if (PyErr_Occurred()) SWIG_fail;
35860 }
35861 {
35862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35863 }
35864 return resultobj;
35865 fail:
35866 return NULL;
35867 }
35868
35869
35870 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35871 PyObject *resultobj = 0;
35872 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35873 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
35874 bool result;
35875 void *argp1 = 0 ;
35876 int res1 = 0 ;
35877 void *argp2 = 0 ;
35878 int res2 = 0 ;
35879 PyObject * obj0 = 0 ;
35880 PyObject * obj1 = 0 ;
35881 char * kwnames[] = {
35882 (char *) "self",(char *) "other", NULL
35883 };
35884
35885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
35886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35887 if (!SWIG_IsOK(res1)) {
35888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35889 }
35890 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35891 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35892 if (!SWIG_IsOK(res2)) {
35893 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
35894 }
35895 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35896 {
35897 PyThreadState* __tstate = wxPyBeginAllowThreads();
35898 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
35899 wxPyEndAllowThreads(__tstate);
35900 if (PyErr_Occurred()) SWIG_fail;
35901 }
35902 {
35903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35904 }
35905 return resultobj;
35906 fail:
35907 return NULL;
35908 }
35909
35910
35911 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35912 PyObject *resultobj = 0;
35913 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35914 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
35915 bool result;
35916 void *argp1 = 0 ;
35917 int res1 = 0 ;
35918 void *argp2 = 0 ;
35919 int res2 = 0 ;
35920 PyObject * obj0 = 0 ;
35921 PyObject * obj1 = 0 ;
35922 char * kwnames[] = {
35923 (char *) "self",(char *) "other", NULL
35924 };
35925
35926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
35927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35928 if (!SWIG_IsOK(res1)) {
35929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35930 }
35931 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35932 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35933 if (!SWIG_IsOK(res2)) {
35934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
35935 }
35936 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35937 {
35938 PyThreadState* __tstate = wxPyBeginAllowThreads();
35939 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
35940 wxPyEndAllowThreads(__tstate);
35941 if (PyErr_Occurred()) SWIG_fail;
35942 }
35943 {
35944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35945 }
35946 return resultobj;
35947 fail:
35948 return NULL;
35949 }
35950
35951
35952 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35953 PyObject *resultobj = 0;
35954 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35955 int arg2 ;
35956 void *argp1 = 0 ;
35957 int res1 = 0 ;
35958 int val2 ;
35959 int ecode2 = 0 ;
35960 PyObject *swig_obj[2] ;
35961
35962 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
35963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35964 if (!SWIG_IsOK(res1)) {
35965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35966 }
35967 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35968 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35969 if (!SWIG_IsOK(ecode2)) {
35970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
35971 }
35972 arg2 = static_cast< int >(val2);
35973 if (arg1) (arg1)->w = arg2;
35974
35975 resultobj = SWIG_Py_Void();
35976 return resultobj;
35977 fail:
35978 return NULL;
35979 }
35980
35981
35982 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35983 PyObject *resultobj = 0;
35984 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35985 int result;
35986 void *argp1 = 0 ;
35987 int res1 = 0 ;
35988 PyObject *swig_obj[1] ;
35989
35990 if (!args) SWIG_fail;
35991 swig_obj[0] = args;
35992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35993 if (!SWIG_IsOK(res1)) {
35994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35995 }
35996 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35997 result = (int) ((arg1)->w);
35998 resultobj = SWIG_From_int(static_cast< int >(result));
35999 return resultobj;
36000 fail:
36001 return NULL;
36002 }
36003
36004
36005 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36006 PyObject *resultobj = 0;
36007 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36008 int arg2 ;
36009 void *argp1 = 0 ;
36010 int res1 = 0 ;
36011 int val2 ;
36012 int ecode2 = 0 ;
36013 PyObject *swig_obj[2] ;
36014
36015 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36017 if (!SWIG_IsOK(res1)) {
36018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36019 }
36020 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36021 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36022 if (!SWIG_IsOK(ecode2)) {
36023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36024 }
36025 arg2 = static_cast< int >(val2);
36026 if (arg1) (arg1)->h = arg2;
36027
36028 resultobj = SWIG_Py_Void();
36029 return resultobj;
36030 fail:
36031 return NULL;
36032 }
36033
36034
36035 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36036 PyObject *resultobj = 0;
36037 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36038 int result;
36039 void *argp1 = 0 ;
36040 int res1 = 0 ;
36041 PyObject *swig_obj[1] ;
36042
36043 if (!args) SWIG_fail;
36044 swig_obj[0] = args;
36045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36046 if (!SWIG_IsOK(res1)) {
36047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36048 }
36049 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36050 result = (int) ((arg1)->h);
36051 resultobj = SWIG_From_int(static_cast< int >(result));
36052 return resultobj;
36053 fail:
36054 return NULL;
36055 }
36056
36057
36058 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36059 PyObject *resultobj = 0;
36060 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36061 int arg2 ;
36062 void *argp1 = 0 ;
36063 int res1 = 0 ;
36064 int val2 ;
36065 int ecode2 = 0 ;
36066 PyObject *swig_obj[2] ;
36067
36068 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36070 if (!SWIG_IsOK(res1)) {
36071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36072 }
36073 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36074 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36075 if (!SWIG_IsOK(ecode2)) {
36076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36077 }
36078 arg2 = static_cast< int >(val2);
36079 if (arg1) (arg1)->bpp = arg2;
36080
36081 resultobj = SWIG_Py_Void();
36082 return resultobj;
36083 fail:
36084 return NULL;
36085 }
36086
36087
36088 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36089 PyObject *resultobj = 0;
36090 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36091 int result;
36092 void *argp1 = 0 ;
36093 int res1 = 0 ;
36094 PyObject *swig_obj[1] ;
36095
36096 if (!args) SWIG_fail;
36097 swig_obj[0] = args;
36098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36099 if (!SWIG_IsOK(res1)) {
36100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36101 }
36102 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36103 result = (int) ((arg1)->bpp);
36104 resultobj = SWIG_From_int(static_cast< int >(result));
36105 return resultobj;
36106 fail:
36107 return NULL;
36108 }
36109
36110
36111 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36112 PyObject *resultobj = 0;
36113 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36114 int arg2 ;
36115 void *argp1 = 0 ;
36116 int res1 = 0 ;
36117 int val2 ;
36118 int ecode2 = 0 ;
36119 PyObject *swig_obj[2] ;
36120
36121 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36123 if (!SWIG_IsOK(res1)) {
36124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36125 }
36126 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36127 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36128 if (!SWIG_IsOK(ecode2)) {
36129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36130 }
36131 arg2 = static_cast< int >(val2);
36132 if (arg1) (arg1)->refresh = arg2;
36133
36134 resultobj = SWIG_Py_Void();
36135 return resultobj;
36136 fail:
36137 return NULL;
36138 }
36139
36140
36141 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36142 PyObject *resultobj = 0;
36143 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36144 int result;
36145 void *argp1 = 0 ;
36146 int res1 = 0 ;
36147 PyObject *swig_obj[1] ;
36148
36149 if (!args) SWIG_fail;
36150 swig_obj[0] = args;
36151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36152 if (!SWIG_IsOK(res1)) {
36153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36154 }
36155 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36156 result = (int) ((arg1)->refresh);
36157 resultobj = SWIG_From_int(static_cast< int >(result));
36158 return resultobj;
36159 fail:
36160 return NULL;
36161 }
36162
36163
36164 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36165 PyObject *obj;
36166 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36167 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36168 return SWIG_Py_Void();
36169 }
36170
36171 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36172 return SWIG_Python_InitShadowInstance(args);
36173 }
36174
36175 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36176 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36177 return 1;
36178 }
36179
36180
36181 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36182 PyObject *pyobj = 0;
36183
36184 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36185 return pyobj;
36186 }
36187
36188
36189 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36190 PyObject *resultobj = 0;
36191 size_t arg1 = (size_t) 0 ;
36192 wxDisplay *result = 0 ;
36193 size_t val1 ;
36194 int ecode1 = 0 ;
36195 PyObject * obj0 = 0 ;
36196 char * kwnames[] = {
36197 (char *) "index", NULL
36198 };
36199
36200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36201 if (obj0) {
36202 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
36203 if (!SWIG_IsOK(ecode1)) {
36204 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
36205 }
36206 arg1 = static_cast< size_t >(val1);
36207 }
36208 {
36209 PyThreadState* __tstate = wxPyBeginAllowThreads();
36210 result = (wxDisplay *)new wxDisplay(arg1);
36211 wxPyEndAllowThreads(__tstate);
36212 if (PyErr_Occurred()) SWIG_fail;
36213 }
36214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36215 return resultobj;
36216 fail:
36217 return NULL;
36218 }
36219
36220
36221 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36222 PyObject *resultobj = 0;
36223 wxDisplay *arg1 = (wxDisplay *) 0 ;
36224 void *argp1 = 0 ;
36225 int res1 = 0 ;
36226 PyObject *swig_obj[1] ;
36227
36228 if (!args) SWIG_fail;
36229 swig_obj[0] = args;
36230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36231 if (!SWIG_IsOK(res1)) {
36232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36233 }
36234 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36235 {
36236 PyThreadState* __tstate = wxPyBeginAllowThreads();
36237 delete arg1;
36238
36239 wxPyEndAllowThreads(__tstate);
36240 if (PyErr_Occurred()) SWIG_fail;
36241 }
36242 resultobj = SWIG_Py_Void();
36243 return resultobj;
36244 fail:
36245 return NULL;
36246 }
36247
36248
36249 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36250 PyObject *resultobj = 0;
36251 size_t result;
36252
36253 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36254 {
36255 PyThreadState* __tstate = wxPyBeginAllowThreads();
36256 result = (size_t)wxDisplay::GetCount();
36257 wxPyEndAllowThreads(__tstate);
36258 if (PyErr_Occurred()) SWIG_fail;
36259 }
36260 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
36261 return resultobj;
36262 fail:
36263 return NULL;
36264 }
36265
36266
36267 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36268 PyObject *resultobj = 0;
36269 wxPoint *arg1 = 0 ;
36270 int result;
36271 wxPoint temp1 ;
36272 PyObject * obj0 = 0 ;
36273 char * kwnames[] = {
36274 (char *) "pt", NULL
36275 };
36276
36277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36278 {
36279 arg1 = &temp1;
36280 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36281 }
36282 {
36283 PyThreadState* __tstate = wxPyBeginAllowThreads();
36284 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36285 wxPyEndAllowThreads(__tstate);
36286 if (PyErr_Occurred()) SWIG_fail;
36287 }
36288 resultobj = SWIG_From_int(static_cast< int >(result));
36289 return resultobj;
36290 fail:
36291 return NULL;
36292 }
36293
36294
36295 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36296 PyObject *resultobj = 0;
36297 wxWindow *arg1 = (wxWindow *) 0 ;
36298 int result;
36299 void *argp1 = 0 ;
36300 int res1 = 0 ;
36301 PyObject * obj0 = 0 ;
36302 char * kwnames[] = {
36303 (char *) "window", NULL
36304 };
36305
36306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36308 if (!SWIG_IsOK(res1)) {
36309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36310 }
36311 arg1 = reinterpret_cast< wxWindow * >(argp1);
36312 {
36313 PyThreadState* __tstate = wxPyBeginAllowThreads();
36314 result = (int)wxDisplay::GetFromWindow(arg1);
36315 wxPyEndAllowThreads(__tstate);
36316 if (PyErr_Occurred()) SWIG_fail;
36317 }
36318 resultobj = SWIG_From_int(static_cast< int >(result));
36319 return resultobj;
36320 fail:
36321 return NULL;
36322 }
36323
36324
36325 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36326 PyObject *resultobj = 0;
36327 wxDisplay *arg1 = (wxDisplay *) 0 ;
36328 bool result;
36329 void *argp1 = 0 ;
36330 int res1 = 0 ;
36331 PyObject *swig_obj[1] ;
36332
36333 if (!args) SWIG_fail;
36334 swig_obj[0] = args;
36335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36336 if (!SWIG_IsOK(res1)) {
36337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36338 }
36339 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36340 {
36341 PyThreadState* __tstate = wxPyBeginAllowThreads();
36342 result = (bool)((wxDisplay const *)arg1)->IsOk();
36343 wxPyEndAllowThreads(__tstate);
36344 if (PyErr_Occurred()) SWIG_fail;
36345 }
36346 {
36347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36348 }
36349 return resultobj;
36350 fail:
36351 return NULL;
36352 }
36353
36354
36355 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36356 PyObject *resultobj = 0;
36357 wxDisplay *arg1 = (wxDisplay *) 0 ;
36358 wxRect result;
36359 void *argp1 = 0 ;
36360 int res1 = 0 ;
36361 PyObject *swig_obj[1] ;
36362
36363 if (!args) SWIG_fail;
36364 swig_obj[0] = args;
36365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36366 if (!SWIG_IsOK(res1)) {
36367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36368 }
36369 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36370 {
36371 PyThreadState* __tstate = wxPyBeginAllowThreads();
36372 result = ((wxDisplay const *)arg1)->GetGeometry();
36373 wxPyEndAllowThreads(__tstate);
36374 if (PyErr_Occurred()) SWIG_fail;
36375 }
36376 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36377 return resultobj;
36378 fail:
36379 return NULL;
36380 }
36381
36382
36383 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36384 PyObject *resultobj = 0;
36385 wxDisplay *arg1 = (wxDisplay *) 0 ;
36386 wxRect result;
36387 void *argp1 = 0 ;
36388 int res1 = 0 ;
36389 PyObject *swig_obj[1] ;
36390
36391 if (!args) SWIG_fail;
36392 swig_obj[0] = args;
36393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36394 if (!SWIG_IsOK(res1)) {
36395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36396 }
36397 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36398 {
36399 PyThreadState* __tstate = wxPyBeginAllowThreads();
36400 result = ((wxDisplay const *)arg1)->GetClientArea();
36401 wxPyEndAllowThreads(__tstate);
36402 if (PyErr_Occurred()) SWIG_fail;
36403 }
36404 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36405 return resultobj;
36406 fail:
36407 return NULL;
36408 }
36409
36410
36411 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36412 PyObject *resultobj = 0;
36413 wxDisplay *arg1 = (wxDisplay *) 0 ;
36414 wxString result;
36415 void *argp1 = 0 ;
36416 int res1 = 0 ;
36417 PyObject *swig_obj[1] ;
36418
36419 if (!args) SWIG_fail;
36420 swig_obj[0] = args;
36421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36422 if (!SWIG_IsOK(res1)) {
36423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36424 }
36425 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36426 {
36427 PyThreadState* __tstate = wxPyBeginAllowThreads();
36428 result = ((wxDisplay const *)arg1)->GetName();
36429 wxPyEndAllowThreads(__tstate);
36430 if (PyErr_Occurred()) SWIG_fail;
36431 }
36432 {
36433 #if wxUSE_UNICODE
36434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36435 #else
36436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36437 #endif
36438 }
36439 return resultobj;
36440 fail:
36441 return NULL;
36442 }
36443
36444
36445 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36446 PyObject *resultobj = 0;
36447 wxDisplay *arg1 = (wxDisplay *) 0 ;
36448 bool result;
36449 void *argp1 = 0 ;
36450 int res1 = 0 ;
36451 PyObject *swig_obj[1] ;
36452
36453 if (!args) SWIG_fail;
36454 swig_obj[0] = args;
36455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36456 if (!SWIG_IsOK(res1)) {
36457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36458 }
36459 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36460 {
36461 PyThreadState* __tstate = wxPyBeginAllowThreads();
36462 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36463 wxPyEndAllowThreads(__tstate);
36464 if (PyErr_Occurred()) SWIG_fail;
36465 }
36466 {
36467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36468 }
36469 return resultobj;
36470 fail:
36471 return NULL;
36472 }
36473
36474
36475 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36476 PyObject *resultobj = 0;
36477 wxDisplay *arg1 = (wxDisplay *) 0 ;
36478 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36479 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36480 PyObject *result = 0 ;
36481 void *argp1 = 0 ;
36482 int res1 = 0 ;
36483 void *argp2 = 0 ;
36484 int res2 = 0 ;
36485 PyObject * obj0 = 0 ;
36486 PyObject * obj1 = 0 ;
36487 char * kwnames[] = {
36488 (char *) "self",(char *) "mode", NULL
36489 };
36490
36491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36493 if (!SWIG_IsOK(res1)) {
36494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36495 }
36496 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36497 if (obj1) {
36498 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36499 if (!SWIG_IsOK(res2)) {
36500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36501 }
36502 if (!argp2) {
36503 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36504 }
36505 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36506 }
36507 {
36508 PyThreadState* __tstate = wxPyBeginAllowThreads();
36509 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36510 wxPyEndAllowThreads(__tstate);
36511 if (PyErr_Occurred()) SWIG_fail;
36512 }
36513 resultobj = result;
36514 return resultobj;
36515 fail:
36516 return NULL;
36517 }
36518
36519
36520 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36521 PyObject *resultobj = 0;
36522 wxDisplay *arg1 = (wxDisplay *) 0 ;
36523 wxVideoMode result;
36524 void *argp1 = 0 ;
36525 int res1 = 0 ;
36526 PyObject *swig_obj[1] ;
36527
36528 if (!args) SWIG_fail;
36529 swig_obj[0] = args;
36530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36531 if (!SWIG_IsOK(res1)) {
36532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36533 }
36534 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36535 {
36536 PyThreadState* __tstate = wxPyBeginAllowThreads();
36537 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36538 wxPyEndAllowThreads(__tstate);
36539 if (PyErr_Occurred()) SWIG_fail;
36540 }
36541 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36542 return resultobj;
36543 fail:
36544 return NULL;
36545 }
36546
36547
36548 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36549 PyObject *resultobj = 0;
36550 wxDisplay *arg1 = (wxDisplay *) 0 ;
36551 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36552 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36553 bool result;
36554 void *argp1 = 0 ;
36555 int res1 = 0 ;
36556 void *argp2 = 0 ;
36557 int res2 = 0 ;
36558 PyObject * obj0 = 0 ;
36559 PyObject * obj1 = 0 ;
36560 char * kwnames[] = {
36561 (char *) "self",(char *) "mode", NULL
36562 };
36563
36564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36566 if (!SWIG_IsOK(res1)) {
36567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36568 }
36569 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36570 if (obj1) {
36571 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36572 if (!SWIG_IsOK(res2)) {
36573 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36574 }
36575 if (!argp2) {
36576 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36577 }
36578 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36579 }
36580 {
36581 PyThreadState* __tstate = wxPyBeginAllowThreads();
36582 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36583 wxPyEndAllowThreads(__tstate);
36584 if (PyErr_Occurred()) SWIG_fail;
36585 }
36586 {
36587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36588 }
36589 return resultobj;
36590 fail:
36591 return NULL;
36592 }
36593
36594
36595 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36596 PyObject *resultobj = 0;
36597 wxDisplay *arg1 = (wxDisplay *) 0 ;
36598 void *argp1 = 0 ;
36599 int res1 = 0 ;
36600 PyObject *swig_obj[1] ;
36601
36602 if (!args) SWIG_fail;
36603 swig_obj[0] = args;
36604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36605 if (!SWIG_IsOK(res1)) {
36606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36607 }
36608 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36609 {
36610 PyThreadState* __tstate = wxPyBeginAllowThreads();
36611 wxDisplay_ResetMode(arg1);
36612 wxPyEndAllowThreads(__tstate);
36613 if (PyErr_Occurred()) SWIG_fail;
36614 }
36615 resultobj = SWIG_Py_Void();
36616 return resultobj;
36617 fail:
36618 return NULL;
36619 }
36620
36621
36622 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36623 PyObject *obj;
36624 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36625 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36626 return SWIG_Py_Void();
36627 }
36628
36629 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36630 return SWIG_Python_InitShadowInstance(args);
36631 }
36632
36633 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36634 PyObject *resultobj = 0;
36635 wxStandardPaths *result = 0 ;
36636
36637 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36638 {
36639 PyThreadState* __tstate = wxPyBeginAllowThreads();
36640 result = (wxStandardPaths *)wxStandardPaths_Get();
36641 wxPyEndAllowThreads(__tstate);
36642 if (PyErr_Occurred()) SWIG_fail;
36643 }
36644 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36645 return resultobj;
36646 fail:
36647 return NULL;
36648 }
36649
36650
36651 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36652 PyObject *resultobj = 0;
36653 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36654 wxString result;
36655 void *argp1 = 0 ;
36656 int res1 = 0 ;
36657 PyObject *swig_obj[1] ;
36658
36659 if (!args) SWIG_fail;
36660 swig_obj[0] = args;
36661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36662 if (!SWIG_IsOK(res1)) {
36663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36664 }
36665 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36666 {
36667 PyThreadState* __tstate = wxPyBeginAllowThreads();
36668 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36669 wxPyEndAllowThreads(__tstate);
36670 if (PyErr_Occurred()) SWIG_fail;
36671 }
36672 {
36673 #if wxUSE_UNICODE
36674 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36675 #else
36676 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36677 #endif
36678 }
36679 return resultobj;
36680 fail:
36681 return NULL;
36682 }
36683
36684
36685 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36686 PyObject *resultobj = 0;
36687 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36688 wxString result;
36689 void *argp1 = 0 ;
36690 int res1 = 0 ;
36691 PyObject *swig_obj[1] ;
36692
36693 if (!args) SWIG_fail;
36694 swig_obj[0] = args;
36695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36696 if (!SWIG_IsOK(res1)) {
36697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36698 }
36699 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36700 {
36701 PyThreadState* __tstate = wxPyBeginAllowThreads();
36702 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36703 wxPyEndAllowThreads(__tstate);
36704 if (PyErr_Occurred()) SWIG_fail;
36705 }
36706 {
36707 #if wxUSE_UNICODE
36708 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36709 #else
36710 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36711 #endif
36712 }
36713 return resultobj;
36714 fail:
36715 return NULL;
36716 }
36717
36718
36719 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36720 PyObject *resultobj = 0;
36721 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36722 wxString result;
36723 void *argp1 = 0 ;
36724 int res1 = 0 ;
36725 PyObject *swig_obj[1] ;
36726
36727 if (!args) SWIG_fail;
36728 swig_obj[0] = args;
36729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36730 if (!SWIG_IsOK(res1)) {
36731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36732 }
36733 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36734 {
36735 PyThreadState* __tstate = wxPyBeginAllowThreads();
36736 result = ((wxStandardPaths const *)arg1)->GetDataDir();
36737 wxPyEndAllowThreads(__tstate);
36738 if (PyErr_Occurred()) SWIG_fail;
36739 }
36740 {
36741 #if wxUSE_UNICODE
36742 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36743 #else
36744 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36745 #endif
36746 }
36747 return resultobj;
36748 fail:
36749 return NULL;
36750 }
36751
36752
36753 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36754 PyObject *resultobj = 0;
36755 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36756 wxString result;
36757 void *argp1 = 0 ;
36758 int res1 = 0 ;
36759 PyObject *swig_obj[1] ;
36760
36761 if (!args) SWIG_fail;
36762 swig_obj[0] = args;
36763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36764 if (!SWIG_IsOK(res1)) {
36765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36766 }
36767 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36768 {
36769 PyThreadState* __tstate = wxPyBeginAllowThreads();
36770 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
36771 wxPyEndAllowThreads(__tstate);
36772 if (PyErr_Occurred()) SWIG_fail;
36773 }
36774 {
36775 #if wxUSE_UNICODE
36776 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36777 #else
36778 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36779 #endif
36780 }
36781 return resultobj;
36782 fail:
36783 return NULL;
36784 }
36785
36786
36787 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36788 PyObject *resultobj = 0;
36789 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36790 wxString result;
36791 void *argp1 = 0 ;
36792 int res1 = 0 ;
36793 PyObject *swig_obj[1] ;
36794
36795 if (!args) SWIG_fail;
36796 swig_obj[0] = args;
36797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36798 if (!SWIG_IsOK(res1)) {
36799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36800 }
36801 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36802 {
36803 PyThreadState* __tstate = wxPyBeginAllowThreads();
36804 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
36805 wxPyEndAllowThreads(__tstate);
36806 if (PyErr_Occurred()) SWIG_fail;
36807 }
36808 {
36809 #if wxUSE_UNICODE
36810 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36811 #else
36812 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36813 #endif
36814 }
36815 return resultobj;
36816 fail:
36817 return NULL;
36818 }
36819
36820
36821 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36822 PyObject *resultobj = 0;
36823 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36824 wxString result;
36825 void *argp1 = 0 ;
36826 int res1 = 0 ;
36827 PyObject *swig_obj[1] ;
36828
36829 if (!args) SWIG_fail;
36830 swig_obj[0] = args;
36831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36832 if (!SWIG_IsOK(res1)) {
36833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36834 }
36835 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36836 {
36837 PyThreadState* __tstate = wxPyBeginAllowThreads();
36838 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
36839 wxPyEndAllowThreads(__tstate);
36840 if (PyErr_Occurred()) SWIG_fail;
36841 }
36842 {
36843 #if wxUSE_UNICODE
36844 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36845 #else
36846 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36847 #endif
36848 }
36849 return resultobj;
36850 fail:
36851 return NULL;
36852 }
36853
36854
36855 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36856 PyObject *resultobj = 0;
36857 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36858 wxString result;
36859 void *argp1 = 0 ;
36860 int res1 = 0 ;
36861 PyObject *swig_obj[1] ;
36862
36863 if (!args) SWIG_fail;
36864 swig_obj[0] = args;
36865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36866 if (!SWIG_IsOK(res1)) {
36867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36868 }
36869 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36870 {
36871 PyThreadState* __tstate = wxPyBeginAllowThreads();
36872 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
36873 wxPyEndAllowThreads(__tstate);
36874 if (PyErr_Occurred()) SWIG_fail;
36875 }
36876 {
36877 #if wxUSE_UNICODE
36878 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36879 #else
36880 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36881 #endif
36882 }
36883 return resultobj;
36884 fail:
36885 return NULL;
36886 }
36887
36888
36889 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36890 PyObject *resultobj = 0;
36891 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36892 wxString result;
36893 void *argp1 = 0 ;
36894 int res1 = 0 ;
36895 PyObject *swig_obj[1] ;
36896
36897 if (!args) SWIG_fail;
36898 swig_obj[0] = args;
36899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36900 if (!SWIG_IsOK(res1)) {
36901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36902 }
36903 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36904 {
36905 PyThreadState* __tstate = wxPyBeginAllowThreads();
36906 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
36907 wxPyEndAllowThreads(__tstate);
36908 if (PyErr_Occurred()) SWIG_fail;
36909 }
36910 {
36911 #if wxUSE_UNICODE
36912 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36913 #else
36914 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36915 #endif
36916 }
36917 return resultobj;
36918 fail:
36919 return NULL;
36920 }
36921
36922
36923 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36924 PyObject *resultobj = 0;
36925 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36926 wxString *arg2 = 0 ;
36927 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
36928 wxString result;
36929 void *argp1 = 0 ;
36930 int res1 = 0 ;
36931 bool temp2 = false ;
36932 int val3 ;
36933 int ecode3 = 0 ;
36934 PyObject * obj0 = 0 ;
36935 PyObject * obj1 = 0 ;
36936 PyObject * obj2 = 0 ;
36937 char * kwnames[] = {
36938 (char *) "self",(char *) "lang",(char *) "category", NULL
36939 };
36940
36941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36943 if (!SWIG_IsOK(res1)) {
36944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36945 }
36946 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36947 {
36948 arg2 = wxString_in_helper(obj1);
36949 if (arg2 == NULL) SWIG_fail;
36950 temp2 = true;
36951 }
36952 if (obj2) {
36953 ecode3 = SWIG_AsVal_int(obj2, &val3);
36954 if (!SWIG_IsOK(ecode3)) {
36955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
36956 }
36957 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
36958 }
36959 {
36960 PyThreadState* __tstate = wxPyBeginAllowThreads();
36961 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
36962 wxPyEndAllowThreads(__tstate);
36963 if (PyErr_Occurred()) SWIG_fail;
36964 }
36965 {
36966 #if wxUSE_UNICODE
36967 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36968 #else
36969 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36970 #endif
36971 }
36972 {
36973 if (temp2)
36974 delete arg2;
36975 }
36976 return resultobj;
36977 fail:
36978 {
36979 if (temp2)
36980 delete arg2;
36981 }
36982 return NULL;
36983 }
36984
36985
36986 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36987 PyObject *resultobj = 0;
36988 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36989 wxString result;
36990 void *argp1 = 0 ;
36991 int res1 = 0 ;
36992 PyObject *swig_obj[1] ;
36993
36994 if (!args) SWIG_fail;
36995 swig_obj[0] = args;
36996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36997 if (!SWIG_IsOK(res1)) {
36998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36999 }
37000 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37001 {
37002 PyThreadState* __tstate = wxPyBeginAllowThreads();
37003 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37004 wxPyEndAllowThreads(__tstate);
37005 if (PyErr_Occurred()) SWIG_fail;
37006 }
37007 {
37008 #if wxUSE_UNICODE
37009 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37010 #else
37011 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37012 #endif
37013 }
37014 return resultobj;
37015 fail:
37016 return NULL;
37017 }
37018
37019
37020 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37021 PyObject *resultobj = 0;
37022 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37023 wxString *arg2 = 0 ;
37024 void *argp1 = 0 ;
37025 int res1 = 0 ;
37026 bool temp2 = false ;
37027 PyObject * obj0 = 0 ;
37028 PyObject * obj1 = 0 ;
37029 char * kwnames[] = {
37030 (char *) "self",(char *) "prefix", NULL
37031 };
37032
37033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37035 if (!SWIG_IsOK(res1)) {
37036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37037 }
37038 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37039 {
37040 arg2 = wxString_in_helper(obj1);
37041 if (arg2 == NULL) SWIG_fail;
37042 temp2 = true;
37043 }
37044 {
37045 PyThreadState* __tstate = wxPyBeginAllowThreads();
37046 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
37047 wxPyEndAllowThreads(__tstate);
37048 if (PyErr_Occurred()) SWIG_fail;
37049 }
37050 resultobj = SWIG_Py_Void();
37051 {
37052 if (temp2)
37053 delete arg2;
37054 }
37055 return resultobj;
37056 fail:
37057 {
37058 if (temp2)
37059 delete arg2;
37060 }
37061 return NULL;
37062 }
37063
37064
37065 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37066 PyObject *resultobj = 0;
37067 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37068 wxString result;
37069 void *argp1 = 0 ;
37070 int res1 = 0 ;
37071 PyObject *swig_obj[1] ;
37072
37073 if (!args) SWIG_fail;
37074 swig_obj[0] = args;
37075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37076 if (!SWIG_IsOK(res1)) {
37077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37078 }
37079 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37080 {
37081 PyThreadState* __tstate = wxPyBeginAllowThreads();
37082 result = wxStandardPaths_GetInstallPrefix(arg1);
37083 wxPyEndAllowThreads(__tstate);
37084 if (PyErr_Occurred()) SWIG_fail;
37085 }
37086 {
37087 #if wxUSE_UNICODE
37088 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37089 #else
37090 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37091 #endif
37092 }
37093 return resultobj;
37094 fail:
37095 return NULL;
37096 }
37097
37098
37099 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37100 PyObject *obj;
37101 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37102 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37103 return SWIG_Py_Void();
37104 }
37105
37106 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37107 PyObject *resultobj = 0;
37108 wxEventType arg1 ;
37109 wxPowerEvent *result = 0 ;
37110 int val1 ;
37111 int ecode1 = 0 ;
37112 PyObject * obj0 = 0 ;
37113 char * kwnames[] = {
37114 (char *) "evtType", NULL
37115 };
37116
37117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37118 ecode1 = SWIG_AsVal_int(obj0, &val1);
37119 if (!SWIG_IsOK(ecode1)) {
37120 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37121 }
37122 arg1 = static_cast< wxEventType >(val1);
37123 {
37124 PyThreadState* __tstate = wxPyBeginAllowThreads();
37125 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37126 wxPyEndAllowThreads(__tstate);
37127 if (PyErr_Occurred()) SWIG_fail;
37128 }
37129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37130 return resultobj;
37131 fail:
37132 return NULL;
37133 }
37134
37135
37136 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37137 PyObject *resultobj = 0;
37138 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37139 void *argp1 = 0 ;
37140 int res1 = 0 ;
37141 PyObject *swig_obj[1] ;
37142
37143 if (!args) SWIG_fail;
37144 swig_obj[0] = args;
37145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37146 if (!SWIG_IsOK(res1)) {
37147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37148 }
37149 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37150 {
37151 PyThreadState* __tstate = wxPyBeginAllowThreads();
37152 (arg1)->Veto();
37153 wxPyEndAllowThreads(__tstate);
37154 if (PyErr_Occurred()) SWIG_fail;
37155 }
37156 resultobj = SWIG_Py_Void();
37157 return resultobj;
37158 fail:
37159 return NULL;
37160 }
37161
37162
37163 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37164 PyObject *resultobj = 0;
37165 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37166 bool result;
37167 void *argp1 = 0 ;
37168 int res1 = 0 ;
37169 PyObject *swig_obj[1] ;
37170
37171 if (!args) SWIG_fail;
37172 swig_obj[0] = args;
37173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37174 if (!SWIG_IsOK(res1)) {
37175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37176 }
37177 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37178 {
37179 PyThreadState* __tstate = wxPyBeginAllowThreads();
37180 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37181 wxPyEndAllowThreads(__tstate);
37182 if (PyErr_Occurred()) SWIG_fail;
37183 }
37184 {
37185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37186 }
37187 return resultobj;
37188 fail:
37189 return NULL;
37190 }
37191
37192
37193 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37194 PyObject *obj;
37195 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37196 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37197 return SWIG_Py_Void();
37198 }
37199
37200 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37201 return SWIG_Python_InitShadowInstance(args);
37202 }
37203
37204 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37205 PyObject *resultobj = 0;
37206 wxPowerType result;
37207
37208 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37209 {
37210 PyThreadState* __tstate = wxPyBeginAllowThreads();
37211 result = (wxPowerType)wxGetPowerType();
37212 wxPyEndAllowThreads(__tstate);
37213 if (PyErr_Occurred()) SWIG_fail;
37214 }
37215 resultobj = SWIG_From_int(static_cast< int >(result));
37216 return resultobj;
37217 fail:
37218 return NULL;
37219 }
37220
37221
37222 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37223 PyObject *resultobj = 0;
37224 wxBatteryState result;
37225
37226 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37227 {
37228 PyThreadState* __tstate = wxPyBeginAllowThreads();
37229 result = (wxBatteryState)wxGetBatteryState();
37230 wxPyEndAllowThreads(__tstate);
37231 if (PyErr_Occurred()) SWIG_fail;
37232 }
37233 resultobj = SWIG_From_int(static_cast< int >(result));
37234 return resultobj;
37235 fail:
37236 return NULL;
37237 }
37238
37239
37240 static PyMethodDef SwigMethods[] = {
37241 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
37242 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
37243 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
37244 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
37245 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
37246 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
37247 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
37248 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
37249 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
37250 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
37251 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
37252 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
37253 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
37254 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
37255 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
37256 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
37257 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
37258 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
37259 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
37260 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
37261 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
37262 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
37263 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
37264 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
37265 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
37266 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
37267 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
37268 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
37269 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
37270 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
37271 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
37272 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
37273 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
37274 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
37275 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
37276 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
37277 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
37278 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
37279 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
37280 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
37281 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
37282 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
37283 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
37284 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
37285 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
37286 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
37287 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
37288 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
37289 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
37290 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37291 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37292 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37293 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
37294 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37295 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37296 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
37297 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
37298 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
37299 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
37300 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
37301 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
37302 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
37303 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
37304 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
37305 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
37306 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
37307 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
37308 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
37309 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37310 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
37311 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37312 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
37313 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
37314 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
37315 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37316 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37317 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
37318 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
37319 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
37320 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
37321 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
37322 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
37323 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
37324 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
37325 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
37326 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
37327 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
37328 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
37329 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
37330 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
37331 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
37332 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
37333 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
37334 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
37335 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
37336 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
37337 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
37338 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
37339 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
37340 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
37341 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
37342 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
37343 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
37344 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
37345 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
37346 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
37347 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
37348 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
37349 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
37350 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
37351 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
37352 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
37353 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
37354 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
37355 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
37356 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
37357 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
37358 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
37359 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
37360 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
37361 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
37362 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
37363 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
37364 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
37365 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
37366 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
37367 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
37368 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
37369 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
37370 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
37371 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
37372 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
37373 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
37374 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
37375 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
37376 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
37377 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
37378 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
37379 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
37380 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
37381 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37382 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
37383 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
37384 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
37385 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
37386 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
37387 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
37388 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
37389 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37390 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
37391 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
37392 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
37393 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
37394 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37395 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
37396 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
37397 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
37398 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
37399 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
37400 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37401 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
37402 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37403 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
37404 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
37405 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37406 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37407 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
37408 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
37409 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
37410 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
37411 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
37412 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
37413 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
37414 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
37415 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
37416 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
37417 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
37418 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
37419 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
37420 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
37421 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
37422 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
37423 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37424 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37425 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
37426 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
37427 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
37428 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
37429 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
37430 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
37431 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
37432 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
37433 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
37434 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
37435 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
37436 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
37437 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
37438 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
37439 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
37440 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
37441 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
37442 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
37443 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
37444 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
37445 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
37446 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
37447 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
37448 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
37449 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
37450 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
37451 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
37452 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
37453 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
37454 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
37455 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37456 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37457 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
37458 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
37459 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
37460 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37461 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
37462 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
37463 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37464 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
37465 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
37466 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37467 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
37468 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
37469 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
37470 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
37471 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
37472 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
37473 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
37474 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
37475 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37476 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
37477 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
37478 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
37479 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
37480 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
37481 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
37482 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
37483 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
37484 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
37485 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
37486 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
37487 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
37488 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
37489 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
37490 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
37491 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
37492 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
37493 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
37494 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
37495 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
37496 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
37497 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
37498 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
37499 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
37500 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37501 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37502 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37503 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
37504 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
37505 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
37506 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
37507 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
37508 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
37509 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
37510 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
37511 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
37512 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
37513 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
37514 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
37515 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
37516 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
37517 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
37518 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
37519 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
37520 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
37521 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
37522 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
37523 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
37524 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
37525 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
37526 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
37527 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
37528 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
37529 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
37530 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
37531 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
37532 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
37533 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
37534 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
37535 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
37536 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
37537 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
37538 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
37539 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
37540 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
37541 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
37542 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
37543 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
37544 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
37545 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
37546 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
37547 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
37548 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
37549 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37550 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
37551 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
37552 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
37553 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
37554 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
37555 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
37556 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
37557 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
37558 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
37559 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
37560 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
37561 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
37562 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
37563 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37564 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
37565 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
37566 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
37567 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
37568 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
37569 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
37570 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37571 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
37572 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
37573 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
37574 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
37575 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
37576 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
37577 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
37578 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
37579 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
37580 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
37581 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
37582 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
37583 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
37584 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37585 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
37586 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
37587 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
37588 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
37589 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
37590 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
37591 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
37592 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
37593 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
37594 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
37595 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
37596 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
37597 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
37598 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
37599 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
37600 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
37601 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
37602 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
37603 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
37604 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
37605 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
37606 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
37607 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
37608 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
37609 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
37610 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
37611 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
37612 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
37613 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
37614 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
37615 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
37616 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
37617 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
37618 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
37619 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
37620 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
37621 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
37622 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
37623 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
37624 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
37625 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
37626 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
37627 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
37628 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
37629 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
37630 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
37631 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
37632 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
37633 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
37634 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
37635 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
37636 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
37637 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
37638 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
37639 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
37640 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
37641 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37642 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
37643 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
37644 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
37645 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
37646 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
37647 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
37648 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
37649 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
37650 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
37651 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
37652 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
37653 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
37654 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
37655 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
37656 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
37657 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
37658 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
37659 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
37660 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
37661 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
37662 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
37663 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
37664 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
37665 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
37666 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
37667 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
37668 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
37669 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
37670 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
37671 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37672 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
37673 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
37674 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
37675 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37676 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
37677 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
37678 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
37679 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
37680 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
37681 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
37682 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
37683 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
37684 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
37685 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
37686 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
37687 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
37688 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
37689 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
37690 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
37691 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
37692 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
37693 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
37694 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
37695 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
37696 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37697 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37698 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
37699 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37700 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37701 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
37702 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
37703 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
37704 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
37705 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
37706 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
37707 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
37708 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
37709 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
37710 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
37711 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
37712 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
37713 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
37714 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
37715 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
37716 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
37717 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
37718 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
37719 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
37720 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
37721 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
37722 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37723 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37724 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
37725 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
37726 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
37727 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
37728 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
37729 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
37730 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
37731 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
37732 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
37733 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
37734 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
37735 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
37736 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
37737 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
37738 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
37739 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
37740 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37741 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
37742 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37743 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
37744 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
37745 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37746 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37747 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
37748 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
37749 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
37750 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
37751 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
37752 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
37753 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
37754 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
37755 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
37756 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
37757 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
37758 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37759 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37760 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
37761 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
37762 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
37763 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37764 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
37765 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
37766 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
37767 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37768 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
37769 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
37770 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
37771 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
37772 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
37773 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
37774 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
37775 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
37776 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
37777 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
37778 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
37779 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
37780 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
37781 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
37782 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
37783 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
37784 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
37785 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
37786 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
37787 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
37788 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
37789 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
37790 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
37791 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
37792 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
37793 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
37794 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37795 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
37796 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
37797 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
37798 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37799 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
37800 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
37801 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
37802 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
37803 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
37804 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
37805 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
37806 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
37807 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
37808 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
37809 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
37810 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
37811 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
37812 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
37813 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
37814 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
37815 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
37816 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
37817 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
37818 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
37819 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
37820 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
37821 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
37822 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37823 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
37824 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
37825 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
37826 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
37827 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
37828 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37829 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37830 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37831 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37832 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37833 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37834 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37835 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37836 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37837 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37838 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
37839 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
37840 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
37841 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
37842 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
37843 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
37844 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
37845 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
37846 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
37847 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
37848 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
37849 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37850 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37851 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37852 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
37853 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37854 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37855 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
37856 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
37857 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37858 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
37859 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
37860 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
37861 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
37862 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
37863 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37864 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
37865 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
37866 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
37867 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
37868 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
37869 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
37870 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
37871 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
37872 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
37873 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
37874 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
37875 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
37876 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
37877 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
37878 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
37879 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
37880 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
37881 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
37882 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
37883 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
37884 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
37885 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
37886 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
37887 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
37888 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
37889 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
37890 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
37891 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
37892 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
37893 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
37894 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
37895 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37896 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37897 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
37898 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37899 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
37900 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
37901 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
37902 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
37903 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
37904 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
37905 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
37906 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
37907 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
37908 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
37909 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
37910 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
37911 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
37912 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
37913 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
37914 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
37915 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
37916 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
37917 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
37918 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
37919 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
37920 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
37921 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
37922 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
37923 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
37924 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
37925 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
37926 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
37927 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
37928 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
37929 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
37930 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
37931 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
37932 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
37933 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
37934 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
37935 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
37936 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
37937 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
37938 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
37939 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
37940 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37941 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37942 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
37943 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
37944 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
37945 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
37946 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
37947 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
37948 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
37949 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
37950 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
37951 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
37952 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
37953 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
37954 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
37955 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
37956 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
37957 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
37958 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
37959 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
37960 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
37961 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
37962 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
37963 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
37964 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
37965 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
37966 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
37967 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
37968 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
37969 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
37970 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
37971 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
37972 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
37973 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
37974 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
37975 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
37976 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
37977 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
37978 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
37979 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
37980 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
37981 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
37982 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
37983 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
37984 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
37985 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
37986 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
37987 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
37988 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37989 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37990 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
37991 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
37992 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
37993 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
37994 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
37995 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
37996 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37997 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37998 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
37999 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
38000 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
38001 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
38002 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
38003 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
38004 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
38005 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
38006 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
38007 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
38008 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38009 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
38010 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
38011 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
38012 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
38013 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
38014 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38015 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
38016 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
38017 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
38018 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
38019 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
38020 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
38021 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38022 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
38023 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
38024 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
38025 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38026 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
38027 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
38028 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
38029 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
38030 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
38031 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
38032 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
38033 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38034 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
38035 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
38036 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
38037 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
38038 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
38039 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38040 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38041 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
38042 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
38043 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38044 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
38045 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
38046 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
38047 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
38048 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38049 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38050 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
38051 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
38052 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
38053 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
38054 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
38055 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
38056 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
38057 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
38058 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38059 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
38060 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
38061 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
38062 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
38063 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38064 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
38065 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
38066 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
38067 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
38068 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
38069 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
38070 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
38071 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
38072 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
38073 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
38074 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
38075 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38076 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
38077 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38078 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
38079 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
38080 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38081 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
38082 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
38083 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
38084 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
38085 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38086 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
38087 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
38088 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
38089 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38090 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38091 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
38092 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38093 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
38094 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
38095 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
38096 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
38097 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
38098 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
38099 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38100 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
38101 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38102 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38103 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
38104 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38105 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
38106 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
38107 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
38108 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
38109 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
38110 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
38111 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
38112 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
38113 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
38114 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
38115 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
38116 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
38117 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
38118 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
38119 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
38120 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
38121 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
38122 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
38123 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
38124 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
38125 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
38126 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
38127 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
38128 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
38129 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
38130 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
38131 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
38132 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
38133 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
38134 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
38135 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
38136 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
38137 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
38138 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
38139 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
38140 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
38141 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
38142 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
38143 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
38144 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
38145 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
38146 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
38147 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
38148 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
38149 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
38150 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
38151 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
38152 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
38153 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
38154 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
38155 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
38156 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
38157 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
38158 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
38159 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
38160 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
38161 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
38162 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
38163 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
38164 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
38165 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
38166 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
38167 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
38168 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
38169 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
38170 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
38171 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
38172 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
38173 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
38174 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
38175 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
38176 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
38177 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
38178 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
38179 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
38180 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
38181 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
38182 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
38183 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
38184 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
38185 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
38186 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
38187 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
38188 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
38189 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
38190 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
38191 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
38192 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
38193 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
38194 { NULL, NULL, 0, NULL }
38195 };
38196
38197
38198 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
38199
38200 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
38201 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
38202 }
38203 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
38204 return (void *)((wxEvent *) ((wxMenuEvent *) x));
38205 }
38206 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
38207 return (void *)((wxEvent *) ((wxCloseEvent *) x));
38208 }
38209 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
38210 return (void *)((wxEvent *) ((wxMouseEvent *) x));
38211 }
38212 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
38213 return (void *)((wxEvent *) ((wxEraseEvent *) x));
38214 }
38215 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
38216 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
38217 }
38218 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
38219 return (void *)((wxEvent *) ((wxTimerEvent *) x));
38220 }
38221 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
38222 return (void *)((wxEvent *) ((wxPowerEvent *) x));
38223 }
38224 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
38225 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
38226 }
38227 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
38228 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
38229 }
38230 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
38231 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
38232 }
38233 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
38234 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
38235 }
38236 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
38237 return (void *)((wxEvent *) ((wxPyEvent *) x));
38238 }
38239 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
38240 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
38241 }
38242 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
38243 return (void *)((wxEvent *) ((wxIdleEvent *) x));
38244 }
38245 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
38246 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
38247 }
38248 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
38249 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
38250 }
38251 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
38252 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
38253 }
38254 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
38255 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
38256 }
38257 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
38258 return (void *)((wxEvent *) ((wxActivateEvent *) x));
38259 }
38260 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
38261 return (void *)((wxEvent *) ((wxSizeEvent *) x));
38262 }
38263 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
38264 return (void *)((wxEvent *) ((wxMoveEvent *) x));
38265 }
38266 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
38267 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
38268 }
38269 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
38270 return (void *)((wxEvent *) ((wxPaintEvent *) x));
38271 }
38272 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
38273 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
38274 }
38275 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
38276 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
38277 }
38278 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
38279 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
38280 }
38281 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
38282 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
38283 }
38284 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
38285 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
38286 }
38287 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
38288 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
38289 }
38290 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
38291 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
38292 }
38293 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
38294 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
38295 }
38296 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
38297 return (void *)((wxEvent *) ((wxFocusEvent *) x));
38298 }
38299 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
38300 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
38301 }
38302 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
38303 return (void *)((wxEvent *) ((wxProcessEvent *) x));
38304 }
38305 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
38306 return (void *)((wxEvent *) ((wxShowEvent *) x));
38307 }
38308 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
38309 return (void *)((wxEvent *) ((wxCommandEvent *) x));
38310 }
38311 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
38312 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
38313 }
38314 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
38315 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
38316 }
38317 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
38318 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
38319 }
38320 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
38321 return (void *)((wxEvent *) ((wxKeyEvent *) x));
38322 }
38323 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
38324 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
38325 }
38326 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
38327 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
38328 }
38329 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
38330 return (void *)((wxConfigBase *) ((wxConfig *) x));
38331 }
38332 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
38333 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38334 }
38335 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
38336 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
38337 }
38338 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
38339 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
38340 }
38341 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
38342 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
38343 }
38344 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
38345 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
38346 }
38347 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
38348 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
38349 }
38350 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
38351 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
38352 }
38353 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
38354 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
38355 }
38356 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
38357 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38358 }
38359 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
38360 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
38361 }
38362 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
38363 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
38364 }
38365 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
38366 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
38367 }
38368 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
38369 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
38370 }
38371 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
38372 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
38373 }
38374 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
38375 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
38376 }
38377 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
38378 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
38379 }
38380 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
38381 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
38382 }
38383 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
38384 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
38385 }
38386 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
38387 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
38388 }
38389 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
38390 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
38391 }
38392 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
38393 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
38394 }
38395 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
38396 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
38397 }
38398 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
38399 return (void *)((wxEvtHandler *) ((wxWindow *) x));
38400 }
38401 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
38402 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
38403 }
38404 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
38405 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
38406 }
38407 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
38408 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
38409 }
38410 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
38411 return (void *)((wxEvtHandler *) ((wxValidator *) x));
38412 }
38413 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
38414 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
38415 }
38416 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
38417 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
38418 }
38419 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
38420 return (void *)((wxEvtHandler *) ((wxMenu *) x));
38421 }
38422 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
38423 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
38424 }
38425 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
38426 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
38427 }
38428 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
38429 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
38430 }
38431 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
38432 return (void *)((wxObject *) ((wxSizerItem *) x));
38433 }
38434 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
38435 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
38436 }
38437 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
38438 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
38439 }
38440 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
38441 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
38442 }
38443 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
38444 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
38445 }
38446 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
38447 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
38448 }
38449 static void *_p_wxSizerTo_p_wxObject(void *x) {
38450 return (void *)((wxObject *) ((wxSizer *) x));
38451 }
38452 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
38453 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
38454 }
38455 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
38456 return (void *)((wxObject *) ((wxFileHistory *) x));
38457 }
38458 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
38459 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
38460 }
38461 static void *_p_wxEventTo_p_wxObject(void *x) {
38462 return (void *)((wxObject *) ((wxEvent *) x));
38463 }
38464 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
38465 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
38466 }
38467 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
38468 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
38469 }
38470 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
38471 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
38472 }
38473 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
38474 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
38475 }
38476 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
38477 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
38478 }
38479 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
38480 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
38481 }
38482 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
38483 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
38484 }
38485 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
38486 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
38487 }
38488 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
38489 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
38490 }
38491 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
38492 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
38493 }
38494 static void *_p_wxControlTo_p_wxObject(void *x) {
38495 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
38496 }
38497 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
38498 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
38499 }
38500 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
38501 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
38502 }
38503 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
38504 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
38505 }
38506 static void *_p_wxFSFileTo_p_wxObject(void *x) {
38507 return (void *)((wxObject *) ((wxFSFile *) x));
38508 }
38509 static void *_p_wxClipboardTo_p_wxObject(void *x) {
38510 return (void *)((wxObject *) ((wxClipboard *) x));
38511 }
38512 static void *_p_wxPySizerTo_p_wxObject(void *x) {
38513 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
38514 }
38515 static void *_p_wxPyEventTo_p_wxObject(void *x) {
38516 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
38517 }
38518 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
38519 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
38520 }
38521 static void *_p_wxShowEventTo_p_wxObject(void *x) {
38522 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
38523 }
38524 static void *_p_wxToolTipTo_p_wxObject(void *x) {
38525 return (void *)((wxObject *) ((wxToolTip *) x));
38526 }
38527 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
38528 return (void *)((wxObject *) ((wxMenuItem *) x));
38529 }
38530 static void *_p_wxDateEventTo_p_wxObject(void *x) {
38531 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
38532 }
38533 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
38534 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
38535 }
38536 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
38537 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
38538 }
38539 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
38540 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
38541 }
38542 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
38543 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
38544 }
38545 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
38546 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
38547 }
38548 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
38549 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
38550 }
38551 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
38552 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
38553 }
38554 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
38555 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
38556 }
38557 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
38558 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
38559 }
38560 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
38561 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
38562 }
38563 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
38564 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
38565 }
38566 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
38567 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
38568 }
38569 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
38570 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
38571 }
38572 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
38573 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
38574 }
38575 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
38576 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
38577 }
38578 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
38579 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
38580 }
38581 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
38582 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
38583 }
38584 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
38585 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
38586 }
38587 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
38588 return (void *)((wxObject *) ((wxImageHandler *) x));
38589 }
38590 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
38591 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
38592 }
38593 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
38594 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
38595 }
38596 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
38597 return (void *)((wxObject *) ((wxEvtHandler *) x));
38598 }
38599 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
38600 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
38601 }
38602 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
38603 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
38604 }
38605 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
38606 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
38607 }
38608 static void *_p_wxImageTo_p_wxObject(void *x) {
38609 return (void *)((wxObject *) ((wxImage *) x));
38610 }
38611 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
38612 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
38613 }
38614 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
38615 return (void *)((wxObject *) ((wxSystemOptions *) x));
38616 }
38617 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
38618 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
38619 }
38620 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
38621 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
38622 }
38623 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
38624 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
38625 }
38626 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
38627 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
38628 }
38629 static void *_p_wxWindowTo_p_wxObject(void *x) {
38630 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
38631 }
38632 static void *_p_wxMenuTo_p_wxObject(void *x) {
38633 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
38634 }
38635 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
38636 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
38637 }
38638 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
38639 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
38640 }
38641 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
38642 return (void *)((wxObject *) ((wxFileSystem *) x));
38643 }
38644 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
38645 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
38646 }
38647 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
38648 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
38649 }
38650 static void *_p_wxPyAppTo_p_wxObject(void *x) {
38651 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
38652 }
38653 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
38654 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
38655 }
38656 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
38657 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
38658 }
38659 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
38660 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
38661 }
38662 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
38663 return (void *)((wxObject *) ((wxBusyInfo *) x));
38664 }
38665 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
38666 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
38667 }
38668 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
38669 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
38670 }
38671 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
38672 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
38673 }
38674 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
38675 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
38676 }
38677 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
38678 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
38679 }
38680 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
38681 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
38682 }
38683 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
38684 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
38685 }
38686 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
38687 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
38688 }
38689 static void *_p_wxValidatorTo_p_wxObject(void *x) {
38690 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
38691 }
38692 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
38693 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
38694 }
38695 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
38696 return (void *)((wxLog *) ((wxLogBuffer *) x));
38697 }
38698 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
38699 return (void *)((wxLog *) ((wxLogStderr *) x));
38700 }
38701 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
38702 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
38703 }
38704 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
38705 return (void *)((wxLog *) ((wxLogWindow *) x));
38706 }
38707 static void *_p_wxLogChainTo_p_wxLog(void *x) {
38708 return (void *)((wxLog *) ((wxLogChain *) x));
38709 }
38710 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
38711 return (void *)((wxLog *) ((wxLogGui *) x));
38712 }
38713 static void *_p_wxPyLogTo_p_wxLog(void *x) {
38714 return (void *)((wxLog *) ((wxPyLog *) x));
38715 }
38716 static void *_p_wxControlTo_p_wxWindow(void *x) {
38717 return (void *)((wxWindow *) ((wxControl *) x));
38718 }
38719 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
38720 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
38721 }
38722 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
38723 return (void *)((wxWindow *) ((wxMenuBar *) x));
38724 }
38725 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
38726 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
38727 }
38728 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
38729 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
38730 }
38731 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
38732 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};
38733 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
38734 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
38735 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
38736 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
38737 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
38738 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
38739 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
38740 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
38741 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
38742 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
38743 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
38744 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
38745 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
38746 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
38747 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
38748 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
38749 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
38750 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
38751 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
38752 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
38753 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
38754 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
38755 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
38756 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
38757 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
38758 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
38759 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
38760 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
38761 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
38762 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
38763 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
38764 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
38765 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
38766 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
38767 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
38768 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
38769 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
38770 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
38771 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
38772 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
38773 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
38774 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
38775 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
38776 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
38777 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
38778 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
38779 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
38780 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
38781 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
38782 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
38783 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
38784 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
38785 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
38786 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
38787 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
38788 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
38789 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
38790 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
38791 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
38792 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
38793 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
38794 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
38795 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
38796 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
38797 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
38798 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
38799 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
38800 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
38801 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
38802 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
38803 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
38804 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
38805 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
38806 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
38807 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
38808 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
38809 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
38810 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
38811 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
38812 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
38813 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
38814 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
38815 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
38816 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
38817 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
38818 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
38819 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
38820 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
38821 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
38822 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
38823 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
38824 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
38825 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
38826 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
38827 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
38828 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
38829 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
38830 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
38831 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
38832 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
38833 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
38834 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
38835 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
38836 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
38837 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
38838 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
38839 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
38840 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
38841 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
38842 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
38843 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
38844 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
38845 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
38846 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
38847 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
38848 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
38849 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
38850 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
38851 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
38852 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
38853 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
38854 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
38855 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
38856 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
38857 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
38858 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
38859 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
38860 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
38861 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
38862 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
38863 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
38864 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
38865 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
38866 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
38867 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
38868 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
38869 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
38870 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
38871 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
38872 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
38873 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
38874 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
38875 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
38876 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
38877 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
38878 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
38879 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
38880 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
38881 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
38882 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
38883 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
38884 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
38885 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
38886 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
38887 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
38888 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
38889 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
38890 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
38891 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
38892 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
38893 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
38894 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
38895 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
38896 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
38897 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
38898 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
38899 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
38900 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
38901 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
38902 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
38903 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
38904
38905 static swig_type_info *swig_type_initial[] = {
38906 &_swigt__p_char,
38907 &_swigt__p_form_ops_t,
38908 &_swigt__p_int,
38909 &_swigt__p_unsigned_char,
38910 &_swigt__p_unsigned_int,
38911 &_swigt__p_unsigned_long,
38912 &_swigt__p_void,
38913 &_swigt__p_wxANIHandler,
38914 &_swigt__p_wxAcceleratorTable,
38915 &_swigt__p_wxActivateEvent,
38916 &_swigt__p_wxArrayString,
38917 &_swigt__p_wxBMPHandler,
38918 &_swigt__p_wxBitmap,
38919 &_swigt__p_wxBitmapDataObject,
38920 &_swigt__p_wxBoxSizer,
38921 &_swigt__p_wxBusyCursor,
38922 &_swigt__p_wxBusyInfo,
38923 &_swigt__p_wxCURHandler,
38924 &_swigt__p_wxCaret,
38925 &_swigt__p_wxChar,
38926 &_swigt__p_wxChildFocusEvent,
38927 &_swigt__p_wxClipboard,
38928 &_swigt__p_wxClipboardLocker,
38929 &_swigt__p_wxClipboardTextEvent,
38930 &_swigt__p_wxCloseEvent,
38931 &_swigt__p_wxColour,
38932 &_swigt__p_wxCommandEvent,
38933 &_swigt__p_wxConfig,
38934 &_swigt__p_wxConfigBase,
38935 &_swigt__p_wxConfigPathChanger,
38936 &_swigt__p_wxContextMenuEvent,
38937 &_swigt__p_wxControl,
38938 &_swigt__p_wxControlWithItems,
38939 &_swigt__p_wxCursor,
38940 &_swigt__p_wxCustomDataObject,
38941 &_swigt__p_wxDC,
38942 &_swigt__p_wxDataFormat,
38943 &_swigt__p_wxDataObject,
38944 &_swigt__p_wxDataObjectComposite,
38945 &_swigt__p_wxDataObjectSimple,
38946 &_swigt__p_wxDateEvent,
38947 &_swigt__p_wxDateSpan,
38948 &_swigt__p_wxDateTime,
38949 &_swigt__p_wxDateTime__TimeZone,
38950 &_swigt__p_wxDisplay,
38951 &_swigt__p_wxDisplayChangedEvent,
38952 &_swigt__p_wxDropFilesEvent,
38953 &_swigt__p_wxDuplexMode,
38954 &_swigt__p_wxEraseEvent,
38955 &_swigt__p_wxEvent,
38956 &_swigt__p_wxEvtHandler,
38957 &_swigt__p_wxFSFile,
38958 &_swigt__p_wxFileConfig,
38959 &_swigt__p_wxFileDataObject,
38960 &_swigt__p_wxFileHistory,
38961 &_swigt__p_wxFileSystem,
38962 &_swigt__p_wxFileType,
38963 &_swigt__p_wxFileTypeInfo,
38964 &_swigt__p_wxFlexGridSizer,
38965 &_swigt__p_wxFocusEvent,
38966 &_swigt__p_wxFont,
38967 &_swigt__p_wxFrame,
38968 &_swigt__p_wxGBSizerItem,
38969 &_swigt__p_wxGIFHandler,
38970 &_swigt__p_wxGridBagSizer,
38971 &_swigt__p_wxGridSizer,
38972 &_swigt__p_wxICOHandler,
38973 &_swigt__p_wxIcon,
38974 &_swigt__p_wxIconizeEvent,
38975 &_swigt__p_wxIdleEvent,
38976 &_swigt__p_wxImage,
38977 &_swigt__p_wxImageHandler,
38978 &_swigt__p_wxIndividualLayoutConstraint,
38979 &_swigt__p_wxInitDialogEvent,
38980 &_swigt__p_wxJPEGHandler,
38981 &_swigt__p_wxJoystick,
38982 &_swigt__p_wxJoystickEvent,
38983 &_swigt__p_wxKeyEvent,
38984 &_swigt__p_wxKillError,
38985 &_swigt__p_wxLayoutConstraints,
38986 &_swigt__p_wxLog,
38987 &_swigt__p_wxLogBuffer,
38988 &_swigt__p_wxLogChain,
38989 &_swigt__p_wxLogGui,
38990 &_swigt__p_wxLogNull,
38991 &_swigt__p_wxLogStderr,
38992 &_swigt__p_wxLogTextCtrl,
38993 &_swigt__p_wxLogWindow,
38994 &_swigt__p_wxMaximizeEvent,
38995 &_swigt__p_wxMenu,
38996 &_swigt__p_wxMenuBar,
38997 &_swigt__p_wxMenuEvent,
38998 &_swigt__p_wxMenuItem,
38999 &_swigt__p_wxMetafile,
39000 &_swigt__p_wxMetafileDataObject,
39001 &_swigt__p_wxMimeTypesManager,
39002 &_swigt__p_wxMouseCaptureChangedEvent,
39003 &_swigt__p_wxMouseCaptureLostEvent,
39004 &_swigt__p_wxMouseEvent,
39005 &_swigt__p_wxMouseState,
39006 &_swigt__p_wxMoveEvent,
39007 &_swigt__p_wxMutexGuiLocker,
39008 &_swigt__p_wxNavigationKeyEvent,
39009 &_swigt__p_wxNcPaintEvent,
39010 &_swigt__p_wxNotifyEvent,
39011 &_swigt__p_wxObject,
39012 &_swigt__p_wxOutputStream,
39013 &_swigt__p_wxPCXHandler,
39014 &_swigt__p_wxPNGHandler,
39015 &_swigt__p_wxPNMHandler,
39016 &_swigt__p_wxPaintEvent,
39017 &_swigt__p_wxPaletteChangedEvent,
39018 &_swigt__p_wxPaperSize,
39019 &_swigt__p_wxPlatformInfo,
39020 &_swigt__p_wxPoint,
39021 &_swigt__p_wxPowerEvent,
39022 &_swigt__p_wxProcessEvent,
39023 &_swigt__p_wxPyApp,
39024 &_swigt__p_wxPyArtProvider,
39025 &_swigt__p_wxPyBitmapDataObject,
39026 &_swigt__p_wxPyCommandEvent,
39027 &_swigt__p_wxPyDataObjectSimple,
39028 &_swigt__p_wxPyDropSource,
39029 &_swigt__p_wxPyDropTarget,
39030 &_swigt__p_wxPyEvent,
39031 &_swigt__p_wxPyFileDropTarget,
39032 &_swigt__p_wxPyImageHandler,
39033 &_swigt__p_wxPyLog,
39034 &_swigt__p_wxPyProcess,
39035 &_swigt__p_wxPySizer,
39036 &_swigt__p_wxPyTextDataObject,
39037 &_swigt__p_wxPyTextDropTarget,
39038 &_swigt__p_wxPyTimer,
39039 &_swigt__p_wxPyTipProvider,
39040 &_swigt__p_wxPyValidator,
39041 &_swigt__p_wxQueryNewPaletteEvent,
39042 &_swigt__p_wxRect,
39043 &_swigt__p_wxScrollEvent,
39044 &_swigt__p_wxScrollWinEvent,
39045 &_swigt__p_wxSetCursorEvent,
39046 &_swigt__p_wxShowEvent,
39047 &_swigt__p_wxSingleInstanceChecker,
39048 &_swigt__p_wxSize,
39049 &_swigt__p_wxSizeEvent,
39050 &_swigt__p_wxSizer,
39051 &_swigt__p_wxSizerItem,
39052 &_swigt__p_wxSound,
39053 &_swigt__p_wxStandardPaths,
39054 &_swigt__p_wxStaticBoxSizer,
39055 &_swigt__p_wxStdDialogButtonSizer,
39056 &_swigt__p_wxStopWatch,
39057 &_swigt__p_wxString,
39058 &_swigt__p_wxSysColourChangedEvent,
39059 &_swigt__p_wxSystemOptions,
39060 &_swigt__p_wxSystemSettings,
39061 &_swigt__p_wxTIFFHandler,
39062 &_swigt__p_wxTextCtrl,
39063 &_swigt__p_wxTextDataObject,
39064 &_swigt__p_wxTimeSpan,
39065 &_swigt__p_wxTimer,
39066 &_swigt__p_wxTimerEvent,
39067 &_swigt__p_wxTimerRunner,
39068 &_swigt__p_wxTipProvider,
39069 &_swigt__p_wxToolTip,
39070 &_swigt__p_wxURLDataObject,
39071 &_swigt__p_wxUpdateUIEvent,
39072 &_swigt__p_wxValidator,
39073 &_swigt__p_wxVideoMode,
39074 &_swigt__p_wxWindow,
39075 &_swigt__p_wxWindowCreateEvent,
39076 &_swigt__p_wxWindowDestroyEvent,
39077 &_swigt__p_wxWindowDisabler,
39078 &_swigt__p_wxXPMHandler,
39079 };
39080
39081 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
39082 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
39083 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
39084 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
39085 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
39086 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
39087 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
39088 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
39089 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
39090 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}};
39091 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
39092 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
39093 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
39094 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
39095 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
39096 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
39097 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
39098 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
39099 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}};
39100 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
39101 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
39102 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
39103 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
39104 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
39105 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}};
39106 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
39107 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}};
39108 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
39109 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
39110 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
39111 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
39112 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
39113 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
39114 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
39115 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
39116 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
39117 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
39118 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
39119 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
39120 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
39121 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
39122 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
39123 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
39124 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
39125 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
39126 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
39127 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39128 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39129 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
39130 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
39131 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
39132 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
39133 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
39134 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
39135 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
39136 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
39137 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39138 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39139 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39140 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
39141 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
39142 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
39143 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
39144 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
39145 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
39146 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
39147 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
39148 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
39149 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
39150 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
39151 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
39152 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
39153 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
39154 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
39155 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
39156 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
39157 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
39158 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}};
39159 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
39160 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
39161 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
39162 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
39163 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
39164 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
39165 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
39166 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
39167 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
39168 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
39169 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
39170 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}};
39171 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
39172 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
39173 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
39174 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
39175 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
39176 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
39177 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
39178 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
39179 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
39180 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
39181 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
39182 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
39183 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
39184 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
39185 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
39186 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
39187 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
39188 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
39189 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
39190 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
39191 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
39192 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
39193 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
39194 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
39195 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
39196 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
39197 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
39198 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
39199 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
39200 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
39201 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
39202 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
39203 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
39204 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
39205 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
39206 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
39207 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
39208 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
39209 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
39210 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
39211 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
39212 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
39213 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
39214 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
39215 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
39216 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
39217 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
39218 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
39219 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
39220 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
39221 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
39222 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
39223 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
39224 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
39225 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}};
39226 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
39227 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
39228 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
39229 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
39230 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
39231 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
39232 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
39233 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
39234 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
39235 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
39236 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
39237 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
39238 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
39239 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
39240 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
39241 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
39242 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
39243 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}};
39244 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
39245 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
39246 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
39247 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
39248 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}};
39249 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
39250 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
39251 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
39252 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}};
39253 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
39254
39255 static swig_cast_info *swig_cast_initial[] = {
39256 _swigc__p_char,
39257 _swigc__p_form_ops_t,
39258 _swigc__p_int,
39259 _swigc__p_unsigned_char,
39260 _swigc__p_unsigned_int,
39261 _swigc__p_unsigned_long,
39262 _swigc__p_void,
39263 _swigc__p_wxANIHandler,
39264 _swigc__p_wxAcceleratorTable,
39265 _swigc__p_wxActivateEvent,
39266 _swigc__p_wxArrayString,
39267 _swigc__p_wxBMPHandler,
39268 _swigc__p_wxBitmap,
39269 _swigc__p_wxBitmapDataObject,
39270 _swigc__p_wxBoxSizer,
39271 _swigc__p_wxBusyCursor,
39272 _swigc__p_wxBusyInfo,
39273 _swigc__p_wxCURHandler,
39274 _swigc__p_wxCaret,
39275 _swigc__p_wxChar,
39276 _swigc__p_wxChildFocusEvent,
39277 _swigc__p_wxClipboard,
39278 _swigc__p_wxClipboardLocker,
39279 _swigc__p_wxClipboardTextEvent,
39280 _swigc__p_wxCloseEvent,
39281 _swigc__p_wxColour,
39282 _swigc__p_wxCommandEvent,
39283 _swigc__p_wxConfig,
39284 _swigc__p_wxConfigBase,
39285 _swigc__p_wxConfigPathChanger,
39286 _swigc__p_wxContextMenuEvent,
39287 _swigc__p_wxControl,
39288 _swigc__p_wxControlWithItems,
39289 _swigc__p_wxCursor,
39290 _swigc__p_wxCustomDataObject,
39291 _swigc__p_wxDC,
39292 _swigc__p_wxDataFormat,
39293 _swigc__p_wxDataObject,
39294 _swigc__p_wxDataObjectComposite,
39295 _swigc__p_wxDataObjectSimple,
39296 _swigc__p_wxDateEvent,
39297 _swigc__p_wxDateSpan,
39298 _swigc__p_wxDateTime,
39299 _swigc__p_wxDateTime__TimeZone,
39300 _swigc__p_wxDisplay,
39301 _swigc__p_wxDisplayChangedEvent,
39302 _swigc__p_wxDropFilesEvent,
39303 _swigc__p_wxDuplexMode,
39304 _swigc__p_wxEraseEvent,
39305 _swigc__p_wxEvent,
39306 _swigc__p_wxEvtHandler,
39307 _swigc__p_wxFSFile,
39308 _swigc__p_wxFileConfig,
39309 _swigc__p_wxFileDataObject,
39310 _swigc__p_wxFileHistory,
39311 _swigc__p_wxFileSystem,
39312 _swigc__p_wxFileType,
39313 _swigc__p_wxFileTypeInfo,
39314 _swigc__p_wxFlexGridSizer,
39315 _swigc__p_wxFocusEvent,
39316 _swigc__p_wxFont,
39317 _swigc__p_wxFrame,
39318 _swigc__p_wxGBSizerItem,
39319 _swigc__p_wxGIFHandler,
39320 _swigc__p_wxGridBagSizer,
39321 _swigc__p_wxGridSizer,
39322 _swigc__p_wxICOHandler,
39323 _swigc__p_wxIcon,
39324 _swigc__p_wxIconizeEvent,
39325 _swigc__p_wxIdleEvent,
39326 _swigc__p_wxImage,
39327 _swigc__p_wxImageHandler,
39328 _swigc__p_wxIndividualLayoutConstraint,
39329 _swigc__p_wxInitDialogEvent,
39330 _swigc__p_wxJPEGHandler,
39331 _swigc__p_wxJoystick,
39332 _swigc__p_wxJoystickEvent,
39333 _swigc__p_wxKeyEvent,
39334 _swigc__p_wxKillError,
39335 _swigc__p_wxLayoutConstraints,
39336 _swigc__p_wxLog,
39337 _swigc__p_wxLogBuffer,
39338 _swigc__p_wxLogChain,
39339 _swigc__p_wxLogGui,
39340 _swigc__p_wxLogNull,
39341 _swigc__p_wxLogStderr,
39342 _swigc__p_wxLogTextCtrl,
39343 _swigc__p_wxLogWindow,
39344 _swigc__p_wxMaximizeEvent,
39345 _swigc__p_wxMenu,
39346 _swigc__p_wxMenuBar,
39347 _swigc__p_wxMenuEvent,
39348 _swigc__p_wxMenuItem,
39349 _swigc__p_wxMetafile,
39350 _swigc__p_wxMetafileDataObject,
39351 _swigc__p_wxMimeTypesManager,
39352 _swigc__p_wxMouseCaptureChangedEvent,
39353 _swigc__p_wxMouseCaptureLostEvent,
39354 _swigc__p_wxMouseEvent,
39355 _swigc__p_wxMouseState,
39356 _swigc__p_wxMoveEvent,
39357 _swigc__p_wxMutexGuiLocker,
39358 _swigc__p_wxNavigationKeyEvent,
39359 _swigc__p_wxNcPaintEvent,
39360 _swigc__p_wxNotifyEvent,
39361 _swigc__p_wxObject,
39362 _swigc__p_wxOutputStream,
39363 _swigc__p_wxPCXHandler,
39364 _swigc__p_wxPNGHandler,
39365 _swigc__p_wxPNMHandler,
39366 _swigc__p_wxPaintEvent,
39367 _swigc__p_wxPaletteChangedEvent,
39368 _swigc__p_wxPaperSize,
39369 _swigc__p_wxPlatformInfo,
39370 _swigc__p_wxPoint,
39371 _swigc__p_wxPowerEvent,
39372 _swigc__p_wxProcessEvent,
39373 _swigc__p_wxPyApp,
39374 _swigc__p_wxPyArtProvider,
39375 _swigc__p_wxPyBitmapDataObject,
39376 _swigc__p_wxPyCommandEvent,
39377 _swigc__p_wxPyDataObjectSimple,
39378 _swigc__p_wxPyDropSource,
39379 _swigc__p_wxPyDropTarget,
39380 _swigc__p_wxPyEvent,
39381 _swigc__p_wxPyFileDropTarget,
39382 _swigc__p_wxPyImageHandler,
39383 _swigc__p_wxPyLog,
39384 _swigc__p_wxPyProcess,
39385 _swigc__p_wxPySizer,
39386 _swigc__p_wxPyTextDataObject,
39387 _swigc__p_wxPyTextDropTarget,
39388 _swigc__p_wxPyTimer,
39389 _swigc__p_wxPyTipProvider,
39390 _swigc__p_wxPyValidator,
39391 _swigc__p_wxQueryNewPaletteEvent,
39392 _swigc__p_wxRect,
39393 _swigc__p_wxScrollEvent,
39394 _swigc__p_wxScrollWinEvent,
39395 _swigc__p_wxSetCursorEvent,
39396 _swigc__p_wxShowEvent,
39397 _swigc__p_wxSingleInstanceChecker,
39398 _swigc__p_wxSize,
39399 _swigc__p_wxSizeEvent,
39400 _swigc__p_wxSizer,
39401 _swigc__p_wxSizerItem,
39402 _swigc__p_wxSound,
39403 _swigc__p_wxStandardPaths,
39404 _swigc__p_wxStaticBoxSizer,
39405 _swigc__p_wxStdDialogButtonSizer,
39406 _swigc__p_wxStopWatch,
39407 _swigc__p_wxString,
39408 _swigc__p_wxSysColourChangedEvent,
39409 _swigc__p_wxSystemOptions,
39410 _swigc__p_wxSystemSettings,
39411 _swigc__p_wxTIFFHandler,
39412 _swigc__p_wxTextCtrl,
39413 _swigc__p_wxTextDataObject,
39414 _swigc__p_wxTimeSpan,
39415 _swigc__p_wxTimer,
39416 _swigc__p_wxTimerEvent,
39417 _swigc__p_wxTimerRunner,
39418 _swigc__p_wxTipProvider,
39419 _swigc__p_wxToolTip,
39420 _swigc__p_wxURLDataObject,
39421 _swigc__p_wxUpdateUIEvent,
39422 _swigc__p_wxValidator,
39423 _swigc__p_wxVideoMode,
39424 _swigc__p_wxWindow,
39425 _swigc__p_wxWindowCreateEvent,
39426 _swigc__p_wxWindowDestroyEvent,
39427 _swigc__p_wxWindowDisabler,
39428 _swigc__p_wxXPMHandler,
39429 };
39430
39431
39432 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
39433
39434 static swig_const_info swig_const_table[] = {
39435 {0, 0, 0, 0.0, 0, 0}};
39436
39437 #ifdef __cplusplus
39438 }
39439 #endif
39440 /* -----------------------------------------------------------------------------
39441 * Type initialization:
39442 * This problem is tough by the requirement that no dynamic
39443 * memory is used. Also, since swig_type_info structures store pointers to
39444 * swig_cast_info structures and swig_cast_info structures store pointers back
39445 * to swig_type_info structures, we need some lookup code at initialization.
39446 * The idea is that swig generates all the structures that are needed.
39447 * The runtime then collects these partially filled structures.
39448 * The SWIG_InitializeModule function takes these initial arrays out of
39449 * swig_module, and does all the lookup, filling in the swig_module.types
39450 * array with the correct data and linking the correct swig_cast_info
39451 * structures together.
39452 *
39453 * The generated swig_type_info structures are assigned staticly to an initial
39454 * array. We just loop though that array, and handle each type individually.
39455 * First we lookup if this type has been already loaded, and if so, use the
39456 * loaded structure instead of the generated one. Then we have to fill in the
39457 * cast linked list. The cast data is initially stored in something like a
39458 * two-dimensional array. Each row corresponds to a type (there are the same
39459 * number of rows as there are in the swig_type_initial array). Each entry in
39460 * a column is one of the swig_cast_info structures for that type.
39461 * The cast_initial array is actually an array of arrays, because each row has
39462 * a variable number of columns. So to actually build the cast linked list,
39463 * we find the array of casts associated with the type, and loop through it
39464 * adding the casts to the list. The one last trick we need to do is making
39465 * sure the type pointer in the swig_cast_info struct is correct.
39466 *
39467 * First off, we lookup the cast->type name to see if it is already loaded.
39468 * There are three cases to handle:
39469 * 1) If the cast->type has already been loaded AND the type we are adding
39470 * casting info to has not been loaded (it is in this module), THEN we
39471 * replace the cast->type pointer with the type pointer that has already
39472 * been loaded.
39473 * 2) If BOTH types (the one we are adding casting info to, and the
39474 * cast->type) are loaded, THEN the cast info has already been loaded by
39475 * the previous module so we just ignore it.
39476 * 3) Finally, if cast->type has not already been loaded, then we add that
39477 * swig_cast_info to the linked list (because the cast->type) pointer will
39478 * be correct.
39479 * ----------------------------------------------------------------------------- */
39480
39481 #ifdef __cplusplus
39482 extern "C" {
39483 #if 0
39484 } /* c-mode */
39485 #endif
39486 #endif
39487
39488 #if 0
39489 #define SWIGRUNTIME_DEBUG
39490 #endif
39491
39492 SWIGRUNTIME void
39493 SWIG_InitializeModule(void *clientdata) {
39494 size_t i;
39495 swig_module_info *module_head;
39496 static int init_run = 0;
39497
39498 clientdata = clientdata;
39499
39500 if (init_run) return;
39501 init_run = 1;
39502
39503 /* Initialize the swig_module */
39504 swig_module.type_initial = swig_type_initial;
39505 swig_module.cast_initial = swig_cast_initial;
39506
39507 /* Try and load any already created modules */
39508 module_head = SWIG_GetModule(clientdata);
39509 if (module_head) {
39510 swig_module.next = module_head->next;
39511 module_head->next = &swig_module;
39512 } else {
39513 /* This is the first module loaded */
39514 swig_module.next = &swig_module;
39515 SWIG_SetModule(clientdata, &swig_module);
39516 }
39517
39518 /* Now work on filling in swig_module.types */
39519 #ifdef SWIGRUNTIME_DEBUG
39520 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
39521 #endif
39522 for (i = 0; i < swig_module.size; ++i) {
39523 swig_type_info *type = 0;
39524 swig_type_info *ret;
39525 swig_cast_info *cast;
39526
39527 #ifdef SWIGRUNTIME_DEBUG
39528 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
39529 #endif
39530
39531 /* if there is another module already loaded */
39532 if (swig_module.next != &swig_module) {
39533 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
39534 }
39535 if (type) {
39536 /* Overwrite clientdata field */
39537 #ifdef SWIGRUNTIME_DEBUG
39538 printf("SWIG_InitializeModule: found type %s\n", type->name);
39539 #endif
39540 if (swig_module.type_initial[i]->clientdata) {
39541 type->clientdata = swig_module.type_initial[i]->clientdata;
39542 #ifdef SWIGRUNTIME_DEBUG
39543 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
39544 #endif
39545 }
39546 } else {
39547 type = swig_module.type_initial[i];
39548 }
39549
39550 /* Insert casting types */
39551 cast = swig_module.cast_initial[i];
39552 while (cast->type) {
39553 /* Don't need to add information already in the list */
39554 ret = 0;
39555 #ifdef SWIGRUNTIME_DEBUG
39556 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
39557 #endif
39558 if (swig_module.next != &swig_module) {
39559 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
39560 #ifdef SWIGRUNTIME_DEBUG
39561 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
39562 #endif
39563 }
39564 if (ret) {
39565 if (type == swig_module.type_initial[i]) {
39566 #ifdef SWIGRUNTIME_DEBUG
39567 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
39568 #endif
39569 cast->type = ret;
39570 ret = 0;
39571 } else {
39572 /* Check for casting already in the list */
39573 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
39574 #ifdef SWIGRUNTIME_DEBUG
39575 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
39576 #endif
39577 if (!ocast) ret = 0;
39578 }
39579 }
39580
39581 if (!ret) {
39582 #ifdef SWIGRUNTIME_DEBUG
39583 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
39584 #endif
39585 if (type->cast) {
39586 type->cast->prev = cast;
39587 cast->next = type->cast;
39588 }
39589 type->cast = cast;
39590 }
39591 cast++;
39592 }
39593 /* Set entry in modules->types array equal to the type */
39594 swig_module.types[i] = type;
39595 }
39596 swig_module.types[i] = 0;
39597
39598 #ifdef SWIGRUNTIME_DEBUG
39599 printf("**** SWIG_InitializeModule: Cast List ******\n");
39600 for (i = 0; i < swig_module.size; ++i) {
39601 int j = 0;
39602 swig_cast_info *cast = swig_module.cast_initial[i];
39603 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
39604 while (cast->type) {
39605 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
39606 cast++;
39607 ++j;
39608 }
39609 printf("---- Total casts: %d\n",j);
39610 }
39611 printf("**** SWIG_InitializeModule: Cast List ******\n");
39612 #endif
39613 }
39614
39615 /* This function will propagate the clientdata field of type to
39616 * any new swig_type_info structures that have been added into the list
39617 * of equivalent types. It is like calling
39618 * SWIG_TypeClientData(type, clientdata) a second time.
39619 */
39620 SWIGRUNTIME void
39621 SWIG_PropagateClientData(void) {
39622 size_t i;
39623 swig_cast_info *equiv;
39624 static int init_run = 0;
39625
39626 if (init_run) return;
39627 init_run = 1;
39628
39629 for (i = 0; i < swig_module.size; i++) {
39630 if (swig_module.types[i]->clientdata) {
39631 equiv = swig_module.types[i]->cast;
39632 while (equiv) {
39633 if (!equiv->converter) {
39634 if (equiv->type && !equiv->type->clientdata)
39635 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
39636 }
39637 equiv = equiv->next;
39638 }
39639 }
39640 }
39641 }
39642
39643 #ifdef __cplusplus
39644 #if 0
39645 {
39646 /* c-mode */
39647 #endif
39648 }
39649 #endif
39650
39651
39652
39653 #ifdef __cplusplus
39654 extern "C" {
39655 #endif
39656
39657 /* Python-specific SWIG API */
39658 #define SWIG_newvarlink() SWIG_Python_newvarlink()
39659 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
39660 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
39661
39662 /* -----------------------------------------------------------------------------
39663 * global variable support code.
39664 * ----------------------------------------------------------------------------- */
39665
39666 typedef struct swig_globalvar {
39667 char *name; /* Name of global variable */
39668 PyObject *(*get_attr)(void); /* Return the current value */
39669 int (*set_attr)(PyObject *); /* Set the value */
39670 struct swig_globalvar *next;
39671 } swig_globalvar;
39672
39673 typedef struct swig_varlinkobject {
39674 PyObject_HEAD
39675 swig_globalvar *vars;
39676 } swig_varlinkobject;
39677
39678 SWIGINTERN PyObject *
39679 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
39680 return PyString_FromString("<Swig global variables>");
39681 }
39682
39683 SWIGINTERN PyObject *
39684 swig_varlink_str(swig_varlinkobject *v) {
39685 PyObject *str = PyString_FromString("(");
39686 swig_globalvar *var;
39687 for (var = v->vars; var; var=var->next) {
39688 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
39689 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
39690 }
39691 PyString_ConcatAndDel(&str,PyString_FromString(")"));
39692 return str;
39693 }
39694
39695 SWIGINTERN int
39696 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
39697 PyObject *str = swig_varlink_str(v);
39698 fprintf(fp,"Swig global variables ");
39699 fprintf(fp,"%s\n", PyString_AsString(str));
39700 Py_DECREF(str);
39701 return 0;
39702 }
39703
39704 SWIGINTERN void
39705 swig_varlink_dealloc(swig_varlinkobject *v) {
39706 swig_globalvar *var = v->vars;
39707 while (var) {
39708 swig_globalvar *n = var->next;
39709 free(var->name);
39710 free(var);
39711 var = n;
39712 }
39713 }
39714
39715 SWIGINTERN PyObject *
39716 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
39717 PyObject *res = NULL;
39718 swig_globalvar *var = v->vars;
39719 while (var) {
39720 if (strcmp(var->name,n) == 0) {
39721 res = (*var->get_attr)();
39722 break;
39723 }
39724 var = var->next;
39725 }
39726 if (res == NULL && !PyErr_Occurred()) {
39727 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
39728 }
39729 return res;
39730 }
39731
39732 SWIGINTERN int
39733 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
39734 int res = 1;
39735 swig_globalvar *var = v->vars;
39736 while (var) {
39737 if (strcmp(var->name,n) == 0) {
39738 res = (*var->set_attr)(p);
39739 break;
39740 }
39741 var = var->next;
39742 }
39743 if (res == 1 && !PyErr_Occurred()) {
39744 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
39745 }
39746 return res;
39747 }
39748
39749 SWIGINTERN PyTypeObject*
39750 swig_varlink_type(void) {
39751 static char varlink__doc__[] = "Swig var link object";
39752 static PyTypeObject varlink_type;
39753 static int type_init = 0;
39754 if (!type_init) {
39755 const PyTypeObject tmp
39756 = {
39757 PyObject_HEAD_INIT(NULL)
39758 0, /* Number of items in variable part (ob_size) */
39759 (char *)"swigvarlink", /* Type name (tp_name) */
39760 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
39761 0, /* Itemsize (tp_itemsize) */
39762 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
39763 (printfunc) swig_varlink_print, /* Print (tp_print) */
39764 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
39765 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
39766 0, /* tp_compare */
39767 (reprfunc) swig_varlink_repr, /* tp_repr */
39768 0, /* tp_as_number */
39769 0, /* tp_as_sequence */
39770 0, /* tp_as_mapping */
39771 0, /* tp_hash */
39772 0, /* tp_call */
39773 (reprfunc)swig_varlink_str, /* tp_str */
39774 0, /* tp_getattro */
39775 0, /* tp_setattro */
39776 0, /* tp_as_buffer */
39777 0, /* tp_flags */
39778 varlink__doc__, /* tp_doc */
39779 0, /* tp_traverse */
39780 0, /* tp_clear */
39781 0, /* tp_richcompare */
39782 0, /* tp_weaklistoffset */
39783 #if PY_VERSION_HEX >= 0x02020000
39784 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
39785 #endif
39786 #if PY_VERSION_HEX >= 0x02030000
39787 0, /* tp_del */
39788 #endif
39789 #ifdef COUNT_ALLOCS
39790 0,0,0,0 /* tp_alloc -> tp_next */
39791 #endif
39792 };
39793 varlink_type = tmp;
39794 varlink_type.ob_type = &PyType_Type;
39795 type_init = 1;
39796 }
39797 return &varlink_type;
39798 }
39799
39800 /* Create a variable linking object for use later */
39801 SWIGINTERN PyObject *
39802 SWIG_Python_newvarlink(void) {
39803 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
39804 if (result) {
39805 result->vars = 0;
39806 }
39807 return ((PyObject*) result);
39808 }
39809
39810 SWIGINTERN void
39811 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
39812 swig_varlinkobject *v = (swig_varlinkobject *) p;
39813 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
39814 if (gv) {
39815 size_t size = strlen(name)+1;
39816 gv->name = (char *)malloc(size);
39817 if (gv->name) {
39818 strncpy(gv->name,name,size);
39819 gv->get_attr = get_attr;
39820 gv->set_attr = set_attr;
39821 gv->next = v->vars;
39822 }
39823 }
39824 v->vars = gv;
39825 }
39826
39827 SWIGINTERN PyObject *
39828 SWIG_globals() {
39829 static PyObject *_SWIG_globals = 0;
39830 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
39831 return _SWIG_globals;
39832 }
39833
39834 /* -----------------------------------------------------------------------------
39835 * constants/methods manipulation
39836 * ----------------------------------------------------------------------------- */
39837
39838 /* Install Constants */
39839 SWIGINTERN void
39840 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
39841 PyObject *obj = 0;
39842 size_t i;
39843 for (i = 0; constants[i].type; ++i) {
39844 switch(constants[i].type) {
39845 case SWIG_PY_POINTER:
39846 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
39847 break;
39848 case SWIG_PY_BINARY:
39849 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
39850 break;
39851 default:
39852 obj = 0;
39853 break;
39854 }
39855 if (obj) {
39856 PyDict_SetItemString(d, constants[i].name, obj);
39857 Py_DECREF(obj);
39858 }
39859 }
39860 }
39861
39862 /* -----------------------------------------------------------------------------*/
39863 /* Fix SwigMethods to carry the callback ptrs when needed */
39864 /* -----------------------------------------------------------------------------*/
39865
39866 SWIGINTERN void
39867 SWIG_Python_FixMethods(PyMethodDef *methods,
39868 swig_const_info *const_table,
39869 swig_type_info **types,
39870 swig_type_info **types_initial) {
39871 size_t i;
39872 for (i = 0; methods[i].ml_name; ++i) {
39873 const char *c = methods[i].ml_doc;
39874 if (c && (c = strstr(c, "swig_ptr: "))) {
39875 int j;
39876 swig_const_info *ci = 0;
39877 const char *name = c + 10;
39878 for (j = 0; const_table[j].type; ++j) {
39879 if (strncmp(const_table[j].name, name,
39880 strlen(const_table[j].name)) == 0) {
39881 ci = &(const_table[j]);
39882 break;
39883 }
39884 }
39885 if (ci) {
39886 size_t shift = (ci->ptype) - types;
39887 swig_type_info *ty = types_initial[shift];
39888 size_t ldoc = (c - methods[i].ml_doc);
39889 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
39890 char *ndoc = (char*)malloc(ldoc + lptr + 10);
39891 if (ndoc) {
39892 char *buff = ndoc;
39893 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
39894 if (ptr) {
39895 strncpy(buff, methods[i].ml_doc, ldoc);
39896 buff += ldoc;
39897 strncpy(buff, "swig_ptr: ", 10);
39898 buff += 10;
39899 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
39900 methods[i].ml_doc = ndoc;
39901 }
39902 }
39903 }
39904 }
39905 }
39906 }
39907
39908 #ifdef __cplusplus
39909 }
39910 #endif
39911
39912 /* -----------------------------------------------------------------------------*
39913 * Partial Init method
39914 * -----------------------------------------------------------------------------*/
39915
39916 #ifdef __cplusplus
39917 extern "C"
39918 #endif
39919 SWIGEXPORT void SWIG_init(void) {
39920 PyObject *m, *d;
39921
39922 /* Fix SwigMethods to carry the callback ptrs when needed */
39923 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
39924
39925 m = Py_InitModule((char *) SWIG_name, SwigMethods);
39926 d = PyModule_GetDict(m);
39927
39928 SWIG_InitializeModule(0);
39929 SWIG_InstallConstants(d,swig_const_table);
39930
39931
39932 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
39933 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
39934 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
39935 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
39936 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
39937 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
39938 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
39939 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
39940 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
39941 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
39942 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
39943 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
39944 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
39945 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
39946 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
39947 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
39948 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
39949 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
39950 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
39951 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
39952 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
39953 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
39954 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
39955 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
39956 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
39957 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
39958 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
39959 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
39960 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
39961 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
39962 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
39963 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
39964 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
39965 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
39966 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
39967 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
39968 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
39969 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
39970 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
39971 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
39972 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
39973 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
39974 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
39975 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
39976 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
39977 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
39978 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
39979 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
39980 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
39981 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
39982 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
39983 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
39984 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
39985 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
39986 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
39987 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
39988 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
39989 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
39990 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
39991 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
39992 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
39993 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
39994 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
39995 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
39996 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
39997 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
39998 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
39999 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
40000 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
40001 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
40002 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
40003 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
40004 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
40005 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
40006 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
40007 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
40008 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
40009 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
40010 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
40011 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
40012 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
40013 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
40014 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
40015 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
40016 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
40017 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
40018 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
40019 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
40020 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
40021 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
40022 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
40023 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
40024 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
40025 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
40026 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
40027 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
40028 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
40029 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
40030 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
40031 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
40032 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
40033 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
40034 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
40035 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
40036 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
40037 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
40038 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
40039 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
40040 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
40041 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
40042 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
40043 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
40044 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
40045 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
40046 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
40047 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
40048 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
40049 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
40050 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
40051 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
40052 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
40053 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
40054 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
40055 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
40056 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
40057 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
40058 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
40059 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
40060 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
40061 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
40062 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
40063 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
40064 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
40065 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
40066 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
40067 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
40068 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
40069 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
40070 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
40071 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
40072 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
40073 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
40074 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
40075 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
40076
40077 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
40078
40079 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
40080 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
40081 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
40082 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
40083 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
40084 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
40085 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
40086 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
40087 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
40088 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
40089 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
40090 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
40091 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
40092 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
40093 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
40094 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
40095 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
40096 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
40097 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
40098 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
40099 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
40100 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
40101 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
40102 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
40103 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
40104 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
40105 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
40106 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
40107 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
40108 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
40109 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
40110 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
40111 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
40112 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
40113 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
40114 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
40115 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
40116 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
40117 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
40118 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
40119 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
40120 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
40121 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
40122 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
40123 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
40124 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
40125 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
40126 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
40127 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
40128 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
40129 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
40130 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
40131 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
40132
40133 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
40134
40135 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
40136 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
40137 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
40138 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
40139 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
40140 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
40141 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
40142 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
40143 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
40144 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
40145 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
40146 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
40147 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
40148 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
40149 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
40150 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
40151 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
40152 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
40153 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
40154 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
40155 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
40156 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
40157 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
40158 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
40159 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
40160 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
40161 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
40162 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
40163 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
40164 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
40165 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
40166 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
40167 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
40168 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
40169 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
40170 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
40171 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
40172 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
40173 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
40174 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
40175 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
40176 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
40177 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
40178 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
40179 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
40180 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
40181 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
40182 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
40183 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
40184 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
40185 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
40186 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
40187 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
40188 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
40189 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
40190 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
40191 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
40192 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
40193 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
40194 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
40195 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
40196 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
40197 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
40198 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
40199 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
40200 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
40201 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
40202 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
40203 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
40204 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
40205 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
40206 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
40207 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
40208 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
40209 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
40210 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
40211
40212 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
40213
40214 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
40215 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
40216 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
40217 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
40218 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
40219 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
40220 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
40221 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
40222 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
40223 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
40224 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
40225 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
40226 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
40227 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
40228 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
40229 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
40230 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
40231 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
40232 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
40233 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
40234 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
40235 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
40236 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
40237 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
40238 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
40239 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
40240 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
40241 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
40242 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
40243 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
40244 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
40245 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
40246 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
40247 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
40248 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
40249 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
40250 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
40251 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
40252 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
40253 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
40254 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
40255 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
40256 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
40257 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
40258 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
40259 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
40260 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
40261 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
40262 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
40263 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
40264 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
40265 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
40266 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
40267 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
40268 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
40269 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
40270 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
40271 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
40272 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
40273 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
40274 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
40275 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
40276 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
40277 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
40278 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
40279 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
40280 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
40281 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
40282 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
40283 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
40284 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
40285 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
40286 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
40287 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
40288 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
40289 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
40290 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
40291 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
40292 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
40293 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
40294 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
40295 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
40296 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
40297 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
40298 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
40299 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
40300 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
40301 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
40302 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
40303 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
40304 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
40305 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
40306 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
40307 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
40308 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
40309 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
40310 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
40311 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
40312 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
40313 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
40314 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
40315 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
40316 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
40317 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
40318 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
40319 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
40320 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
40321 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
40322 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
40323 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
40324 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
40325 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
40326 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
40327 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
40328 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
40329 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
40330 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
40331 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
40332 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
40333 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
40334 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
40335 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
40336 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
40337 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
40338 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
40339 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
40340 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
40341 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
40342 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
40343 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
40344 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
40345 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
40346 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
40347 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
40348 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
40349 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
40350 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
40351 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
40352 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
40353 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
40354 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
40355 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
40356 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
40357 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
40358 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
40359 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
40360 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
40361 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
40362 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
40363 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
40364 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
40365 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
40366 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
40367 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
40368 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
40369 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
40370 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
40371 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
40372 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
40373 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
40374 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
40375 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
40376 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
40377 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
40378 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
40379 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
40380 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
40381 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
40382 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
40383 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
40384 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
40385 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
40386 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
40387 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
40388 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
40389 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
40390 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
40391 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
40392 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
40393 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
40394 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
40395 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
40396 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
40397 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
40398 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
40399 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
40400 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
40401 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
40402 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
40403 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
40404 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
40405 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
40406 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
40407 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
40408 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
40409 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
40410 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
40411 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
40412 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
40413 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
40414
40415 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
40416 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
40417 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
40418 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
40419
40420 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
40421 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
40422 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
40423 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
40424 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
40425 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
40426 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
40427 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
40428 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
40429 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
40430 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
40431 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
40432 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
40433 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
40434 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
40435 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
40436 }
40437
wxWidgets (Impactor)