]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Invalidate cache because best size was calculated earlier
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #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_wxAboutDialogInfo swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorTable swig_types[9]
2476 #define SWIGTYPE_p_wxActivateEvent swig_types[10]
2477 #define SWIGTYPE_p_wxArrayString swig_types[11]
2478 #define SWIGTYPE_p_wxBMPHandler swig_types[12]
2479 #define SWIGTYPE_p_wxBitmap swig_types[13]
2480 #define SWIGTYPE_p_wxBitmapDataObject swig_types[14]
2481 #define SWIGTYPE_p_wxBoxSizer swig_types[15]
2482 #define SWIGTYPE_p_wxBusyCursor swig_types[16]
2483 #define SWIGTYPE_p_wxBusyInfo swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChar swig_types[20]
2487 #define SWIGTYPE_p_wxChildFocusEvent swig_types[21]
2488 #define SWIGTYPE_p_wxClipboard swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
2490 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[24]
2491 #define SWIGTYPE_p_wxCloseEvent swig_types[25]
2492 #define SWIGTYPE_p_wxColour swig_types[26]
2493 #define SWIGTYPE_p_wxCommandEvent swig_types[27]
2494 #define SWIGTYPE_p_wxConfig swig_types[28]
2495 #define SWIGTYPE_p_wxConfigBase swig_types[29]
2496 #define SWIGTYPE_p_wxConfigPathChanger swig_types[30]
2497 #define SWIGTYPE_p_wxContextMenuEvent swig_types[31]
2498 #define SWIGTYPE_p_wxControl swig_types[32]
2499 #define SWIGTYPE_p_wxControlWithItems swig_types[33]
2500 #define SWIGTYPE_p_wxCursor swig_types[34]
2501 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
2502 #define SWIGTYPE_p_wxDC swig_types[36]
2503 #define SWIGTYPE_p_wxDataFormat swig_types[37]
2504 #define SWIGTYPE_p_wxDataObject swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectComposite swig_types[39]
2506 #define SWIGTYPE_p_wxDataObjectSimple swig_types[40]
2507 #define SWIGTYPE_p_wxDateEvent swig_types[41]
2508 #define SWIGTYPE_p_wxDateSpan swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime swig_types[43]
2510 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[44]
2511 #define SWIGTYPE_p_wxDisplay swig_types[45]
2512 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDropFilesEvent swig_types[47]
2514 #define SWIGTYPE_p_wxDuplexMode swig_types[48]
2515 #define SWIGTYPE_p_wxEraseEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvent swig_types[50]
2517 #define SWIGTYPE_p_wxEvtHandler swig_types[51]
2518 #define SWIGTYPE_p_wxFSFile swig_types[52]
2519 #define SWIGTYPE_p_wxFileConfig swig_types[53]
2520 #define SWIGTYPE_p_wxFileDataObject swig_types[54]
2521 #define SWIGTYPE_p_wxFileHistory swig_types[55]
2522 #define SWIGTYPE_p_wxFileSystem swig_types[56]
2523 #define SWIGTYPE_p_wxFileType swig_types[57]
2524 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
2525 #define SWIGTYPE_p_wxFlexGridSizer swig_types[59]
2526 #define SWIGTYPE_p_wxFocusEvent swig_types[60]
2527 #define SWIGTYPE_p_wxFont swig_types[61]
2528 #define SWIGTYPE_p_wxFrame swig_types[62]
2529 #define SWIGTYPE_p_wxGBSizerItem swig_types[63]
2530 #define SWIGTYPE_p_wxGIFHandler swig_types[64]
2531 #define SWIGTYPE_p_wxGridBagSizer swig_types[65]
2532 #define SWIGTYPE_p_wxGridSizer swig_types[66]
2533 #define SWIGTYPE_p_wxICOHandler swig_types[67]
2534 #define SWIGTYPE_p_wxIcon swig_types[68]
2535 #define SWIGTYPE_p_wxIconizeEvent swig_types[69]
2536 #define SWIGTYPE_p_wxIdleEvent swig_types[70]
2537 #define SWIGTYPE_p_wxImage swig_types[71]
2538 #define SWIGTYPE_p_wxImageHandler swig_types[72]
2539 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[73]
2540 #define SWIGTYPE_p_wxInitDialogEvent swig_types[74]
2541 #define SWIGTYPE_p_wxJPEGHandler swig_types[75]
2542 #define SWIGTYPE_p_wxJoystick swig_types[76]
2543 #define SWIGTYPE_p_wxJoystickEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKeyEvent swig_types[78]
2545 #define SWIGTYPE_p_wxKillError swig_types[79]
2546 #define SWIGTYPE_p_wxLayoutConstraints swig_types[80]
2547 #define SWIGTYPE_p_wxLog swig_types[81]
2548 #define SWIGTYPE_p_wxLogBuffer swig_types[82]
2549 #define SWIGTYPE_p_wxLogChain swig_types[83]
2550 #define SWIGTYPE_p_wxLogGui swig_types[84]
2551 #define SWIGTYPE_p_wxLogNull swig_types[85]
2552 #define SWIGTYPE_p_wxLogStderr swig_types[86]
2553 #define SWIGTYPE_p_wxLogTextCtrl swig_types[87]
2554 #define SWIGTYPE_p_wxLogWindow swig_types[88]
2555 #define SWIGTYPE_p_wxMaximizeEvent swig_types[89]
2556 #define SWIGTYPE_p_wxMenu swig_types[90]
2557 #define SWIGTYPE_p_wxMenuBar swig_types[91]
2558 #define SWIGTYPE_p_wxMenuEvent swig_types[92]
2559 #define SWIGTYPE_p_wxMenuItem 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 wxMemorySize wxGetFreeMemory()
2821 { wxPyRaiseNotImplemented(); return 0; }
2822
2823
2824 SWIGINTERN int
2825 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2826 {
2827 long v = 0;
2828 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2829 return SWIG_TypeError;
2830 }
2831 else if (val)
2832 *val = (unsigned long)v;
2833 return SWIG_OK;
2834 }
2835
2836
2837 SWIGINTERNINLINE PyObject*
2838 SWIG_From_unsigned_SS_long (unsigned long value)
2839 {
2840 return (value > LONG_MAX) ?
2841 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2842 }
2843
2844
2845 void* wxGetXDisplay()
2846 {
2847 #ifdef __WXGTK__
2848 return wxGetDisplay();
2849 #else
2850 return NULL;
2851 #endif
2852 }
2853
2854
2855 wxWindow* FindWindowAtPointer() {
2856 wxPoint unused;
2857 return wxFindWindowAtPointer(unused);
2858 }
2859
2860
2861 void wxWakeUpMainThread() {}
2862
2863
2864 bool wxThread_IsMain() {
2865 #ifdef WXP_WITH_THREAD
2866 return wxThread::IsMain();
2867 #else
2868 return true;
2869 #endif
2870 }
2871
2872 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2873 delete self;
2874 }
2875
2876 #include <wx/snglinst.h>
2877
2878
2879 #ifdef __WXMSW__
2880 #include <wx/msw/private.h>
2881 #include <wx/dynload.h>
2882 #endif
2883
2884
2885
2886 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2887 #if 0
2888 , int method
2889 #endif
2890 )
2891 {
2892 #ifdef __WXMSW__
2893 #if 0
2894 switch (method)
2895 {
2896 case 1:
2897 // This one only partially works. Appears to be an undocumented
2898 // "standard" convention that not all widgets adhear to. For
2899 // example, for some widgets backgrounds or non-client areas may
2900 // not be painted.
2901 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2902 break;
2903
2904 case 2:
2905 #endif
2906 // This one works much better, nearly all widgets and their
2907 // children are captured correctly[**]. Prior to the big
2908 // background erase changes that Vadim did in 2004-2005 this
2909 // method failed badly on XP with Themes activated, most native
2910 // widgets draw only partially, if at all. Without themes it
2911 // worked just like on Win2k. After those changes this method
2912 // works very well.
2913 //
2914 // ** For example the radio buttons in a wxRadioBox are not its
2915 // children by default, but you can capture it via the panel
2916 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2917 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2918 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2919 PRF_ERASEBKGND | PRF_OWNED );
2920 return true;
2921 #if 0
2922 break;
2923
2924 case 3:
2925 // This one is only defined in the latest SDK and is only
2926 // available on XP. MSDN says it is similar to sending WM_PRINT
2927 // so I expect that it will work similar to the above. Since it
2928 // is avaialble only on XP, it can't be compiled like this and
2929 // will have to be loaded dynamically.
2930 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2931
2932 // fall through
2933
2934 case 4:
2935 // Use PrintWindow if available, or fallback to WM_PRINT
2936 // otherwise. Unfortunately using PrintWindow is even worse than
2937 // WM_PRINT. For most native widgets nothing is drawn to the dc
2938 // at all, with or without Themes.
2939 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2940 static bool s_triedToLoad = false;
2941 static PrintWindow_t pfnPrintWindow = NULL;
2942 if ( !s_triedToLoad )
2943 {
2944
2945 s_triedToLoad = true;
2946 wxDynamicLibrary dllUser32(_T("user32.dll"));
2947 if ( dllUser32.IsLoaded() )
2948 {
2949 wxLogNull nolog; // Don't report errors here
2950 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2951 }
2952 }
2953 if (pfnPrintWindow)
2954 {
2955 //printf("Using PrintWindow\n");
2956 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2957 }
2958 else
2959 {
2960 //printf("Using WM_PRINT\n");
2961 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2962 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2963 PRF_ERASEBKGND | PRF_OWNED );
2964 }
2965 }
2966 #endif // 0
2967 #else
2968 return false;
2969 #endif // __WXMSW__
2970 }
2971
2972
2973
2974 #include <wx/tipdlg.h>
2975
2976
2977 SWIGINTERNINLINE PyObject *
2978 SWIG_From_size_t (size_t value)
2979 {
2980 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2981 }
2982
2983
2984 class wxPyTipProvider : public wxTipProvider {
2985 public:
2986 wxPyTipProvider(size_t currentTip)
2987 : wxTipProvider(currentTip) {}
2988
2989 DEC_PYCALLBACK_STRING__pure(GetTip);
2990 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2991 PYPRIVATE;
2992 };
2993
2994 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2995 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2996
2997
2998 SWIGINTERNINLINE int
2999 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3000 {
3001 unsigned long v;
3002 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3003 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3004 return res;
3005 }
3006
3007
3008 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3009
3010 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3011
3012 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3013 : wxTimer(owner, id)
3014 {
3015 if (owner == NULL)
3016 SetOwner(this);
3017 }
3018
3019
3020 SWIGINTERN swig_type_info*
3021 SWIG_pchar_descriptor()
3022 {
3023 static int init = 0;
3024 static swig_type_info* info = 0;
3025 if (!init) {
3026 info = SWIG_TypeQuery("_p_char");
3027 init = 1;
3028 }
3029 return info;
3030 }
3031
3032
3033 SWIGINTERNINLINE PyObject *
3034 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3035 {
3036 if (carray) {
3037 if (size > INT_MAX) {
3038 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3039 return pchar_descriptor ?
3040 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3041 } else {
3042 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3043 }
3044 } else {
3045 return SWIG_Py_Void();
3046 }
3047 }
3048
3049
3050 SWIGINTERNINLINE PyObject *
3051 SWIG_FromCharPtr(const char *cptr)
3052 {
3053 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3054 }
3055
3056
3057 SWIGINTERN int
3058 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3059 {
3060 unsigned long v;
3061 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3062 if (SWIG_IsOK(res)) {
3063 if ((v > UINT_MAX)) {
3064 return SWIG_OverflowError;
3065 } else {
3066 if (val) *val = static_cast< unsigned int >(v);
3067 }
3068 }
3069 return res;
3070 }
3071
3072 SWIGINTERN wxString wxLog_TimeStamp(){
3073 wxString msg;
3074 wxLog::TimeStamp(&msg);
3075 return msg;
3076 }
3077 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3078 // Make some wrappers that double any % signs so they are 'escaped'
3079 void wxPyLogFatalError(const wxString& msg)
3080 {
3081 wxString m(msg);
3082 m.Replace(wxT("%"), wxT("%%"));
3083 wxLogFatalError(m);
3084 }
3085
3086 void wxPyLogError(const wxString& msg)
3087 {
3088 wxString m(msg);
3089 m.Replace(wxT("%"), wxT("%%"));
3090 wxLogError(m);
3091 }
3092
3093 void wxPyLogWarning(const wxString& msg)
3094 {
3095 wxString m(msg);
3096 m.Replace(wxT("%"), wxT("%%"));
3097 wxLogWarning(m);
3098 }
3099
3100 void wxPyLogMessage(const wxString& msg)
3101 {
3102 wxString m(msg);
3103 m.Replace(wxT("%"), wxT("%%"));
3104 wxLogMessage(m);
3105 }
3106
3107 void wxPyLogInfo(const wxString& msg)
3108 {
3109 wxString m(msg);
3110 m.Replace(wxT("%"), wxT("%%"));
3111 wxLogInfo(m);
3112 }
3113
3114 void wxPyLogDebug(const wxString& msg)
3115 {
3116 wxString m(msg);
3117 m.Replace(wxT("%"), wxT("%%"));
3118 wxLogDebug(m);
3119 }
3120
3121 void wxPyLogVerbose(const wxString& msg)
3122 {
3123 wxString m(msg);
3124 m.Replace(wxT("%"), wxT("%%"));
3125 wxLogVerbose(m);
3126 }
3127
3128 void wxPyLogStatus(const wxString& msg)
3129 {
3130 wxString m(msg);
3131 m.Replace(wxT("%"), wxT("%%"));
3132 wxLogStatus(m);
3133 }
3134
3135 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3136 {
3137 wxString m(msg);
3138 m.Replace(wxT("%"), wxT("%%"));
3139 wxLogStatus(pFrame, m);
3140 }
3141
3142 void wxPyLogSysError(const wxString& msg)
3143 {
3144 wxString m(msg);
3145 m.Replace(wxT("%"), wxT("%%"));
3146 wxLogSysError(m);
3147 }
3148
3149 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3150 {
3151 wxString m(msg);
3152 m.Replace(wxT("%"), wxT("%%"));
3153 wxLogGeneric(level, m);
3154 }
3155
3156 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3157 {
3158 wxString m(msg);
3159 m.Replace(wxT("%"), wxT("%%"));
3160 wxLogTrace(mask, m);
3161 }
3162
3163 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3164 {
3165 wxString m(msg);
3166 m.Replace(wxT("%"), wxT("%%"));
3167 wxLogTrace(mask, m);
3168 }
3169
3170
3171
3172 // A wxLog class that can be derived from in wxPython
3173 class wxPyLog : public wxLog {
3174 public:
3175 wxPyLog() : wxLog() {}
3176
3177 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3178 bool found;
3179 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3180 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3181 PyObject* s = wx2PyString(szString);
3182 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3183 Py_DECREF(s);
3184 }
3185 wxPyEndBlockThreads(blocked);
3186 if (! found)
3187 wxLog::DoLog(level, szString, t);
3188 }
3189
3190 virtual void DoLogString(const wxChar *szString, time_t t) {
3191 bool found;
3192 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3193 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3194 PyObject* s = wx2PyString(szString);
3195 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3196 Py_DECREF(s);
3197 }
3198 wxPyEndBlockThreads(blocked);
3199 if (! found)
3200 wxLog::DoLogString(szString, t);
3201 }
3202
3203 DEC_PYCALLBACK_VOID_(Flush);
3204 PYPRIVATE;
3205 };
3206 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3207
3208
3209
3210
3211 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3212
3213
3214 #include <wx/joystick.h>
3215
3216
3217 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3218 // A C++ stub class for wxJoystick for platforms that don't have it.
3219 class wxJoystick : public wxObject {
3220 public:
3221 wxJoystick(int joystick = wxJOYSTICK1) {
3222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3223 PyErr_SetString(PyExc_NotImplementedError,
3224 "wxJoystick is not available on this platform.");
3225 wxPyEndBlockThreads(blocked);
3226 }
3227 wxPoint GetPosition() { return wxPoint(-1,-1); }
3228 int GetZPosition() { return -1; }
3229 int GetButtonState() { return -1; }
3230 int GetPOVPosition() { return -1; }
3231 int GetPOVCTSPosition() { return -1; }
3232 int GetRudderPosition() { return -1; }
3233 int GetUPosition() { return -1; }
3234 int GetVPosition() { return -1; }
3235 int GetMovementThreshold() { return -1; }
3236 void SetMovementThreshold(int threshold) {}
3237
3238 bool IsOk(void) { return false; }
3239 int GetNumberJoysticks() { return -1; }
3240 int GetManufacturerId() { return -1; }
3241 int GetProductId() { return -1; }
3242 wxString GetProductName() { return wxEmptyString; }
3243 int GetXMin() { return -1; }
3244 int GetYMin() { return -1; }
3245 int GetZMin() { return -1; }
3246 int GetXMax() { return -1; }
3247 int GetYMax() { return -1; }
3248 int GetZMax() { return -1; }
3249 int GetNumberButtons() { return -1; }
3250 int GetNumberAxes() { return -1; }
3251 int GetMaxButtons() { return -1; }
3252 int GetMaxAxes() { return -1; }
3253 int GetPollingMin() { return -1; }
3254 int GetPollingMax() { return -1; }
3255 int GetRudderMin() { return -1; }
3256 int GetRudderMax() { return -1; }
3257 int GetUMin() { return -1; }
3258 int GetUMax() { return -1; }
3259 int GetVMin() { return -1; }
3260 int GetVMax() { return -1; }
3261
3262 bool HasRudder() { return false; }
3263 bool HasZ() { return false; }
3264 bool HasU() { return false; }
3265 bool HasV() { return false; }
3266 bool HasPOV() { return false; }
3267 bool HasPOV4Dir() { return false; }
3268 bool HasPOVCTS() { return false; }
3269
3270 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3271 bool ReleaseCapture() { return false; }
3272 };
3273 #endif
3274
3275
3276 #include <wx/sound.h>
3277
3278
3279 #if !wxUSE_SOUND
3280 // A C++ stub class for wxWave for platforms that don't have it.
3281 class wxSound : public wxObject
3282 {
3283 public:
3284 wxSound() {
3285 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3286 PyErr_SetString(PyExc_NotImplementedError,
3287 "wxSound is not available on this platform.");
3288 wxPyEndBlockThreads(blocked);
3289 }
3290 wxSound(const wxString&/*, bool*/) {
3291 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3292 PyErr_SetString(PyExc_NotImplementedError,
3293 "wxSound is not available on this platform.");
3294 wxPyEndBlockThreads(blocked);
3295 }
3296 wxSound(int, const wxByte*) {
3297 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3298 PyErr_SetString(PyExc_NotImplementedError,
3299 "wxSound is not available on this platform.");
3300 wxPyEndBlockThreads(blocked);
3301 }
3302
3303 ~wxSound() {};
3304
3305 bool Create(const wxString&/*, bool*/) { return false; }
3306 bool Create(int, const wxByte*) { return false; };
3307 bool IsOk() { return false; };
3308 bool Play(unsigned) const { return false; }
3309 static bool Play(const wxString&, unsigned) { return false; }
3310 static void Stop() {}
3311 };
3312
3313 #endif
3314
3315 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3316 if (fileName.Length() == 0)
3317 return new wxSound;
3318 else
3319 return new wxSound(fileName);
3320 }
3321 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3322 unsigned char* buffer; int size;
3323 wxSound *sound = NULL;
3324
3325 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3326 if (!PyArg_Parse(data, "t#", &buffer, &size))
3327 goto done;
3328 sound = new wxSound(size, buffer);
3329 done:
3330 wxPyEndBlockThreads(blocked);
3331 return sound;
3332 }
3333 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3334 #ifndef __WXMAC__
3335 unsigned char* buffer;
3336 int size;
3337 bool rv = false;
3338
3339 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3340 if (!PyArg_Parse(data, "t#", &buffer, &size))
3341 goto done;
3342 rv = self->Create(size, buffer);
3343 done:
3344 wxPyEndBlockThreads(blocked);
3345 return rv;
3346 #else
3347 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3348 PyErr_SetString(PyExc_NotImplementedError,
3349 "Create from data is not available on this platform.");
3350 wxPyEndBlockThreads(blocked);
3351 return false;
3352 #endif
3353 }
3354
3355 #include <wx/mimetype.h>
3356
3357 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3358 wxString str;
3359 if (self->GetMimeType(&str))
3360 return wx2PyString(str);
3361 else
3362 RETURN_NONE();
3363 }
3364 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3365 wxArrayString arr;
3366 if (self->GetMimeTypes(arr))
3367 return wxArrayString2PyList_helper(arr);
3368 else
3369 RETURN_NONE();
3370 }
3371 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3372 wxArrayString arr;
3373 if (self->GetExtensions(arr))
3374 return wxArrayString2PyList_helper(arr);
3375 else
3376 RETURN_NONE();
3377 }
3378 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3379 wxIconLocation loc;
3380 if (self->GetIcon(&loc))
3381 return new wxIcon(loc);
3382 else
3383 return NULL;
3384 }
3385 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3386 wxIconLocation loc;
3387 if (self->GetIcon(&loc)) {
3388 wxString iconFile = loc.GetFileName();
3389 int iconIndex = -1;
3390
3391
3392
3393 // Make a tuple and put the values in it
3394 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3395 PyObject* tuple = PyTuple_New(3);
3396 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3397 wxT("wxIcon"), true));
3398 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3399 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3400 wxPyEndBlockThreads(blocked);
3401 return tuple;
3402 }
3403 else
3404 RETURN_NONE();
3405 }
3406 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3407 wxString str;
3408 if (self->GetDescription(&str))
3409 return wx2PyString(str);
3410 else
3411 RETURN_NONE();
3412 }
3413 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3414 wxString str;
3415 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3416 return wx2PyString(str);
3417 else
3418 RETURN_NONE();
3419 }
3420 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3421 wxString str;
3422 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3423 return wx2PyString(str);
3424 else
3425 RETURN_NONE();
3426 }
3427 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3428 wxArrayString verbs;
3429 wxArrayString commands;
3430 if (self->GetAllCommands(&verbs, &commands,
3431 wxFileType::MessageParameters(filename, mimetype))) {
3432 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3433 PyObject* tuple = PyTuple_New(2);
3434 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3435 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3436 wxPyEndBlockThreads(blocked);
3437 return tuple;
3438 }
3439 else
3440 RETURN_NONE();
3441 }
3442 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3443 return wxFileType::ExpandCommand(command,
3444 wxFileType::MessageParameters(filename, mimetype));
3445 }
3446 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3447 wxArrayString arr;
3448 self->EnumAllFileTypes(arr);
3449 return wxArrayString2PyList_helper(arr);
3450 }
3451
3452 #include <wx/artprov.h>
3453
3454 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3455 static const wxString wxPyART_MENU(wxART_MENU);
3456 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3457 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3458 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3459 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3460 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3461 static const wxString wxPyART_OTHER(wxART_OTHER);
3462 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3463 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3464 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3465 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3466 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3467 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3468 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3469 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3470 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3471 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3472 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3473 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3474 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3475 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3476 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3477 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3478 static const wxString wxPyART_PRINT(wxART_PRINT);
3479 static const wxString wxPyART_HELP(wxART_HELP);
3480 static const wxString wxPyART_TIP(wxART_TIP);
3481 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3482 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3483 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3484 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3485 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3486 static const wxString wxPyART_CDROM(wxART_CDROM);
3487 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3488 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3489 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3490 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3491 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3492 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3493 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3494 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3495 static const wxString wxPyART_ERROR(wxART_ERROR);
3496 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3497 static const wxString wxPyART_WARNING(wxART_WARNING);
3498 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3499 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3500 static const wxString wxPyART_COPY(wxART_COPY);
3501 static const wxString wxPyART_CUT(wxART_CUT);
3502 static const wxString wxPyART_PASTE(wxART_PASTE);
3503 static const wxString wxPyART_DELETE(wxART_DELETE);
3504 static const wxString wxPyART_NEW(wxART_NEW);
3505 static const wxString wxPyART_UNDO(wxART_UNDO);
3506 static const wxString wxPyART_REDO(wxART_REDO);
3507 static const wxString wxPyART_QUIT(wxART_QUIT);
3508 static const wxString wxPyART_FIND(wxART_FIND);
3509 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3510 // Python aware wxArtProvider
3511 class wxPyArtProvider : public wxArtProvider {
3512 public:
3513
3514 virtual wxBitmap CreateBitmap(const wxArtID& id,
3515 const wxArtClient& client,
3516 const wxSize& size) {
3517 wxBitmap rval = wxNullBitmap;
3518 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3519 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3520 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3521 PyObject* ro;
3522 wxBitmap* ptr;
3523 PyObject* s1, *s2;
3524 s1 = wx2PyString(id);
3525 s2 = wx2PyString(client);
3526 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3527 Py_DECREF(so);
3528 Py_DECREF(s1);
3529 Py_DECREF(s2);
3530 if (ro) {
3531 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3532 rval = *ptr;
3533 Py_DECREF(ro);
3534 }
3535 }
3536 wxPyEndBlockThreads(blocked);
3537 return rval;
3538 }
3539
3540 PYPRIVATE;
3541 };
3542
3543 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3544
3545
3546
3547 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3548 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3549 PyObject* ret = PyTuple_New(3);
3550 if (ret) {
3551 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3552 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3553 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3554 }
3555 wxPyEndBlockThreads(blocked);
3556 return ret;
3557 }
3558
3559 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3560 bool cont;
3561 long index = 0;
3562 wxString value;
3563
3564 cont = self->GetFirstGroup(value, index);
3565 return __EnumerationHelper(cont, value, index);
3566 }
3567 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3568 bool cont;
3569 wxString value;
3570
3571 cont = self->GetNextGroup(value, index);
3572 return __EnumerationHelper(cont, value, index);
3573 }
3574 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3575 bool cont;
3576 long index = 0;
3577 wxString value;
3578
3579 cont = self->GetFirstEntry(value, index);
3580 return __EnumerationHelper(cont, value, index);
3581 }
3582 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3583 bool cont;
3584 wxString value;
3585
3586 cont = self->GetNextEntry(value, index);
3587 return __EnumerationHelper(cont, value, index);
3588 }
3589 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3590 long rv;
3591 self->Read(key, &rv, defaultVal);
3592 return rv;
3593 }
3594
3595 SWIGINTERN int
3596 SWIG_AsVal_double (PyObject *obj, double* val)
3597 {
3598 if (PyNumber_Check(obj)) {
3599 if (val) *val = PyFloat_AsDouble(obj);
3600 return SWIG_OK;
3601 }
3602 return SWIG_TypeError;
3603 }
3604
3605 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3606 double rv;
3607 self->Read(key, &rv, defaultVal);
3608 return rv;
3609 }
3610
3611 #define SWIG_From_double PyFloat_FromDouble
3612
3613 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3614 bool rv;
3615 self->Read(key, &rv, defaultVal);
3616 return rv;
3617 }
3618
3619 #include <wx/datetime.h>
3620
3621 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3622 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3623
3624 #define LOCAL_TZ wxDateTime::Local
3625
3626 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3627 wxString am;
3628 wxString pm;
3629 wxDateTime::GetAmPmStrings(&am, &pm);
3630 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3631 PyObject* tup = PyTuple_New(2);
3632 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3633 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3634 wxPyEndBlockThreads(blocked);
3635 return tup;
3636 }
3637
3638 SWIGINTERNINLINE PyObject *
3639 SWIG_From_unsigned_SS_int (unsigned int value)
3640 {
3641 return SWIG_From_unsigned_SS_long (value);
3642 }
3643
3644 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3645 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3646 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3647 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3648 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3649 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3650 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3651 return (*self < *other);
3652 }
3653 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3654 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3655 return (*self <= *other);
3656 }
3657 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3658 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3659 return (*self > *other);
3660 }
3661 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3662 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3663 return (*self >= *other);
3664 }
3665 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3666 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3667 return (*self == *other);
3668 }
3669 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3670 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3671 return (*self != *other);
3672 }
3673 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3674 const wxChar* rv;
3675 const wxChar* _date = date;
3676 rv = self->ParseRfc822Date(_date);
3677 if (rv == NULL) return -1;
3678 return rv - _date;
3679 }
3680 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3681 const wxChar* rv;
3682 const wxChar* _date = date;
3683 rv = self->ParseFormat(_date, format, dateDef);
3684 if (rv == NULL) return -1;
3685 return rv - _date;
3686 }
3687 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3688 const wxChar* rv;
3689 const wxChar* _datetime = datetime;
3690 rv = self->ParseDateTime(_datetime);
3691 if (rv == NULL) return -1;
3692 return rv - _datetime;
3693 }
3694 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3695 const wxChar* rv;
3696 const wxChar* _date = date;
3697 rv = self->ParseDate(_date);
3698 if (rv == NULL) return -1;
3699 return rv - _date;
3700 }
3701 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3702 const wxChar* rv;
3703 const wxChar* _time = time;
3704 rv = self->ParseTime(_time);
3705 if (rv == NULL) return -1;
3706 return rv - _time;
3707 }
3708 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3709 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3710 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3711 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3712 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3713 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3714 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3715 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3716 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3717 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3718 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3719 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3720 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3721 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3722 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3723 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3724
3725 #include <wx/dataobj.h>
3726
3727 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3728 size_t count = self->GetFormatCount(dir);
3729 wxDataFormat* formats = new wxDataFormat[count];
3730 self->GetAllFormats(formats, dir);
3731
3732 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3733 PyObject* list = PyList_New(count);
3734 for (size_t i=0; i<count; i++) {
3735 wxDataFormat* format = new wxDataFormat(formats[i]);
3736 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3737 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3738 }
3739 wxPyEndBlockThreads(blocked);
3740 delete [] formats;
3741 return list;
3742 }
3743 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3744 PyObject* rval = NULL;
3745 size_t size = self->GetDataSize(format);
3746 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3747 if (size) {
3748 char* buf = new char[size];
3749 if (self->GetDataHere(format, buf))
3750 rval = PyString_FromStringAndSize(buf, size);
3751 delete [] buf;
3752 }
3753 if (! rval) {
3754 rval = Py_None;
3755 Py_INCREF(rval);
3756 }
3757 wxPyEndBlockThreads(blocked);
3758 return rval;
3759 }
3760 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3761 bool rval;
3762 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3763 if (PyString_Check(data)) {
3764 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3765 }
3766 else {
3767 // raise a TypeError if not a string
3768 PyErr_SetString(PyExc_TypeError, "String expected.");
3769 rval = false;
3770 }
3771 wxPyEndBlockThreads(blocked);
3772 return rval;
3773 }
3774 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3775 PyObject* rval = NULL;
3776 size_t size = self->GetDataSize();
3777 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3778 if (size) {
3779 char* buf = new char[size];
3780 if (self->GetDataHere(buf))
3781 rval = PyString_FromStringAndSize(buf, size);
3782 delete [] buf;
3783 }
3784 if (! rval) {
3785 rval = Py_None;
3786 Py_INCREF(rval);
3787 }
3788 wxPyEndBlockThreads(blocked);
3789 return rval;
3790 }
3791 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3792 bool rval;
3793 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3794 if (PyString_Check(data)) {
3795 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3796 }
3797 else {
3798 // raise a TypeError if not a string
3799 PyErr_SetString(PyExc_TypeError, "String expected.");
3800 rval = false;
3801 }
3802 wxPyEndBlockThreads(blocked);
3803 return rval;
3804 }
3805 // Create a new class for wxPython to use
3806 class wxPyDataObjectSimple : public wxDataObjectSimple {
3807 public:
3808 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3809 : wxDataObjectSimple(format) {}
3810
3811 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3812 bool GetDataHere(void *buf) const;
3813 bool SetData(size_t len, const void *buf);
3814 PYPRIVATE;
3815 };
3816
3817 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3818
3819 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3820 // We need to get the data for this object and write it to buf. I think
3821 // the best way to do this for wxPython is to have the Python method
3822 // return either a string or None and then act appropriately with the
3823 // C++ version.
3824
3825 bool rval = false;
3826 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3827 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3828 PyObject* ro;
3829 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3830 if (ro) {
3831 rval = (ro != Py_None && PyString_Check(ro));
3832 if (rval)
3833 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3834 Py_DECREF(ro);
3835 }
3836 }
3837 wxPyEndBlockThreads(blocked);
3838 return rval;
3839 }
3840
3841 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3842 // For this one we simply need to make a string from buf and len
3843 // and send it to the Python method.
3844 bool rval = false;
3845 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3846 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3847 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3848 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3849 Py_DECREF(data);
3850 }
3851 wxPyEndBlockThreads(blocked);
3852 return rval;
3853 }
3854
3855 // Create a new class for wxPython to use
3856 class wxPyTextDataObject : public wxTextDataObject {
3857 public:
3858 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3859 : wxTextDataObject(text) {}
3860
3861 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3862 DEC_PYCALLBACK_STRING__const(GetText);
3863 DEC_PYCALLBACK__STRING(SetText);
3864 PYPRIVATE;
3865 };
3866
3867 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3868 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3869 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3870
3871
3872 // Create a new class for wxPython to use
3873 class wxPyBitmapDataObject : public wxBitmapDataObject {
3874 public:
3875 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3876 : wxBitmapDataObject(bitmap) {}
3877
3878 wxBitmap GetBitmap() const;
3879 void SetBitmap(const wxBitmap& bitmap);
3880 PYPRIVATE;
3881 };
3882
3883 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3884 wxBitmap* rval = &wxNullBitmap;
3885 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3886 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3887 PyObject* ro;
3888 wxBitmap* ptr;
3889 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3890 if (ro) {
3891 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3892 rval = ptr;
3893 Py_DECREF(ro);
3894 }
3895 }
3896 wxPyEndBlockThreads(blocked);
3897 return *rval;
3898 }
3899
3900 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3901 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3902 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3903 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3904 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3905 Py_DECREF(bo);
3906 }
3907 wxPyEndBlockThreads(blocked);
3908 }
3909
3910 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3911 return new wxCustomDataObject(wxDataFormat(formatName));
3912 }
3913 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3914 bool rval;
3915 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3916 if (PyString_Check(data)) {
3917 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3918 }
3919 else {
3920 // raise a TypeError if not a string
3921 PyErr_SetString(PyExc_TypeError, "String expected.");
3922 rval = false;
3923 }
3924 wxPyEndBlockThreads(blocked);
3925 return rval;
3926 }
3927 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3928 PyObject* obj;
3929 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3930 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3931 wxPyEndBlockThreads(blocked);
3932 return obj;
3933 }
3934
3935 class wxMetafileDataObject : public wxDataObjectSimple
3936 {
3937 public:
3938 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3939 };
3940
3941
3942 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3943
3944
3945 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3946 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3947 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3948 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3949 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3950
3951
3952 class wxPyTextDropTarget : public wxTextDropTarget {
3953 public:
3954 wxPyTextDropTarget() {}
3955
3956 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3957
3958 DEC_PYCALLBACK__(OnLeave);
3959 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3960 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3961 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3962 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3963
3964 PYPRIVATE;
3965 };
3966
3967 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3968 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3969 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3970 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3971 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3972 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3973
3974
3975
3976 class wxPyFileDropTarget : public wxFileDropTarget {
3977 public:
3978 wxPyFileDropTarget() {}
3979
3980 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3981
3982 DEC_PYCALLBACK__(OnLeave);
3983 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3984 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3985 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3986 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3987
3988 PYPRIVATE;
3989 };
3990
3991 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3992 const wxArrayString& filenames) {
3993 bool rval = false;
3994 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3995 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3996 PyObject* list = wxArrayString2PyList_helper(filenames);
3997 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3998 Py_DECREF(list);
3999 }
4000 wxPyEndBlockThreads(blocked);
4001 return rval;
4002 }
4003
4004
4005
4006 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4007 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4008 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4009 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4010 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4011
4012
4013
4014
4015 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4016
4017 #include <wx/display.h>
4018
4019 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4020 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4021
4022 #if !wxUSE_DISPLAY
4023 const wxVideoMode wxDefaultVideoMode;
4024 #endif
4025
4026 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4027 #if wxUSE_DISPLAY
4028 PyObject* pyList = NULL;
4029 wxArrayVideoModes arr = self->GetModes(mode);
4030 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4031 pyList = PyList_New(0);
4032 for (size_t i=0; i < arr.GetCount(); i++)
4033 {
4034 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4035 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4036 PyList_Append(pyList, pyObj);
4037 Py_DECREF(pyObj);
4038 }
4039 wxPyEndBlockThreads(blocked);
4040 return pyList;
4041 #else
4042 wxPyRaiseNotImplemented();
4043 return NULL;
4044 #endif
4045 }
4046 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4047 #if wxUSE_DISPLAY
4048 return self->GetCurrentMode();
4049 #else
4050 wxPyRaiseNotImplemented();
4051 return wxDefaultVideoMode;
4052 #endif
4053 }
4054 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4055 #if wxUSE_DISPLAY
4056 return self->ChangeMode(mode);
4057 #else
4058 wxPyRaiseNotImplemented();
4059 return false;
4060 #endif
4061 }
4062 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4063 #if wxUSE_DISPLAY
4064 self->ResetMode();
4065 #else
4066 wxPyRaiseNotImplemented();
4067 #endif
4068 }
4069
4070 #include <wx/stdpaths.h>
4071
4072 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4073 return (wxStandardPaths*) &wxStandardPaths::Get();
4074 }
4075
4076 #ifndef wxHAS_POWER_EVENTS
4077 // Dummy class and other definitions for platforms that don't have them
4078
4079 // See wxPython_int.h for wxPowerEvent
4080
4081 enum {
4082 wxEVT_POWER_SUSPENDING,
4083 wxEVT_POWER_SUSPENDED,
4084 wxEVT_POWER_SUSPEND_CANCEL,
4085 wxEVT_POWER_RESUME,
4086 };
4087
4088 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4089 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4090
4091 #endif
4092
4093
4094 #include <wx/aboutdlg.h>
4095
4096 #ifdef __cplusplus
4097 extern "C" {
4098 #endif
4099 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4100 PyObject *resultobj = 0;
4101 wxSystemColour arg1 ;
4102 wxColour result;
4103 int val1 ;
4104 int ecode1 = 0 ;
4105 PyObject * obj0 = 0 ;
4106 char * kwnames[] = {
4107 (char *) "index", NULL
4108 };
4109
4110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4111 ecode1 = SWIG_AsVal_int(obj0, &val1);
4112 if (!SWIG_IsOK(ecode1)) {
4113 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4114 }
4115 arg1 = static_cast< wxSystemColour >(val1);
4116 {
4117 if (!wxPyCheckForApp()) SWIG_fail;
4118 PyThreadState* __tstate = wxPyBeginAllowThreads();
4119 result = wxSystemSettings::GetColour(arg1);
4120 wxPyEndAllowThreads(__tstate);
4121 if (PyErr_Occurred()) SWIG_fail;
4122 }
4123 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4124 return resultobj;
4125 fail:
4126 return NULL;
4127 }
4128
4129
4130 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4131 PyObject *resultobj = 0;
4132 wxSystemFont arg1 ;
4133 wxFont result;
4134 int val1 ;
4135 int ecode1 = 0 ;
4136 PyObject * obj0 = 0 ;
4137 char * kwnames[] = {
4138 (char *) "index", NULL
4139 };
4140
4141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4142 ecode1 = SWIG_AsVal_int(obj0, &val1);
4143 if (!SWIG_IsOK(ecode1)) {
4144 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4145 }
4146 arg1 = static_cast< wxSystemFont >(val1);
4147 {
4148 if (!wxPyCheckForApp()) SWIG_fail;
4149 PyThreadState* __tstate = wxPyBeginAllowThreads();
4150 result = wxSystemSettings::GetFont(arg1);
4151 wxPyEndAllowThreads(__tstate);
4152 if (PyErr_Occurred()) SWIG_fail;
4153 }
4154 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4155 return resultobj;
4156 fail:
4157 return NULL;
4158 }
4159
4160
4161 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4162 PyObject *resultobj = 0;
4163 wxSystemMetric arg1 ;
4164 wxWindow *arg2 = (wxWindow *) NULL ;
4165 int result;
4166 int val1 ;
4167 int ecode1 = 0 ;
4168 void *argp2 = 0 ;
4169 int res2 = 0 ;
4170 PyObject * obj0 = 0 ;
4171 PyObject * obj1 = 0 ;
4172 char * kwnames[] = {
4173 (char *) "index",(char *) "win", NULL
4174 };
4175
4176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4177 ecode1 = SWIG_AsVal_int(obj0, &val1);
4178 if (!SWIG_IsOK(ecode1)) {
4179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4180 }
4181 arg1 = static_cast< wxSystemMetric >(val1);
4182 if (obj1) {
4183 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4184 if (!SWIG_IsOK(res2)) {
4185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4186 }
4187 arg2 = reinterpret_cast< wxWindow * >(argp2);
4188 }
4189 {
4190 if (!wxPyCheckForApp()) SWIG_fail;
4191 PyThreadState* __tstate = wxPyBeginAllowThreads();
4192 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4193 wxPyEndAllowThreads(__tstate);
4194 if (PyErr_Occurred()) SWIG_fail;
4195 }
4196 resultobj = SWIG_From_int(static_cast< int >(result));
4197 return resultobj;
4198 fail:
4199 return NULL;
4200 }
4201
4202
4203 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4204 PyObject *resultobj = 0;
4205 wxSystemFeature arg1 ;
4206 bool result;
4207 int val1 ;
4208 int ecode1 = 0 ;
4209 PyObject * obj0 = 0 ;
4210 char * kwnames[] = {
4211 (char *) "index", NULL
4212 };
4213
4214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4215 ecode1 = SWIG_AsVal_int(obj0, &val1);
4216 if (!SWIG_IsOK(ecode1)) {
4217 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4218 }
4219 arg1 = static_cast< wxSystemFeature >(val1);
4220 {
4221 if (!wxPyCheckForApp()) SWIG_fail;
4222 PyThreadState* __tstate = wxPyBeginAllowThreads();
4223 result = (bool)wxSystemSettings::HasFeature(arg1);
4224 wxPyEndAllowThreads(__tstate);
4225 if (PyErr_Occurred()) SWIG_fail;
4226 }
4227 {
4228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4229 }
4230 return resultobj;
4231 fail:
4232 return NULL;
4233 }
4234
4235
4236 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4237 PyObject *resultobj = 0;
4238 wxSystemScreenType result;
4239
4240 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4241 {
4242 if (!wxPyCheckForApp()) SWIG_fail;
4243 PyThreadState* __tstate = wxPyBeginAllowThreads();
4244 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4245 wxPyEndAllowThreads(__tstate);
4246 if (PyErr_Occurred()) SWIG_fail;
4247 }
4248 resultobj = SWIG_From_int(static_cast< int >(result));
4249 return resultobj;
4250 fail:
4251 return NULL;
4252 }
4253
4254
4255 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4256 PyObject *resultobj = 0;
4257 wxSystemScreenType arg1 ;
4258 int val1 ;
4259 int ecode1 = 0 ;
4260 PyObject * obj0 = 0 ;
4261 char * kwnames[] = {
4262 (char *) "screen", NULL
4263 };
4264
4265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4266 ecode1 = SWIG_AsVal_int(obj0, &val1);
4267 if (!SWIG_IsOK(ecode1)) {
4268 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4269 }
4270 arg1 = static_cast< wxSystemScreenType >(val1);
4271 {
4272 if (!wxPyCheckForApp()) SWIG_fail;
4273 PyThreadState* __tstate = wxPyBeginAllowThreads();
4274 wxSystemSettings::SetScreenType(arg1);
4275 wxPyEndAllowThreads(__tstate);
4276 if (PyErr_Occurred()) SWIG_fail;
4277 }
4278 resultobj = SWIG_Py_Void();
4279 return resultobj;
4280 fail:
4281 return NULL;
4282 }
4283
4284
4285 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4286 PyObject *obj;
4287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4288 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4289 return SWIG_Py_Void();
4290 }
4291
4292 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4293 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4294 return 1;
4295 }
4296
4297
4298 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4299 PyObject *pyobj = 0;
4300
4301 {
4302 #if wxUSE_UNICODE
4303 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4304 #else
4305 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4306 #endif
4307 }
4308 return pyobj;
4309 }
4310
4311
4312 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4313 PyObject *resultobj = 0;
4314 wxSystemOptions *result = 0 ;
4315
4316 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4317 {
4318 PyThreadState* __tstate = wxPyBeginAllowThreads();
4319 result = (wxSystemOptions *)new wxSystemOptions();
4320 wxPyEndAllowThreads(__tstate);
4321 if (PyErr_Occurred()) SWIG_fail;
4322 }
4323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4324 return resultobj;
4325 fail:
4326 return NULL;
4327 }
4328
4329
4330 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4331 PyObject *resultobj = 0;
4332 wxString *arg1 = 0 ;
4333 wxString *arg2 = 0 ;
4334 bool temp1 = false ;
4335 bool temp2 = false ;
4336 PyObject * obj0 = 0 ;
4337 PyObject * obj1 = 0 ;
4338 char * kwnames[] = {
4339 (char *) "name",(char *) "value", NULL
4340 };
4341
4342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4343 {
4344 arg1 = wxString_in_helper(obj0);
4345 if (arg1 == NULL) SWIG_fail;
4346 temp1 = true;
4347 }
4348 {
4349 arg2 = wxString_in_helper(obj1);
4350 if (arg2 == NULL) SWIG_fail;
4351 temp2 = true;
4352 }
4353 {
4354 PyThreadState* __tstate = wxPyBeginAllowThreads();
4355 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4356 wxPyEndAllowThreads(__tstate);
4357 if (PyErr_Occurred()) SWIG_fail;
4358 }
4359 resultobj = SWIG_Py_Void();
4360 {
4361 if (temp1)
4362 delete arg1;
4363 }
4364 {
4365 if (temp2)
4366 delete arg2;
4367 }
4368 return resultobj;
4369 fail:
4370 {
4371 if (temp1)
4372 delete arg1;
4373 }
4374 {
4375 if (temp2)
4376 delete arg2;
4377 }
4378 return NULL;
4379 }
4380
4381
4382 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4383 PyObject *resultobj = 0;
4384 wxString *arg1 = 0 ;
4385 int arg2 ;
4386 bool temp1 = false ;
4387 int val2 ;
4388 int ecode2 = 0 ;
4389 PyObject * obj0 = 0 ;
4390 PyObject * obj1 = 0 ;
4391 char * kwnames[] = {
4392 (char *) "name",(char *) "value", NULL
4393 };
4394
4395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4396 {
4397 arg1 = wxString_in_helper(obj0);
4398 if (arg1 == NULL) SWIG_fail;
4399 temp1 = true;
4400 }
4401 ecode2 = SWIG_AsVal_int(obj1, &val2);
4402 if (!SWIG_IsOK(ecode2)) {
4403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4404 }
4405 arg2 = static_cast< int >(val2);
4406 {
4407 PyThreadState* __tstate = wxPyBeginAllowThreads();
4408 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4409 wxPyEndAllowThreads(__tstate);
4410 if (PyErr_Occurred()) SWIG_fail;
4411 }
4412 resultobj = SWIG_Py_Void();
4413 {
4414 if (temp1)
4415 delete arg1;
4416 }
4417 return resultobj;
4418 fail:
4419 {
4420 if (temp1)
4421 delete arg1;
4422 }
4423 return NULL;
4424 }
4425
4426
4427 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4428 PyObject *resultobj = 0;
4429 wxString *arg1 = 0 ;
4430 wxString result;
4431 bool temp1 = false ;
4432 PyObject * obj0 = 0 ;
4433 char * kwnames[] = {
4434 (char *) "name", NULL
4435 };
4436
4437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4438 {
4439 arg1 = wxString_in_helper(obj0);
4440 if (arg1 == NULL) SWIG_fail;
4441 temp1 = true;
4442 }
4443 {
4444 PyThreadState* __tstate = wxPyBeginAllowThreads();
4445 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4446 wxPyEndAllowThreads(__tstate);
4447 if (PyErr_Occurred()) SWIG_fail;
4448 }
4449 {
4450 #if wxUSE_UNICODE
4451 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4452 #else
4453 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4454 #endif
4455 }
4456 {
4457 if (temp1)
4458 delete arg1;
4459 }
4460 return resultobj;
4461 fail:
4462 {
4463 if (temp1)
4464 delete arg1;
4465 }
4466 return NULL;
4467 }
4468
4469
4470 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4471 PyObject *resultobj = 0;
4472 wxString *arg1 = 0 ;
4473 int result;
4474 bool temp1 = false ;
4475 PyObject * obj0 = 0 ;
4476 char * kwnames[] = {
4477 (char *) "name", NULL
4478 };
4479
4480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4481 {
4482 arg1 = wxString_in_helper(obj0);
4483 if (arg1 == NULL) SWIG_fail;
4484 temp1 = true;
4485 }
4486 {
4487 PyThreadState* __tstate = wxPyBeginAllowThreads();
4488 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4489 wxPyEndAllowThreads(__tstate);
4490 if (PyErr_Occurred()) SWIG_fail;
4491 }
4492 resultobj = SWIG_From_int(static_cast< int >(result));
4493 {
4494 if (temp1)
4495 delete arg1;
4496 }
4497 return resultobj;
4498 fail:
4499 {
4500 if (temp1)
4501 delete arg1;
4502 }
4503 return NULL;
4504 }
4505
4506
4507 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4508 PyObject *resultobj = 0;
4509 wxString *arg1 = 0 ;
4510 bool result;
4511 bool temp1 = false ;
4512 PyObject * obj0 = 0 ;
4513 char * kwnames[] = {
4514 (char *) "name", NULL
4515 };
4516
4517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4518 {
4519 arg1 = wxString_in_helper(obj0);
4520 if (arg1 == NULL) SWIG_fail;
4521 temp1 = true;
4522 }
4523 {
4524 PyThreadState* __tstate = wxPyBeginAllowThreads();
4525 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4526 wxPyEndAllowThreads(__tstate);
4527 if (PyErr_Occurred()) SWIG_fail;
4528 }
4529 {
4530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4531 }
4532 {
4533 if (temp1)
4534 delete arg1;
4535 }
4536 return resultobj;
4537 fail:
4538 {
4539 if (temp1)
4540 delete arg1;
4541 }
4542 return NULL;
4543 }
4544
4545
4546 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4547 PyObject *resultobj = 0;
4548 wxString *arg1 = 0 ;
4549 bool result;
4550 bool temp1 = false ;
4551 PyObject * obj0 = 0 ;
4552 char * kwnames[] = {
4553 (char *) "name", NULL
4554 };
4555
4556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4557 {
4558 arg1 = wxString_in_helper(obj0);
4559 if (arg1 == NULL) SWIG_fail;
4560 temp1 = true;
4561 }
4562 {
4563 PyThreadState* __tstate = wxPyBeginAllowThreads();
4564 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4565 wxPyEndAllowThreads(__tstate);
4566 if (PyErr_Occurred()) SWIG_fail;
4567 }
4568 {
4569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4570 }
4571 {
4572 if (temp1)
4573 delete arg1;
4574 }
4575 return resultobj;
4576 fail:
4577 {
4578 if (temp1)
4579 delete arg1;
4580 }
4581 return NULL;
4582 }
4583
4584
4585 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4586 PyObject *obj;
4587 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4588 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4589 return SWIG_Py_Void();
4590 }
4591
4592 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4593 return SWIG_Python_InitShadowInstance(args);
4594 }
4595
4596 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4597 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4598 return 1;
4599 }
4600
4601
4602 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4603 PyObject *pyobj = 0;
4604
4605 {
4606 #if wxUSE_UNICODE
4607 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4608 #else
4609 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4610 #endif
4611 }
4612 return pyobj;
4613 }
4614
4615
4616 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4617 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4618 return 1;
4619 }
4620
4621
4622 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4623 PyObject *pyobj = 0;
4624
4625 {
4626 #if wxUSE_UNICODE
4627 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4628 #else
4629 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4630 #endif
4631 }
4632 return pyobj;
4633 }
4634
4635
4636 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4637 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4638 return 1;
4639 }
4640
4641
4642 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4643 PyObject *pyobj = 0;
4644
4645 {
4646 #if wxUSE_UNICODE
4647 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4648 #else
4649 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4650 #endif
4651 }
4652 return pyobj;
4653 }
4654
4655
4656 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4657 PyObject *resultobj = 0;
4658 long result;
4659
4660 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4661 {
4662 PyThreadState* __tstate = wxPyBeginAllowThreads();
4663 result = (long)wxNewId();
4664 wxPyEndAllowThreads(__tstate);
4665 if (PyErr_Occurred()) SWIG_fail;
4666 }
4667 resultobj = SWIG_From_long(static_cast< long >(result));
4668 return resultobj;
4669 fail:
4670 return NULL;
4671 }
4672
4673
4674 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4675 PyObject *resultobj = 0;
4676 long arg1 ;
4677 long val1 ;
4678 int ecode1 = 0 ;
4679 PyObject * obj0 = 0 ;
4680 char * kwnames[] = {
4681 (char *) "id", NULL
4682 };
4683
4684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4685 ecode1 = SWIG_AsVal_long(obj0, &val1);
4686 if (!SWIG_IsOK(ecode1)) {
4687 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4688 }
4689 arg1 = static_cast< long >(val1);
4690 {
4691 PyThreadState* __tstate = wxPyBeginAllowThreads();
4692 wxRegisterId(arg1);
4693 wxPyEndAllowThreads(__tstate);
4694 if (PyErr_Occurred()) SWIG_fail;
4695 }
4696 resultobj = SWIG_Py_Void();
4697 return resultobj;
4698 fail:
4699 return NULL;
4700 }
4701
4702
4703 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4704 PyObject *resultobj = 0;
4705 long result;
4706
4707 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4708 {
4709 PyThreadState* __tstate = wxPyBeginAllowThreads();
4710 result = (long)wxGetCurrentId();
4711 wxPyEndAllowThreads(__tstate);
4712 if (PyErr_Occurred()) SWIG_fail;
4713 }
4714 resultobj = SWIG_From_long(static_cast< long >(result));
4715 return resultobj;
4716 fail:
4717 return NULL;
4718 }
4719
4720
4721 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4722 PyObject *resultobj = 0;
4723 int arg1 ;
4724 bool result;
4725 int val1 ;
4726 int ecode1 = 0 ;
4727 PyObject * obj0 = 0 ;
4728 char * kwnames[] = {
4729 (char *) "id", NULL
4730 };
4731
4732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4733 ecode1 = SWIG_AsVal_int(obj0, &val1);
4734 if (!SWIG_IsOK(ecode1)) {
4735 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4736 }
4737 arg1 = static_cast< int >(val1);
4738 {
4739 PyThreadState* __tstate = wxPyBeginAllowThreads();
4740 result = (bool)wxIsStockID(arg1);
4741 wxPyEndAllowThreads(__tstate);
4742 if (PyErr_Occurred()) SWIG_fail;
4743 }
4744 {
4745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4746 }
4747 return resultobj;
4748 fail:
4749 return NULL;
4750 }
4751
4752
4753 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4754 PyObject *resultobj = 0;
4755 int arg1 ;
4756 wxString *arg2 = 0 ;
4757 bool result;
4758 int val1 ;
4759 int ecode1 = 0 ;
4760 bool temp2 = false ;
4761 PyObject * obj0 = 0 ;
4762 PyObject * obj1 = 0 ;
4763 char * kwnames[] = {
4764 (char *) "id",(char *) "label", NULL
4765 };
4766
4767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4768 ecode1 = SWIG_AsVal_int(obj0, &val1);
4769 if (!SWIG_IsOK(ecode1)) {
4770 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4771 }
4772 arg1 = static_cast< int >(val1);
4773 {
4774 arg2 = wxString_in_helper(obj1);
4775 if (arg2 == NULL) SWIG_fail;
4776 temp2 = true;
4777 }
4778 {
4779 PyThreadState* __tstate = wxPyBeginAllowThreads();
4780 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4781 wxPyEndAllowThreads(__tstate);
4782 if (PyErr_Occurred()) SWIG_fail;
4783 }
4784 {
4785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4786 }
4787 {
4788 if (temp2)
4789 delete arg2;
4790 }
4791 return resultobj;
4792 fail:
4793 {
4794 if (temp2)
4795 delete arg2;
4796 }
4797 return NULL;
4798 }
4799
4800
4801 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4802 PyObject *resultobj = 0;
4803 int arg1 ;
4804 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4805 wxString result;
4806 int val1 ;
4807 int ecode1 = 0 ;
4808 long val2 ;
4809 int ecode2 = 0 ;
4810 PyObject * obj0 = 0 ;
4811 PyObject * obj1 = 0 ;
4812 char * kwnames[] = {
4813 (char *) "id",(char *) "flags", NULL
4814 };
4815
4816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4817 ecode1 = SWIG_AsVal_int(obj0, &val1);
4818 if (!SWIG_IsOK(ecode1)) {
4819 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4820 }
4821 arg1 = static_cast< int >(val1);
4822 if (obj1) {
4823 ecode2 = SWIG_AsVal_long(obj1, &val2);
4824 if (!SWIG_IsOK(ecode2)) {
4825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4826 }
4827 arg2 = static_cast< long >(val2);
4828 }
4829 {
4830 PyThreadState* __tstate = wxPyBeginAllowThreads();
4831 result = wxGetStockLabel(arg1,arg2);
4832 wxPyEndAllowThreads(__tstate);
4833 if (PyErr_Occurred()) SWIG_fail;
4834 }
4835 {
4836 #if wxUSE_UNICODE
4837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4838 #else
4839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4840 #endif
4841 }
4842 return resultobj;
4843 fail:
4844 return NULL;
4845 }
4846
4847
4848 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4849 PyObject *resultobj = 0;
4850 int arg1 ;
4851 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4852 wxString result;
4853 int val1 ;
4854 int ecode1 = 0 ;
4855 int val2 ;
4856 int ecode2 = 0 ;
4857 PyObject * obj0 = 0 ;
4858 PyObject * obj1 = 0 ;
4859 char * kwnames[] = {
4860 (char *) "id",(char *) "client", NULL
4861 };
4862
4863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4864 ecode1 = SWIG_AsVal_int(obj0, &val1);
4865 if (!SWIG_IsOK(ecode1)) {
4866 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4867 }
4868 arg1 = static_cast< int >(val1);
4869 if (obj1) {
4870 ecode2 = SWIG_AsVal_int(obj1, &val2);
4871 if (!SWIG_IsOK(ecode2)) {
4872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4873 }
4874 arg2 = static_cast< wxStockHelpStringClient >(val2);
4875 }
4876 {
4877 PyThreadState* __tstate = wxPyBeginAllowThreads();
4878 result = wxGetStockHelpString(arg1,arg2);
4879 wxPyEndAllowThreads(__tstate);
4880 if (PyErr_Occurred()) SWIG_fail;
4881 }
4882 {
4883 #if wxUSE_UNICODE
4884 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4885 #else
4886 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4887 #endif
4888 }
4889 return resultobj;
4890 fail:
4891 return NULL;
4892 }
4893
4894
4895 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4896 PyObject *resultobj = 0;
4897
4898 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4899 {
4900 if (!wxPyCheckForApp()) SWIG_fail;
4901 PyThreadState* __tstate = wxPyBeginAllowThreads();
4902 wxBell();
4903 wxPyEndAllowThreads(__tstate);
4904 if (PyErr_Occurred()) SWIG_fail;
4905 }
4906 resultobj = SWIG_Py_Void();
4907 return resultobj;
4908 fail:
4909 return NULL;
4910 }
4911
4912
4913 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4914 PyObject *resultobj = 0;
4915
4916 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4917 {
4918 if (!wxPyCheckForApp()) SWIG_fail;
4919 PyThreadState* __tstate = wxPyBeginAllowThreads();
4920 wxEndBusyCursor();
4921 wxPyEndAllowThreads(__tstate);
4922 if (PyErr_Occurred()) SWIG_fail;
4923 }
4924 resultobj = SWIG_Py_Void();
4925 return resultobj;
4926 fail:
4927 return NULL;
4928 }
4929
4930
4931 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4932 PyObject *resultobj = 0;
4933 bool arg1 = (bool) true ;
4934 long result;
4935 bool val1 ;
4936 int ecode1 = 0 ;
4937 PyObject * obj0 = 0 ;
4938 char * kwnames[] = {
4939 (char *) "resetTimer", NULL
4940 };
4941
4942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4943 if (obj0) {
4944 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4945 if (!SWIG_IsOK(ecode1)) {
4946 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4947 }
4948 arg1 = static_cast< bool >(val1);
4949 }
4950 {
4951 PyThreadState* __tstate = wxPyBeginAllowThreads();
4952 result = (long)wxGetElapsedTime(arg1);
4953 wxPyEndAllowThreads(__tstate);
4954 if (PyErr_Occurred()) SWIG_fail;
4955 }
4956 resultobj = SWIG_From_long(static_cast< long >(result));
4957 return resultobj;
4958 fail:
4959 return NULL;
4960 }
4961
4962
4963 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4964 PyObject *resultobj = 0;
4965 bool result;
4966
4967 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4968 {
4969 PyThreadState* __tstate = wxPyBeginAllowThreads();
4970 result = (bool)wxIsBusy();
4971 wxPyEndAllowThreads(__tstate);
4972 if (PyErr_Occurred()) SWIG_fail;
4973 }
4974 {
4975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4976 }
4977 return resultobj;
4978 fail:
4979 return NULL;
4980 }
4981
4982
4983 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4984 PyObject *resultobj = 0;
4985 wxString result;
4986
4987 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4988 {
4989 PyThreadState* __tstate = wxPyBeginAllowThreads();
4990 result = wxNow();
4991 wxPyEndAllowThreads(__tstate);
4992 if (PyErr_Occurred()) SWIG_fail;
4993 }
4994 {
4995 #if wxUSE_UNICODE
4996 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4997 #else
4998 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4999 #endif
5000 }
5001 return resultobj;
5002 fail:
5003 return NULL;
5004 }
5005
5006
5007 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5008 PyObject *resultobj = 0;
5009 wxString const &arg1_defvalue = wxPyEmptyString ;
5010 wxString *arg1 = (wxString *) &arg1_defvalue ;
5011 bool result;
5012 bool temp1 = false ;
5013 PyObject * obj0 = 0 ;
5014 char * kwnames[] = {
5015 (char *) "command", NULL
5016 };
5017
5018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5019 if (obj0) {
5020 {
5021 arg1 = wxString_in_helper(obj0);
5022 if (arg1 == NULL) SWIG_fail;
5023 temp1 = true;
5024 }
5025 }
5026 {
5027 PyThreadState* __tstate = wxPyBeginAllowThreads();
5028 result = (bool)wxShell((wxString const &)*arg1);
5029 wxPyEndAllowThreads(__tstate);
5030 if (PyErr_Occurred()) SWIG_fail;
5031 }
5032 {
5033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5034 }
5035 {
5036 if (temp1)
5037 delete arg1;
5038 }
5039 return resultobj;
5040 fail:
5041 {
5042 if (temp1)
5043 delete arg1;
5044 }
5045 return NULL;
5046 }
5047
5048
5049 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5050 PyObject *resultobj = 0;
5051
5052 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5053 {
5054 PyThreadState* __tstate = wxPyBeginAllowThreads();
5055 wxStartTimer();
5056 wxPyEndAllowThreads(__tstate);
5057 if (PyErr_Occurred()) SWIG_fail;
5058 }
5059 resultobj = SWIG_Py_Void();
5060 return resultobj;
5061 fail:
5062 return NULL;
5063 }
5064
5065
5066 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5067 PyObject *resultobj = 0;
5068 int *arg1 = (int *) 0 ;
5069 int *arg2 = (int *) 0 ;
5070 int result;
5071 int temp1 ;
5072 int res1 = SWIG_TMPOBJ ;
5073 int temp2 ;
5074 int res2 = SWIG_TMPOBJ ;
5075
5076 arg1 = &temp1;
5077 arg2 = &temp2;
5078 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5079 {
5080 PyThreadState* __tstate = wxPyBeginAllowThreads();
5081 result = (int)wxGetOsVersion(arg1,arg2);
5082 wxPyEndAllowThreads(__tstate);
5083 if (PyErr_Occurred()) SWIG_fail;
5084 }
5085 resultobj = SWIG_From_int(static_cast< int >(result));
5086 if (SWIG_IsTmpObj(res1)) {
5087 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5088 } else {
5089 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5090 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5091 }
5092 if (SWIG_IsTmpObj(res2)) {
5093 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5094 } else {
5095 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5096 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5097 }
5098 return resultobj;
5099 fail:
5100 return NULL;
5101 }
5102
5103
5104 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5105 PyObject *resultobj = 0;
5106 wxString result;
5107
5108 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5109 {
5110 PyThreadState* __tstate = wxPyBeginAllowThreads();
5111 result = wxGetOsDescription();
5112 wxPyEndAllowThreads(__tstate);
5113 if (PyErr_Occurred()) SWIG_fail;
5114 }
5115 {
5116 #if wxUSE_UNICODE
5117 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5118 #else
5119 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5120 #endif
5121 }
5122 return resultobj;
5123 fail:
5124 return NULL;
5125 }
5126
5127
5128 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5129 PyObject *resultobj = 0;
5130 bool result;
5131
5132 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5133 {
5134 PyThreadState* __tstate = wxPyBeginAllowThreads();
5135 result = (bool)wxIsPlatformLittleEndian();
5136 wxPyEndAllowThreads(__tstate);
5137 if (PyErr_Occurred()) SWIG_fail;
5138 }
5139 {
5140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5141 }
5142 return resultobj;
5143 fail:
5144 return NULL;
5145 }
5146
5147
5148 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5149 PyObject *resultobj = 0;
5150 bool result;
5151
5152 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5153 {
5154 PyThreadState* __tstate = wxPyBeginAllowThreads();
5155 result = (bool)wxIsPlatform64Bit();
5156 wxPyEndAllowThreads(__tstate);
5157 if (PyErr_Occurred()) SWIG_fail;
5158 }
5159 {
5160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5161 }
5162 return resultobj;
5163 fail:
5164 return NULL;
5165 }
5166
5167
5168 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5169 PyObject *resultobj = 0;
5170 wxMemorySize result;
5171
5172 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5173 {
5174 PyThreadState* __tstate = wxPyBeginAllowThreads();
5175 result = wxGetFreeMemory();
5176 wxPyEndAllowThreads(__tstate);
5177 if (PyErr_Occurred()) SWIG_fail;
5178 }
5179 {
5180 #if wxUSE_LONGLONG
5181 resultobj = PyLong_FromLongLong((&result)->GetValue());
5182 #else
5183 resultobj = PyInt_FromLong(result);
5184 #endif
5185 }
5186 return resultobj;
5187 fail:
5188 return NULL;
5189 }
5190
5191
5192 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5193 PyObject *resultobj = 0;
5194 wxShutdownFlags arg1 ;
5195 bool result;
5196 int val1 ;
5197 int ecode1 = 0 ;
5198 PyObject * obj0 = 0 ;
5199 char * kwnames[] = {
5200 (char *) "wFlags", NULL
5201 };
5202
5203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5204 ecode1 = SWIG_AsVal_int(obj0, &val1);
5205 if (!SWIG_IsOK(ecode1)) {
5206 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5207 }
5208 arg1 = static_cast< wxShutdownFlags >(val1);
5209 {
5210 if (!wxPyCheckForApp()) SWIG_fail;
5211 PyThreadState* __tstate = wxPyBeginAllowThreads();
5212 result = (bool)wxShutdown(arg1);
5213 wxPyEndAllowThreads(__tstate);
5214 if (PyErr_Occurred()) SWIG_fail;
5215 }
5216 {
5217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5218 }
5219 return resultobj;
5220 fail:
5221 return NULL;
5222 }
5223
5224
5225 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5226 PyObject *resultobj = 0;
5227 int arg1 ;
5228 int val1 ;
5229 int ecode1 = 0 ;
5230 PyObject * obj0 = 0 ;
5231 char * kwnames[] = {
5232 (char *) "secs", NULL
5233 };
5234
5235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5236 ecode1 = SWIG_AsVal_int(obj0, &val1);
5237 if (!SWIG_IsOK(ecode1)) {
5238 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5239 }
5240 arg1 = static_cast< int >(val1);
5241 {
5242 PyThreadState* __tstate = wxPyBeginAllowThreads();
5243 wxSleep(arg1);
5244 wxPyEndAllowThreads(__tstate);
5245 if (PyErr_Occurred()) SWIG_fail;
5246 }
5247 resultobj = SWIG_Py_Void();
5248 return resultobj;
5249 fail:
5250 return NULL;
5251 }
5252
5253
5254 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5255 PyObject *resultobj = 0;
5256 unsigned long arg1 ;
5257 unsigned long val1 ;
5258 int ecode1 = 0 ;
5259 PyObject * obj0 = 0 ;
5260 char * kwnames[] = {
5261 (char *) "milliseconds", NULL
5262 };
5263
5264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5265 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5266 if (!SWIG_IsOK(ecode1)) {
5267 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5268 }
5269 arg1 = static_cast< unsigned long >(val1);
5270 {
5271 PyThreadState* __tstate = wxPyBeginAllowThreads();
5272 wxMilliSleep(arg1);
5273 wxPyEndAllowThreads(__tstate);
5274 if (PyErr_Occurred()) SWIG_fail;
5275 }
5276 resultobj = SWIG_Py_Void();
5277 return resultobj;
5278 fail:
5279 return NULL;
5280 }
5281
5282
5283 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5284 PyObject *resultobj = 0;
5285 unsigned long arg1 ;
5286 unsigned long val1 ;
5287 int ecode1 = 0 ;
5288 PyObject * obj0 = 0 ;
5289 char * kwnames[] = {
5290 (char *) "microseconds", NULL
5291 };
5292
5293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5294 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5295 if (!SWIG_IsOK(ecode1)) {
5296 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5297 }
5298 arg1 = static_cast< unsigned long >(val1);
5299 {
5300 PyThreadState* __tstate = wxPyBeginAllowThreads();
5301 wxMicroSleep(arg1);
5302 wxPyEndAllowThreads(__tstate);
5303 if (PyErr_Occurred()) SWIG_fail;
5304 }
5305 resultobj = SWIG_Py_Void();
5306 return resultobj;
5307 fail:
5308 return NULL;
5309 }
5310
5311
5312 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5313 PyObject *resultobj = 0;
5314 bool arg1 ;
5315 bool val1 ;
5316 int ecode1 = 0 ;
5317 PyObject * obj0 = 0 ;
5318 char * kwnames[] = {
5319 (char *) "enable", NULL
5320 };
5321
5322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5323 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5324 if (!SWIG_IsOK(ecode1)) {
5325 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5326 }
5327 arg1 = static_cast< bool >(val1);
5328 {
5329 PyThreadState* __tstate = wxPyBeginAllowThreads();
5330 wxEnableTopLevelWindows(arg1);
5331 wxPyEndAllowThreads(__tstate);
5332 if (PyErr_Occurred()) SWIG_fail;
5333 }
5334 resultobj = SWIG_Py_Void();
5335 return resultobj;
5336 fail:
5337 return NULL;
5338 }
5339
5340
5341 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5342 PyObject *resultobj = 0;
5343 wxString *arg1 = 0 ;
5344 wxString result;
5345 bool temp1 = false ;
5346 PyObject * obj0 = 0 ;
5347 char * kwnames[] = {
5348 (char *) "in", NULL
5349 };
5350
5351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5352 {
5353 arg1 = wxString_in_helper(obj0);
5354 if (arg1 == NULL) SWIG_fail;
5355 temp1 = true;
5356 }
5357 {
5358 PyThreadState* __tstate = wxPyBeginAllowThreads();
5359 result = wxStripMenuCodes((wxString const &)*arg1);
5360 wxPyEndAllowThreads(__tstate);
5361 if (PyErr_Occurred()) SWIG_fail;
5362 }
5363 {
5364 #if wxUSE_UNICODE
5365 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5366 #else
5367 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5368 #endif
5369 }
5370 {
5371 if (temp1)
5372 delete arg1;
5373 }
5374 return resultobj;
5375 fail:
5376 {
5377 if (temp1)
5378 delete arg1;
5379 }
5380 return NULL;
5381 }
5382
5383
5384 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5385 PyObject *resultobj = 0;
5386 wxString result;
5387
5388 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5389 {
5390 PyThreadState* __tstate = wxPyBeginAllowThreads();
5391 result = wxGetEmailAddress();
5392 wxPyEndAllowThreads(__tstate);
5393 if (PyErr_Occurred()) SWIG_fail;
5394 }
5395 {
5396 #if wxUSE_UNICODE
5397 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5398 #else
5399 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5400 #endif
5401 }
5402 return resultobj;
5403 fail:
5404 return NULL;
5405 }
5406
5407
5408 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5409 PyObject *resultobj = 0;
5410 wxString result;
5411
5412 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5413 {
5414 PyThreadState* __tstate = wxPyBeginAllowThreads();
5415 result = wxGetHostName();
5416 wxPyEndAllowThreads(__tstate);
5417 if (PyErr_Occurred()) SWIG_fail;
5418 }
5419 {
5420 #if wxUSE_UNICODE
5421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5422 #else
5423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5424 #endif
5425 }
5426 return resultobj;
5427 fail:
5428 return NULL;
5429 }
5430
5431
5432 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5433 PyObject *resultobj = 0;
5434 wxString result;
5435
5436 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5437 {
5438 PyThreadState* __tstate = wxPyBeginAllowThreads();
5439 result = wxGetFullHostName();
5440 wxPyEndAllowThreads(__tstate);
5441 if (PyErr_Occurred()) SWIG_fail;
5442 }
5443 {
5444 #if wxUSE_UNICODE
5445 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5446 #else
5447 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5448 #endif
5449 }
5450 return resultobj;
5451 fail:
5452 return NULL;
5453 }
5454
5455
5456 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5457 PyObject *resultobj = 0;
5458 wxString result;
5459
5460 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5461 {
5462 PyThreadState* __tstate = wxPyBeginAllowThreads();
5463 result = wxGetUserId();
5464 wxPyEndAllowThreads(__tstate);
5465 if (PyErr_Occurred()) SWIG_fail;
5466 }
5467 {
5468 #if wxUSE_UNICODE
5469 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5470 #else
5471 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5472 #endif
5473 }
5474 return resultobj;
5475 fail:
5476 return NULL;
5477 }
5478
5479
5480 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5481 PyObject *resultobj = 0;
5482 wxString result;
5483
5484 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5485 {
5486 PyThreadState* __tstate = wxPyBeginAllowThreads();
5487 result = wxGetUserName();
5488 wxPyEndAllowThreads(__tstate);
5489 if (PyErr_Occurred()) SWIG_fail;
5490 }
5491 {
5492 #if wxUSE_UNICODE
5493 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5494 #else
5495 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5496 #endif
5497 }
5498 return resultobj;
5499 fail:
5500 return NULL;
5501 }
5502
5503
5504 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5505 PyObject *resultobj = 0;
5506 wxString result;
5507
5508 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5509 {
5510 PyThreadState* __tstate = wxPyBeginAllowThreads();
5511 result = wxGetHomeDir();
5512 wxPyEndAllowThreads(__tstate);
5513 if (PyErr_Occurred()) SWIG_fail;
5514 }
5515 {
5516 #if wxUSE_UNICODE
5517 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5518 #else
5519 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5520 #endif
5521 }
5522 return resultobj;
5523 fail:
5524 return NULL;
5525 }
5526
5527
5528 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5529 PyObject *resultobj = 0;
5530 wxString const &arg1_defvalue = wxPyEmptyString ;
5531 wxString *arg1 = (wxString *) &arg1_defvalue ;
5532 wxString result;
5533 bool temp1 = false ;
5534 PyObject * obj0 = 0 ;
5535 char * kwnames[] = {
5536 (char *) "user", NULL
5537 };
5538
5539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5540 if (obj0) {
5541 {
5542 arg1 = wxString_in_helper(obj0);
5543 if (arg1 == NULL) SWIG_fail;
5544 temp1 = true;
5545 }
5546 }
5547 {
5548 PyThreadState* __tstate = wxPyBeginAllowThreads();
5549 result = wxGetUserHome((wxString const &)*arg1);
5550 wxPyEndAllowThreads(__tstate);
5551 if (PyErr_Occurred()) SWIG_fail;
5552 }
5553 {
5554 #if wxUSE_UNICODE
5555 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5556 #else
5557 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5558 #endif
5559 }
5560 {
5561 if (temp1)
5562 delete arg1;
5563 }
5564 return resultobj;
5565 fail:
5566 {
5567 if (temp1)
5568 delete arg1;
5569 }
5570 return NULL;
5571 }
5572
5573
5574 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5575 PyObject *resultobj = 0;
5576 unsigned long result;
5577
5578 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5579 {
5580 PyThreadState* __tstate = wxPyBeginAllowThreads();
5581 result = (unsigned long)wxGetProcessId();
5582 wxPyEndAllowThreads(__tstate);
5583 if (PyErr_Occurred()) SWIG_fail;
5584 }
5585 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5586 return resultobj;
5587 fail:
5588 return NULL;
5589 }
5590
5591
5592 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5593 PyObject *resultobj = 0;
5594
5595 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5596 {
5597 PyThreadState* __tstate = wxPyBeginAllowThreads();
5598 wxTrap();
5599 wxPyEndAllowThreads(__tstate);
5600 if (PyErr_Occurred()) SWIG_fail;
5601 }
5602 resultobj = SWIG_Py_Void();
5603 return resultobj;
5604 fail:
5605 return NULL;
5606 }
5607
5608
5609 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5610 PyObject *resultobj = 0;
5611 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5612 wxString *arg1 = (wxString *) &arg1_defvalue ;
5613 wxString const &arg2_defvalue = wxPyEmptyString ;
5614 wxString *arg2 = (wxString *) &arg2_defvalue ;
5615 wxString const &arg3_defvalue = wxPyEmptyString ;
5616 wxString *arg3 = (wxString *) &arg3_defvalue ;
5617 wxString const &arg4_defvalue = wxPyEmptyString ;
5618 wxString *arg4 = (wxString *) &arg4_defvalue ;
5619 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5620 wxString *arg5 = (wxString *) &arg5_defvalue ;
5621 int arg6 = (int) 0 ;
5622 wxWindow *arg7 = (wxWindow *) NULL ;
5623 int arg8 = (int) -1 ;
5624 int arg9 = (int) -1 ;
5625 wxString result;
5626 bool temp1 = false ;
5627 bool temp2 = false ;
5628 bool temp3 = false ;
5629 bool temp4 = false ;
5630 bool temp5 = false ;
5631 int val6 ;
5632 int ecode6 = 0 ;
5633 void *argp7 = 0 ;
5634 int res7 = 0 ;
5635 int val8 ;
5636 int ecode8 = 0 ;
5637 int val9 ;
5638 int ecode9 = 0 ;
5639 PyObject * obj0 = 0 ;
5640 PyObject * obj1 = 0 ;
5641 PyObject * obj2 = 0 ;
5642 PyObject * obj3 = 0 ;
5643 PyObject * obj4 = 0 ;
5644 PyObject * obj5 = 0 ;
5645 PyObject * obj6 = 0 ;
5646 PyObject * obj7 = 0 ;
5647 PyObject * obj8 = 0 ;
5648 char * kwnames[] = {
5649 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5650 };
5651
5652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5653 if (obj0) {
5654 {
5655 arg1 = wxString_in_helper(obj0);
5656 if (arg1 == NULL) SWIG_fail;
5657 temp1 = true;
5658 }
5659 }
5660 if (obj1) {
5661 {
5662 arg2 = wxString_in_helper(obj1);
5663 if (arg2 == NULL) SWIG_fail;
5664 temp2 = true;
5665 }
5666 }
5667 if (obj2) {
5668 {
5669 arg3 = wxString_in_helper(obj2);
5670 if (arg3 == NULL) SWIG_fail;
5671 temp3 = true;
5672 }
5673 }
5674 if (obj3) {
5675 {
5676 arg4 = wxString_in_helper(obj3);
5677 if (arg4 == NULL) SWIG_fail;
5678 temp4 = true;
5679 }
5680 }
5681 if (obj4) {
5682 {
5683 arg5 = wxString_in_helper(obj4);
5684 if (arg5 == NULL) SWIG_fail;
5685 temp5 = true;
5686 }
5687 }
5688 if (obj5) {
5689 ecode6 = SWIG_AsVal_int(obj5, &val6);
5690 if (!SWIG_IsOK(ecode6)) {
5691 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5692 }
5693 arg6 = static_cast< int >(val6);
5694 }
5695 if (obj6) {
5696 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5697 if (!SWIG_IsOK(res7)) {
5698 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5699 }
5700 arg7 = reinterpret_cast< wxWindow * >(argp7);
5701 }
5702 if (obj7) {
5703 ecode8 = SWIG_AsVal_int(obj7, &val8);
5704 if (!SWIG_IsOK(ecode8)) {
5705 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5706 }
5707 arg8 = static_cast< int >(val8);
5708 }
5709 if (obj8) {
5710 ecode9 = SWIG_AsVal_int(obj8, &val9);
5711 if (!SWIG_IsOK(ecode9)) {
5712 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5713 }
5714 arg9 = static_cast< int >(val9);
5715 }
5716 {
5717 if (!wxPyCheckForApp()) SWIG_fail;
5718 PyThreadState* __tstate = wxPyBeginAllowThreads();
5719 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5720 wxPyEndAllowThreads(__tstate);
5721 if (PyErr_Occurred()) SWIG_fail;
5722 }
5723 {
5724 #if wxUSE_UNICODE
5725 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5726 #else
5727 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5728 #endif
5729 }
5730 {
5731 if (temp1)
5732 delete arg1;
5733 }
5734 {
5735 if (temp2)
5736 delete arg2;
5737 }
5738 {
5739 if (temp3)
5740 delete arg3;
5741 }
5742 {
5743 if (temp4)
5744 delete arg4;
5745 }
5746 {
5747 if (temp5)
5748 delete arg5;
5749 }
5750 return resultobj;
5751 fail:
5752 {
5753 if (temp1)
5754 delete arg1;
5755 }
5756 {
5757 if (temp2)
5758 delete arg2;
5759 }
5760 {
5761 if (temp3)
5762 delete arg3;
5763 }
5764 {
5765 if (temp4)
5766 delete arg4;
5767 }
5768 {
5769 if (temp5)
5770 delete arg5;
5771 }
5772 return NULL;
5773 }
5774
5775
5776 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5777 PyObject *resultobj = 0;
5778 wxString *arg1 = 0 ;
5779 wxString *arg2 = 0 ;
5780 wxString const &arg3_defvalue = wxPyEmptyString ;
5781 wxString *arg3 = (wxString *) &arg3_defvalue ;
5782 wxWindow *arg4 = (wxWindow *) NULL ;
5783 wxString result;
5784 bool temp1 = false ;
5785 bool temp2 = false ;
5786 bool temp3 = false ;
5787 void *argp4 = 0 ;
5788 int res4 = 0 ;
5789 PyObject * obj0 = 0 ;
5790 PyObject * obj1 = 0 ;
5791 PyObject * obj2 = 0 ;
5792 PyObject * obj3 = 0 ;
5793 char * kwnames[] = {
5794 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5795 };
5796
5797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5798 {
5799 arg1 = wxString_in_helper(obj0);
5800 if (arg1 == NULL) SWIG_fail;
5801 temp1 = true;
5802 }
5803 {
5804 arg2 = wxString_in_helper(obj1);
5805 if (arg2 == NULL) SWIG_fail;
5806 temp2 = true;
5807 }
5808 if (obj2) {
5809 {
5810 arg3 = wxString_in_helper(obj2);
5811 if (arg3 == NULL) SWIG_fail;
5812 temp3 = true;
5813 }
5814 }
5815 if (obj3) {
5816 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5817 if (!SWIG_IsOK(res4)) {
5818 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5819 }
5820 arg4 = reinterpret_cast< wxWindow * >(argp4);
5821 }
5822 {
5823 if (!wxPyCheckForApp()) SWIG_fail;
5824 PyThreadState* __tstate = wxPyBeginAllowThreads();
5825 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5826 wxPyEndAllowThreads(__tstate);
5827 if (PyErr_Occurred()) SWIG_fail;
5828 }
5829 {
5830 #if wxUSE_UNICODE
5831 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5832 #else
5833 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5834 #endif
5835 }
5836 {
5837 if (temp1)
5838 delete arg1;
5839 }
5840 {
5841 if (temp2)
5842 delete arg2;
5843 }
5844 {
5845 if (temp3)
5846 delete arg3;
5847 }
5848 return resultobj;
5849 fail:
5850 {
5851 if (temp1)
5852 delete arg1;
5853 }
5854 {
5855 if (temp2)
5856 delete arg2;
5857 }
5858 {
5859 if (temp3)
5860 delete arg3;
5861 }
5862 return NULL;
5863 }
5864
5865
5866 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5867 PyObject *resultobj = 0;
5868 wxString *arg1 = 0 ;
5869 wxString *arg2 = 0 ;
5870 wxString const &arg3_defvalue = wxPyEmptyString ;
5871 wxString *arg3 = (wxString *) &arg3_defvalue ;
5872 wxWindow *arg4 = (wxWindow *) NULL ;
5873 wxString result;
5874 bool temp1 = false ;
5875 bool temp2 = false ;
5876 bool temp3 = false ;
5877 void *argp4 = 0 ;
5878 int res4 = 0 ;
5879 PyObject * obj0 = 0 ;
5880 PyObject * obj1 = 0 ;
5881 PyObject * obj2 = 0 ;
5882 PyObject * obj3 = 0 ;
5883 char * kwnames[] = {
5884 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5885 };
5886
5887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5888 {
5889 arg1 = wxString_in_helper(obj0);
5890 if (arg1 == NULL) SWIG_fail;
5891 temp1 = true;
5892 }
5893 {
5894 arg2 = wxString_in_helper(obj1);
5895 if (arg2 == NULL) SWIG_fail;
5896 temp2 = true;
5897 }
5898 if (obj2) {
5899 {
5900 arg3 = wxString_in_helper(obj2);
5901 if (arg3 == NULL) SWIG_fail;
5902 temp3 = true;
5903 }
5904 }
5905 if (obj3) {
5906 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5907 if (!SWIG_IsOK(res4)) {
5908 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5909 }
5910 arg4 = reinterpret_cast< wxWindow * >(argp4);
5911 }
5912 {
5913 if (!wxPyCheckForApp()) SWIG_fail;
5914 PyThreadState* __tstate = wxPyBeginAllowThreads();
5915 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5916 wxPyEndAllowThreads(__tstate);
5917 if (PyErr_Occurred()) SWIG_fail;
5918 }
5919 {
5920 #if wxUSE_UNICODE
5921 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5922 #else
5923 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5924 #endif
5925 }
5926 {
5927 if (temp1)
5928 delete arg1;
5929 }
5930 {
5931 if (temp2)
5932 delete arg2;
5933 }
5934 {
5935 if (temp3)
5936 delete arg3;
5937 }
5938 return resultobj;
5939 fail:
5940 {
5941 if (temp1)
5942 delete arg1;
5943 }
5944 {
5945 if (temp2)
5946 delete arg2;
5947 }
5948 {
5949 if (temp3)
5950 delete arg3;
5951 }
5952 return NULL;
5953 }
5954
5955
5956 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5957 PyObject *resultobj = 0;
5958 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5959 wxString *arg1 = (wxString *) &arg1_defvalue ;
5960 wxString const &arg2_defvalue = wxPyEmptyString ;
5961 wxString *arg2 = (wxString *) &arg2_defvalue ;
5962 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5963 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5964 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5965 wxWindow *arg5 = (wxWindow *) NULL ;
5966 wxString result;
5967 bool temp1 = false ;
5968 bool temp2 = false ;
5969 long val3 ;
5970 int ecode3 = 0 ;
5971 wxPoint temp4 ;
5972 void *argp5 = 0 ;
5973 int res5 = 0 ;
5974 PyObject * obj0 = 0 ;
5975 PyObject * obj1 = 0 ;
5976 PyObject * obj2 = 0 ;
5977 PyObject * obj3 = 0 ;
5978 PyObject * obj4 = 0 ;
5979 char * kwnames[] = {
5980 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5981 };
5982
5983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5984 if (obj0) {
5985 {
5986 arg1 = wxString_in_helper(obj0);
5987 if (arg1 == NULL) SWIG_fail;
5988 temp1 = true;
5989 }
5990 }
5991 if (obj1) {
5992 {
5993 arg2 = wxString_in_helper(obj1);
5994 if (arg2 == NULL) SWIG_fail;
5995 temp2 = true;
5996 }
5997 }
5998 if (obj2) {
5999 ecode3 = SWIG_AsVal_long(obj2, &val3);
6000 if (!SWIG_IsOK(ecode3)) {
6001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
6002 }
6003 arg3 = static_cast< long >(val3);
6004 }
6005 if (obj3) {
6006 {
6007 arg4 = &temp4;
6008 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6009 }
6010 }
6011 if (obj4) {
6012 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6013 if (!SWIG_IsOK(res5)) {
6014 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6015 }
6016 arg5 = reinterpret_cast< wxWindow * >(argp5);
6017 }
6018 {
6019 if (!wxPyCheckForApp()) SWIG_fail;
6020 PyThreadState* __tstate = wxPyBeginAllowThreads();
6021 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6022 wxPyEndAllowThreads(__tstate);
6023 if (PyErr_Occurred()) SWIG_fail;
6024 }
6025 {
6026 #if wxUSE_UNICODE
6027 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6028 #else
6029 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6030 #endif
6031 }
6032 {
6033 if (temp1)
6034 delete arg1;
6035 }
6036 {
6037 if (temp2)
6038 delete arg2;
6039 }
6040 return resultobj;
6041 fail:
6042 {
6043 if (temp1)
6044 delete arg1;
6045 }
6046 {
6047 if (temp2)
6048 delete arg2;
6049 }
6050 return NULL;
6051 }
6052
6053
6054 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6055 PyObject *resultobj = 0;
6056 wxString *arg1 = 0 ;
6057 wxString const &arg2_defvalue = wxPyEmptyString ;
6058 wxString *arg2 = (wxString *) &arg2_defvalue ;
6059 wxString const &arg3_defvalue = wxPyEmptyString ;
6060 wxString *arg3 = (wxString *) &arg3_defvalue ;
6061 wxWindow *arg4 = (wxWindow *) NULL ;
6062 int arg5 = (int) -1 ;
6063 int arg6 = (int) -1 ;
6064 bool arg7 = (bool) true ;
6065 wxString result;
6066 bool temp1 = false ;
6067 bool temp2 = false ;
6068 bool temp3 = false ;
6069 void *argp4 = 0 ;
6070 int res4 = 0 ;
6071 int val5 ;
6072 int ecode5 = 0 ;
6073 int val6 ;
6074 int ecode6 = 0 ;
6075 bool val7 ;
6076 int ecode7 = 0 ;
6077 PyObject * obj0 = 0 ;
6078 PyObject * obj1 = 0 ;
6079 PyObject * obj2 = 0 ;
6080 PyObject * obj3 = 0 ;
6081 PyObject * obj4 = 0 ;
6082 PyObject * obj5 = 0 ;
6083 PyObject * obj6 = 0 ;
6084 char * kwnames[] = {
6085 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6086 };
6087
6088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6089 {
6090 arg1 = wxString_in_helper(obj0);
6091 if (arg1 == NULL) SWIG_fail;
6092 temp1 = true;
6093 }
6094 if (obj1) {
6095 {
6096 arg2 = wxString_in_helper(obj1);
6097 if (arg2 == NULL) SWIG_fail;
6098 temp2 = true;
6099 }
6100 }
6101 if (obj2) {
6102 {
6103 arg3 = wxString_in_helper(obj2);
6104 if (arg3 == NULL) SWIG_fail;
6105 temp3 = true;
6106 }
6107 }
6108 if (obj3) {
6109 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6110 if (!SWIG_IsOK(res4)) {
6111 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6112 }
6113 arg4 = reinterpret_cast< wxWindow * >(argp4);
6114 }
6115 if (obj4) {
6116 ecode5 = SWIG_AsVal_int(obj4, &val5);
6117 if (!SWIG_IsOK(ecode5)) {
6118 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6119 }
6120 arg5 = static_cast< int >(val5);
6121 }
6122 if (obj5) {
6123 ecode6 = SWIG_AsVal_int(obj5, &val6);
6124 if (!SWIG_IsOK(ecode6)) {
6125 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6126 }
6127 arg6 = static_cast< int >(val6);
6128 }
6129 if (obj6) {
6130 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6131 if (!SWIG_IsOK(ecode7)) {
6132 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6133 }
6134 arg7 = static_cast< bool >(val7);
6135 }
6136 {
6137 if (!wxPyCheckForApp()) SWIG_fail;
6138 PyThreadState* __tstate = wxPyBeginAllowThreads();
6139 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6140 wxPyEndAllowThreads(__tstate);
6141 if (PyErr_Occurred()) SWIG_fail;
6142 }
6143 {
6144 #if wxUSE_UNICODE
6145 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6146 #else
6147 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6148 #endif
6149 }
6150 {
6151 if (temp1)
6152 delete arg1;
6153 }
6154 {
6155 if (temp2)
6156 delete arg2;
6157 }
6158 {
6159 if (temp3)
6160 delete arg3;
6161 }
6162 return resultobj;
6163 fail:
6164 {
6165 if (temp1)
6166 delete arg1;
6167 }
6168 {
6169 if (temp2)
6170 delete arg2;
6171 }
6172 {
6173 if (temp3)
6174 delete arg3;
6175 }
6176 return NULL;
6177 }
6178
6179
6180 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6181 PyObject *resultobj = 0;
6182 wxString *arg1 = 0 ;
6183 wxString const &arg2_defvalue = wxPyEmptyString ;
6184 wxString *arg2 = (wxString *) &arg2_defvalue ;
6185 wxString const &arg3_defvalue = wxPyEmptyString ;
6186 wxString *arg3 = (wxString *) &arg3_defvalue ;
6187 wxWindow *arg4 = (wxWindow *) NULL ;
6188 wxString result;
6189 bool temp1 = false ;
6190 bool temp2 = false ;
6191 bool temp3 = false ;
6192 void *argp4 = 0 ;
6193 int res4 = 0 ;
6194 PyObject * obj0 = 0 ;
6195 PyObject * obj1 = 0 ;
6196 PyObject * obj2 = 0 ;
6197 PyObject * obj3 = 0 ;
6198 char * kwnames[] = {
6199 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6200 };
6201
6202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6203 {
6204 arg1 = wxString_in_helper(obj0);
6205 if (arg1 == NULL) SWIG_fail;
6206 temp1 = true;
6207 }
6208 if (obj1) {
6209 {
6210 arg2 = wxString_in_helper(obj1);
6211 if (arg2 == NULL) SWIG_fail;
6212 temp2 = true;
6213 }
6214 }
6215 if (obj2) {
6216 {
6217 arg3 = wxString_in_helper(obj2);
6218 if (arg3 == NULL) SWIG_fail;
6219 temp3 = true;
6220 }
6221 }
6222 if (obj3) {
6223 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6224 if (!SWIG_IsOK(res4)) {
6225 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6226 }
6227 arg4 = reinterpret_cast< wxWindow * >(argp4);
6228 }
6229 {
6230 if (!wxPyCheckForApp()) SWIG_fail;
6231 PyThreadState* __tstate = wxPyBeginAllowThreads();
6232 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6233 wxPyEndAllowThreads(__tstate);
6234 if (PyErr_Occurred()) SWIG_fail;
6235 }
6236 {
6237 #if wxUSE_UNICODE
6238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6239 #else
6240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6241 #endif
6242 }
6243 {
6244 if (temp1)
6245 delete arg1;
6246 }
6247 {
6248 if (temp2)
6249 delete arg2;
6250 }
6251 {
6252 if (temp3)
6253 delete arg3;
6254 }
6255 return resultobj;
6256 fail:
6257 {
6258 if (temp1)
6259 delete arg1;
6260 }
6261 {
6262 if (temp2)
6263 delete arg2;
6264 }
6265 {
6266 if (temp3)
6267 delete arg3;
6268 }
6269 return NULL;
6270 }
6271
6272
6273 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6274 PyObject *resultobj = 0;
6275 wxString *arg1 = 0 ;
6276 wxString *arg2 = 0 ;
6277 int arg3 ;
6278 wxString *arg4 = (wxString *) 0 ;
6279 wxWindow *arg5 = (wxWindow *) NULL ;
6280 int arg6 = (int) -1 ;
6281 int arg7 = (int) -1 ;
6282 bool arg8 = (bool) true ;
6283 int arg9 = (int) 150 ;
6284 int arg10 = (int) 200 ;
6285 wxString result;
6286 bool temp1 = false ;
6287 bool temp2 = false ;
6288 void *argp5 = 0 ;
6289 int res5 = 0 ;
6290 int val6 ;
6291 int ecode6 = 0 ;
6292 int val7 ;
6293 int ecode7 = 0 ;
6294 bool val8 ;
6295 int ecode8 = 0 ;
6296 int val9 ;
6297 int ecode9 = 0 ;
6298 int val10 ;
6299 int ecode10 = 0 ;
6300 PyObject * obj0 = 0 ;
6301 PyObject * obj1 = 0 ;
6302 PyObject * obj2 = 0 ;
6303 PyObject * obj3 = 0 ;
6304 PyObject * obj4 = 0 ;
6305 PyObject * obj5 = 0 ;
6306 PyObject * obj6 = 0 ;
6307 PyObject * obj7 = 0 ;
6308 PyObject * obj8 = 0 ;
6309 char * kwnames[] = {
6310 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6311 };
6312
6313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6314 {
6315 arg1 = wxString_in_helper(obj0);
6316 if (arg1 == NULL) SWIG_fail;
6317 temp1 = true;
6318 }
6319 {
6320 arg2 = wxString_in_helper(obj1);
6321 if (arg2 == NULL) SWIG_fail;
6322 temp2 = true;
6323 }
6324 {
6325 arg3 = PyList_Size(obj2);
6326 arg4 = wxString_LIST_helper(obj2);
6327 if (arg4 == NULL) SWIG_fail;
6328 }
6329 if (obj3) {
6330 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6331 if (!SWIG_IsOK(res5)) {
6332 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6333 }
6334 arg5 = reinterpret_cast< wxWindow * >(argp5);
6335 }
6336 if (obj4) {
6337 ecode6 = SWIG_AsVal_int(obj4, &val6);
6338 if (!SWIG_IsOK(ecode6)) {
6339 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6340 }
6341 arg6 = static_cast< int >(val6);
6342 }
6343 if (obj5) {
6344 ecode7 = SWIG_AsVal_int(obj5, &val7);
6345 if (!SWIG_IsOK(ecode7)) {
6346 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6347 }
6348 arg7 = static_cast< int >(val7);
6349 }
6350 if (obj6) {
6351 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6352 if (!SWIG_IsOK(ecode8)) {
6353 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6354 }
6355 arg8 = static_cast< bool >(val8);
6356 }
6357 if (obj7) {
6358 ecode9 = SWIG_AsVal_int(obj7, &val9);
6359 if (!SWIG_IsOK(ecode9)) {
6360 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6361 }
6362 arg9 = static_cast< int >(val9);
6363 }
6364 if (obj8) {
6365 ecode10 = SWIG_AsVal_int(obj8, &val10);
6366 if (!SWIG_IsOK(ecode10)) {
6367 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6368 }
6369 arg10 = static_cast< int >(val10);
6370 }
6371 {
6372 if (!wxPyCheckForApp()) SWIG_fail;
6373 PyThreadState* __tstate = wxPyBeginAllowThreads();
6374 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6375 wxPyEndAllowThreads(__tstate);
6376 if (PyErr_Occurred()) SWIG_fail;
6377 }
6378 {
6379 #if wxUSE_UNICODE
6380 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6381 #else
6382 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6383 #endif
6384 }
6385 {
6386 if (temp1)
6387 delete arg1;
6388 }
6389 {
6390 if (temp2)
6391 delete arg2;
6392 }
6393 {
6394 if (arg4) delete [] arg4;
6395 }
6396 return resultobj;
6397 fail:
6398 {
6399 if (temp1)
6400 delete arg1;
6401 }
6402 {
6403 if (temp2)
6404 delete arg2;
6405 }
6406 {
6407 if (arg4) delete [] arg4;
6408 }
6409 return NULL;
6410 }
6411
6412
6413 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6414 PyObject *resultobj = 0;
6415 wxString *arg1 = 0 ;
6416 wxString *arg2 = 0 ;
6417 int arg3 ;
6418 wxString *arg4 = (wxString *) 0 ;
6419 wxWindow *arg5 = (wxWindow *) NULL ;
6420 int arg6 = (int) -1 ;
6421 int arg7 = (int) -1 ;
6422 bool arg8 = (bool) true ;
6423 int arg9 = (int) 150 ;
6424 int arg10 = (int) 200 ;
6425 int result;
6426 bool temp1 = false ;
6427 bool temp2 = false ;
6428 void *argp5 = 0 ;
6429 int res5 = 0 ;
6430 int val6 ;
6431 int ecode6 = 0 ;
6432 int val7 ;
6433 int ecode7 = 0 ;
6434 bool val8 ;
6435 int ecode8 = 0 ;
6436 int val9 ;
6437 int ecode9 = 0 ;
6438 int val10 ;
6439 int ecode10 = 0 ;
6440 PyObject * obj0 = 0 ;
6441 PyObject * obj1 = 0 ;
6442 PyObject * obj2 = 0 ;
6443 PyObject * obj3 = 0 ;
6444 PyObject * obj4 = 0 ;
6445 PyObject * obj5 = 0 ;
6446 PyObject * obj6 = 0 ;
6447 PyObject * obj7 = 0 ;
6448 PyObject * obj8 = 0 ;
6449 char * kwnames[] = {
6450 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6451 };
6452
6453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6454 {
6455 arg1 = wxString_in_helper(obj0);
6456 if (arg1 == NULL) SWIG_fail;
6457 temp1 = true;
6458 }
6459 {
6460 arg2 = wxString_in_helper(obj1);
6461 if (arg2 == NULL) SWIG_fail;
6462 temp2 = true;
6463 }
6464 {
6465 arg3 = PyList_Size(obj2);
6466 arg4 = wxString_LIST_helper(obj2);
6467 if (arg4 == NULL) SWIG_fail;
6468 }
6469 if (obj3) {
6470 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6471 if (!SWIG_IsOK(res5)) {
6472 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6473 }
6474 arg5 = reinterpret_cast< wxWindow * >(argp5);
6475 }
6476 if (obj4) {
6477 ecode6 = SWIG_AsVal_int(obj4, &val6);
6478 if (!SWIG_IsOK(ecode6)) {
6479 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6480 }
6481 arg6 = static_cast< int >(val6);
6482 }
6483 if (obj5) {
6484 ecode7 = SWIG_AsVal_int(obj5, &val7);
6485 if (!SWIG_IsOK(ecode7)) {
6486 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6487 }
6488 arg7 = static_cast< int >(val7);
6489 }
6490 if (obj6) {
6491 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6492 if (!SWIG_IsOK(ecode8)) {
6493 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6494 }
6495 arg8 = static_cast< bool >(val8);
6496 }
6497 if (obj7) {
6498 ecode9 = SWIG_AsVal_int(obj7, &val9);
6499 if (!SWIG_IsOK(ecode9)) {
6500 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6501 }
6502 arg9 = static_cast< int >(val9);
6503 }
6504 if (obj8) {
6505 ecode10 = SWIG_AsVal_int(obj8, &val10);
6506 if (!SWIG_IsOK(ecode10)) {
6507 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6508 }
6509 arg10 = static_cast< int >(val10);
6510 }
6511 {
6512 if (!wxPyCheckForApp()) SWIG_fail;
6513 PyThreadState* __tstate = wxPyBeginAllowThreads();
6514 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6515 wxPyEndAllowThreads(__tstate);
6516 if (PyErr_Occurred()) SWIG_fail;
6517 }
6518 resultobj = SWIG_From_int(static_cast< int >(result));
6519 {
6520 if (temp1)
6521 delete arg1;
6522 }
6523 {
6524 if (temp2)
6525 delete arg2;
6526 }
6527 {
6528 if (arg4) delete [] arg4;
6529 }
6530 return resultobj;
6531 fail:
6532 {
6533 if (temp1)
6534 delete arg1;
6535 }
6536 {
6537 if (temp2)
6538 delete arg2;
6539 }
6540 {
6541 if (arg4) delete [] arg4;
6542 }
6543 return NULL;
6544 }
6545
6546
6547 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6548 PyObject *resultobj = 0;
6549 wxString *arg1 = 0 ;
6550 wxString const &arg2_defvalue = wxPyEmptyString ;
6551 wxString *arg2 = (wxString *) &arg2_defvalue ;
6552 int arg3 = (int) wxOK|wxCENTRE ;
6553 wxWindow *arg4 = (wxWindow *) NULL ;
6554 int arg5 = (int) -1 ;
6555 int arg6 = (int) -1 ;
6556 int result;
6557 bool temp1 = false ;
6558 bool temp2 = false ;
6559 int val3 ;
6560 int ecode3 = 0 ;
6561 void *argp4 = 0 ;
6562 int res4 = 0 ;
6563 int val5 ;
6564 int ecode5 = 0 ;
6565 int val6 ;
6566 int ecode6 = 0 ;
6567 PyObject * obj0 = 0 ;
6568 PyObject * obj1 = 0 ;
6569 PyObject * obj2 = 0 ;
6570 PyObject * obj3 = 0 ;
6571 PyObject * obj4 = 0 ;
6572 PyObject * obj5 = 0 ;
6573 char * kwnames[] = {
6574 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6575 };
6576
6577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6578 {
6579 arg1 = wxString_in_helper(obj0);
6580 if (arg1 == NULL) SWIG_fail;
6581 temp1 = true;
6582 }
6583 if (obj1) {
6584 {
6585 arg2 = wxString_in_helper(obj1);
6586 if (arg2 == NULL) SWIG_fail;
6587 temp2 = true;
6588 }
6589 }
6590 if (obj2) {
6591 ecode3 = SWIG_AsVal_int(obj2, &val3);
6592 if (!SWIG_IsOK(ecode3)) {
6593 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6594 }
6595 arg3 = static_cast< int >(val3);
6596 }
6597 if (obj3) {
6598 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6599 if (!SWIG_IsOK(res4)) {
6600 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6601 }
6602 arg4 = reinterpret_cast< wxWindow * >(argp4);
6603 }
6604 if (obj4) {
6605 ecode5 = SWIG_AsVal_int(obj4, &val5);
6606 if (!SWIG_IsOK(ecode5)) {
6607 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6608 }
6609 arg5 = static_cast< int >(val5);
6610 }
6611 if (obj5) {
6612 ecode6 = SWIG_AsVal_int(obj5, &val6);
6613 if (!SWIG_IsOK(ecode6)) {
6614 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6615 }
6616 arg6 = static_cast< int >(val6);
6617 }
6618 {
6619 if (!wxPyCheckForApp()) SWIG_fail;
6620 PyThreadState* __tstate = wxPyBeginAllowThreads();
6621 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6622 wxPyEndAllowThreads(__tstate);
6623 if (PyErr_Occurred()) SWIG_fail;
6624 }
6625 resultobj = SWIG_From_int(static_cast< int >(result));
6626 {
6627 if (temp1)
6628 delete arg1;
6629 }
6630 {
6631 if (temp2)
6632 delete arg2;
6633 }
6634 return resultobj;
6635 fail:
6636 {
6637 if (temp1)
6638 delete arg1;
6639 }
6640 {
6641 if (temp2)
6642 delete arg2;
6643 }
6644 return NULL;
6645 }
6646
6647
6648 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6649 PyObject *resultobj = 0;
6650 wxString *arg1 = 0 ;
6651 wxString *arg2 = 0 ;
6652 wxString *arg3 = 0 ;
6653 long arg4 ;
6654 long arg5 = (long) 0 ;
6655 long arg6 = (long) 100 ;
6656 wxWindow *arg7 = (wxWindow *) NULL ;
6657 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6658 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6659 long result;
6660 bool temp1 = false ;
6661 bool temp2 = false ;
6662 bool temp3 = false ;
6663 long val4 ;
6664 int ecode4 = 0 ;
6665 long val5 ;
6666 int ecode5 = 0 ;
6667 long val6 ;
6668 int ecode6 = 0 ;
6669 void *argp7 = 0 ;
6670 int res7 = 0 ;
6671 wxPoint temp8 ;
6672 PyObject * obj0 = 0 ;
6673 PyObject * obj1 = 0 ;
6674 PyObject * obj2 = 0 ;
6675 PyObject * obj3 = 0 ;
6676 PyObject * obj4 = 0 ;
6677 PyObject * obj5 = 0 ;
6678 PyObject * obj6 = 0 ;
6679 PyObject * obj7 = 0 ;
6680 char * kwnames[] = {
6681 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6682 };
6683
6684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6685 {
6686 arg1 = wxString_in_helper(obj0);
6687 if (arg1 == NULL) SWIG_fail;
6688 temp1 = true;
6689 }
6690 {
6691 arg2 = wxString_in_helper(obj1);
6692 if (arg2 == NULL) SWIG_fail;
6693 temp2 = true;
6694 }
6695 {
6696 arg3 = wxString_in_helper(obj2);
6697 if (arg3 == NULL) SWIG_fail;
6698 temp3 = true;
6699 }
6700 ecode4 = SWIG_AsVal_long(obj3, &val4);
6701 if (!SWIG_IsOK(ecode4)) {
6702 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6703 }
6704 arg4 = static_cast< long >(val4);
6705 if (obj4) {
6706 ecode5 = SWIG_AsVal_long(obj4, &val5);
6707 if (!SWIG_IsOK(ecode5)) {
6708 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6709 }
6710 arg5 = static_cast< long >(val5);
6711 }
6712 if (obj5) {
6713 ecode6 = SWIG_AsVal_long(obj5, &val6);
6714 if (!SWIG_IsOK(ecode6)) {
6715 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6716 }
6717 arg6 = static_cast< long >(val6);
6718 }
6719 if (obj6) {
6720 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6721 if (!SWIG_IsOK(res7)) {
6722 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6723 }
6724 arg7 = reinterpret_cast< wxWindow * >(argp7);
6725 }
6726 if (obj7) {
6727 {
6728 arg8 = &temp8;
6729 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6730 }
6731 }
6732 {
6733 if (!wxPyCheckForApp()) SWIG_fail;
6734 PyThreadState* __tstate = wxPyBeginAllowThreads();
6735 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6736 wxPyEndAllowThreads(__tstate);
6737 if (PyErr_Occurred()) SWIG_fail;
6738 }
6739 resultobj = SWIG_From_long(static_cast< long >(result));
6740 {
6741 if (temp1)
6742 delete arg1;
6743 }
6744 {
6745 if (temp2)
6746 delete arg2;
6747 }
6748 {
6749 if (temp3)
6750 delete arg3;
6751 }
6752 return resultobj;
6753 fail:
6754 {
6755 if (temp1)
6756 delete arg1;
6757 }
6758 {
6759 if (temp2)
6760 delete arg2;
6761 }
6762 {
6763 if (temp3)
6764 delete arg3;
6765 }
6766 return NULL;
6767 }
6768
6769
6770 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6771 PyObject *resultobj = 0;
6772 bool result;
6773
6774 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6775 {
6776 if (!wxPyCheckForApp()) SWIG_fail;
6777 PyThreadState* __tstate = wxPyBeginAllowThreads();
6778 result = (bool)wxColourDisplay();
6779 wxPyEndAllowThreads(__tstate);
6780 if (PyErr_Occurred()) SWIG_fail;
6781 }
6782 {
6783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6784 }
6785 return resultobj;
6786 fail:
6787 return NULL;
6788 }
6789
6790
6791 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6792 PyObject *resultobj = 0;
6793 int result;
6794
6795 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6796 {
6797 if (!wxPyCheckForApp()) SWIG_fail;
6798 PyThreadState* __tstate = wxPyBeginAllowThreads();
6799 result = (int)wxDisplayDepth();
6800 wxPyEndAllowThreads(__tstate);
6801 if (PyErr_Occurred()) SWIG_fail;
6802 }
6803 resultobj = SWIG_From_int(static_cast< int >(result));
6804 return resultobj;
6805 fail:
6806 return NULL;
6807 }
6808
6809
6810 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6811 PyObject *resultobj = 0;
6812 int result;
6813
6814 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6815 {
6816 if (!wxPyCheckForApp()) SWIG_fail;
6817 PyThreadState* __tstate = wxPyBeginAllowThreads();
6818 result = (int)wxGetDisplayDepth();
6819 wxPyEndAllowThreads(__tstate);
6820 if (PyErr_Occurred()) SWIG_fail;
6821 }
6822 resultobj = SWIG_From_int(static_cast< int >(result));
6823 return resultobj;
6824 fail:
6825 return NULL;
6826 }
6827
6828
6829 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6830 PyObject *resultobj = 0;
6831 int *arg1 = (int *) 0 ;
6832 int *arg2 = (int *) 0 ;
6833 int temp1 ;
6834 int res1 = SWIG_TMPOBJ ;
6835 int temp2 ;
6836 int res2 = SWIG_TMPOBJ ;
6837
6838 arg1 = &temp1;
6839 arg2 = &temp2;
6840 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6841 {
6842 if (!wxPyCheckForApp()) SWIG_fail;
6843 PyThreadState* __tstate = wxPyBeginAllowThreads();
6844 wxDisplaySize(arg1,arg2);
6845 wxPyEndAllowThreads(__tstate);
6846 if (PyErr_Occurred()) SWIG_fail;
6847 }
6848 resultobj = SWIG_Py_Void();
6849 if (SWIG_IsTmpObj(res1)) {
6850 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6851 } else {
6852 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6853 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6854 }
6855 if (SWIG_IsTmpObj(res2)) {
6856 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6857 } else {
6858 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6859 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6860 }
6861 return resultobj;
6862 fail:
6863 return NULL;
6864 }
6865
6866
6867 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6868 PyObject *resultobj = 0;
6869 wxSize result;
6870
6871 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6872 {
6873 if (!wxPyCheckForApp()) SWIG_fail;
6874 PyThreadState* __tstate = wxPyBeginAllowThreads();
6875 result = wxGetDisplaySize();
6876 wxPyEndAllowThreads(__tstate);
6877 if (PyErr_Occurred()) SWIG_fail;
6878 }
6879 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6880 return resultobj;
6881 fail:
6882 return NULL;
6883 }
6884
6885
6886 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6887 PyObject *resultobj = 0;
6888 int *arg1 = (int *) 0 ;
6889 int *arg2 = (int *) 0 ;
6890 int temp1 ;
6891 int res1 = SWIG_TMPOBJ ;
6892 int temp2 ;
6893 int res2 = SWIG_TMPOBJ ;
6894
6895 arg1 = &temp1;
6896 arg2 = &temp2;
6897 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6898 {
6899 if (!wxPyCheckForApp()) SWIG_fail;
6900 PyThreadState* __tstate = wxPyBeginAllowThreads();
6901 wxDisplaySizeMM(arg1,arg2);
6902 wxPyEndAllowThreads(__tstate);
6903 if (PyErr_Occurred()) SWIG_fail;
6904 }
6905 resultobj = SWIG_Py_Void();
6906 if (SWIG_IsTmpObj(res1)) {
6907 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6908 } else {
6909 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6910 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6911 }
6912 if (SWIG_IsTmpObj(res2)) {
6913 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6914 } else {
6915 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6916 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6917 }
6918 return resultobj;
6919 fail:
6920 return NULL;
6921 }
6922
6923
6924 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6925 PyObject *resultobj = 0;
6926 wxSize result;
6927
6928 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6929 {
6930 if (!wxPyCheckForApp()) SWIG_fail;
6931 PyThreadState* __tstate = wxPyBeginAllowThreads();
6932 result = wxGetDisplaySizeMM();
6933 wxPyEndAllowThreads(__tstate);
6934 if (PyErr_Occurred()) SWIG_fail;
6935 }
6936 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6937 return resultobj;
6938 fail:
6939 return NULL;
6940 }
6941
6942
6943 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6944 PyObject *resultobj = 0;
6945 int *arg1 = (int *) 0 ;
6946 int *arg2 = (int *) 0 ;
6947 int *arg3 = (int *) 0 ;
6948 int *arg4 = (int *) 0 ;
6949 int temp1 ;
6950 int res1 = SWIG_TMPOBJ ;
6951 int temp2 ;
6952 int res2 = SWIG_TMPOBJ ;
6953 int temp3 ;
6954 int res3 = SWIG_TMPOBJ ;
6955 int temp4 ;
6956 int res4 = SWIG_TMPOBJ ;
6957
6958 arg1 = &temp1;
6959 arg2 = &temp2;
6960 arg3 = &temp3;
6961 arg4 = &temp4;
6962 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6963 {
6964 if (!wxPyCheckForApp()) SWIG_fail;
6965 PyThreadState* __tstate = wxPyBeginAllowThreads();
6966 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6967 wxPyEndAllowThreads(__tstate);
6968 if (PyErr_Occurred()) SWIG_fail;
6969 }
6970 resultobj = SWIG_Py_Void();
6971 if (SWIG_IsTmpObj(res1)) {
6972 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6973 } else {
6974 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6975 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6976 }
6977 if (SWIG_IsTmpObj(res2)) {
6978 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6979 } else {
6980 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6981 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6982 }
6983 if (SWIG_IsTmpObj(res3)) {
6984 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6985 } else {
6986 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6987 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6988 }
6989 if (SWIG_IsTmpObj(res4)) {
6990 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6991 } else {
6992 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6993 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6994 }
6995 return resultobj;
6996 fail:
6997 return NULL;
6998 }
6999
7000
7001 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7002 PyObject *resultobj = 0;
7003 wxRect result;
7004
7005 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
7006 {
7007 if (!wxPyCheckForApp()) SWIG_fail;
7008 PyThreadState* __tstate = wxPyBeginAllowThreads();
7009 result = wxGetClientDisplayRect();
7010 wxPyEndAllowThreads(__tstate);
7011 if (PyErr_Occurred()) SWIG_fail;
7012 }
7013 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7014 return resultobj;
7015 fail:
7016 return NULL;
7017 }
7018
7019
7020 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7021 PyObject *resultobj = 0;
7022 wxCursor *arg1 = 0 ;
7023 void *argp1 = 0 ;
7024 int res1 = 0 ;
7025 PyObject * obj0 = 0 ;
7026 char * kwnames[] = {
7027 (char *) "cursor", NULL
7028 };
7029
7030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7031 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7032 if (!SWIG_IsOK(res1)) {
7033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7034 }
7035 if (!argp1) {
7036 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7037 }
7038 arg1 = reinterpret_cast< wxCursor * >(argp1);
7039 {
7040 if (!wxPyCheckForApp()) SWIG_fail;
7041 PyThreadState* __tstate = wxPyBeginAllowThreads();
7042 wxSetCursor(*arg1);
7043 wxPyEndAllowThreads(__tstate);
7044 if (PyErr_Occurred()) SWIG_fail;
7045 }
7046 resultobj = SWIG_Py_Void();
7047 return resultobj;
7048 fail:
7049 return NULL;
7050 }
7051
7052
7053 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7054 PyObject *resultobj = 0;
7055 void *result = 0 ;
7056
7057 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7058 {
7059 if (!wxPyCheckForApp()) SWIG_fail;
7060 PyThreadState* __tstate = wxPyBeginAllowThreads();
7061 result = (void *)wxGetXDisplay();
7062 wxPyEndAllowThreads(__tstate);
7063 if (PyErr_Occurred()) SWIG_fail;
7064 }
7065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7066 return resultobj;
7067 fail:
7068 return NULL;
7069 }
7070
7071
7072 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7073 PyObject *resultobj = 0;
7074 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7075 void *argp1 = 0 ;
7076 int res1 = 0 ;
7077 PyObject * obj0 = 0 ;
7078 char * kwnames[] = {
7079 (char *) "cursor", NULL
7080 };
7081
7082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7083 if (obj0) {
7084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7085 if (!SWIG_IsOK(res1)) {
7086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7087 }
7088 arg1 = reinterpret_cast< wxCursor * >(argp1);
7089 }
7090 {
7091 if (!wxPyCheckForApp()) SWIG_fail;
7092 PyThreadState* __tstate = wxPyBeginAllowThreads();
7093 wxBeginBusyCursor(arg1);
7094 wxPyEndAllowThreads(__tstate);
7095 if (PyErr_Occurred()) SWIG_fail;
7096 }
7097 resultobj = SWIG_Py_Void();
7098 return resultobj;
7099 fail:
7100 return NULL;
7101 }
7102
7103
7104 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7105 PyObject *resultobj = 0;
7106 wxPoint result;
7107
7108 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7109 {
7110 if (!wxPyCheckForApp()) SWIG_fail;
7111 PyThreadState* __tstate = wxPyBeginAllowThreads();
7112 result = wxGetMousePosition();
7113 wxPyEndAllowThreads(__tstate);
7114 if (PyErr_Occurred()) SWIG_fail;
7115 }
7116 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7117 return resultobj;
7118 fail:
7119 return NULL;
7120 }
7121
7122
7123 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7124 PyObject *resultobj = 0;
7125 wxWindow *result = 0 ;
7126
7127 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7128 {
7129 if (!wxPyCheckForApp()) SWIG_fail;
7130 PyThreadState* __tstate = wxPyBeginAllowThreads();
7131 result = (wxWindow *)FindWindowAtPointer();
7132 wxPyEndAllowThreads(__tstate);
7133 if (PyErr_Occurred()) SWIG_fail;
7134 }
7135 {
7136 resultobj = wxPyMake_wxObject(result, 0);
7137 }
7138 return resultobj;
7139 fail:
7140 return NULL;
7141 }
7142
7143
7144 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7145 PyObject *resultobj = 0;
7146 wxWindow *result = 0 ;
7147
7148 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7149 {
7150 if (!wxPyCheckForApp()) SWIG_fail;
7151 PyThreadState* __tstate = wxPyBeginAllowThreads();
7152 result = (wxWindow *)wxGetActiveWindow();
7153 wxPyEndAllowThreads(__tstate);
7154 if (PyErr_Occurred()) SWIG_fail;
7155 }
7156 {
7157 resultobj = wxPyMake_wxObject(result, 0);
7158 }
7159 return resultobj;
7160 fail:
7161 return NULL;
7162 }
7163
7164
7165 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7166 PyObject *resultobj = 0;
7167 wxPoint *arg1 = 0 ;
7168 wxWindow *result = 0 ;
7169 wxPoint temp1 ;
7170 PyObject * obj0 = 0 ;
7171 char * kwnames[] = {
7172 (char *) "pt", NULL
7173 };
7174
7175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7176 {
7177 arg1 = &temp1;
7178 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7179 }
7180 {
7181 if (!wxPyCheckForApp()) SWIG_fail;
7182 PyThreadState* __tstate = wxPyBeginAllowThreads();
7183 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7184 wxPyEndAllowThreads(__tstate);
7185 if (PyErr_Occurred()) SWIG_fail;
7186 }
7187 {
7188 resultobj = wxPyMake_wxObject(result, 0);
7189 }
7190 return resultobj;
7191 fail:
7192 return NULL;
7193 }
7194
7195
7196 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7197 PyObject *resultobj = 0;
7198 wxPoint *arg1 = 0 ;
7199 wxWindow *result = 0 ;
7200 wxPoint temp1 ;
7201 PyObject * obj0 = 0 ;
7202 char * kwnames[] = {
7203 (char *) "pt", NULL
7204 };
7205
7206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7207 {
7208 arg1 = &temp1;
7209 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7210 }
7211 {
7212 if (!wxPyCheckForApp()) SWIG_fail;
7213 PyThreadState* __tstate = wxPyBeginAllowThreads();
7214 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7215 wxPyEndAllowThreads(__tstate);
7216 if (PyErr_Occurred()) SWIG_fail;
7217 }
7218 {
7219 resultobj = wxPyMake_wxObject(result, 0);
7220 }
7221 return resultobj;
7222 fail:
7223 return NULL;
7224 }
7225
7226
7227 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7228 PyObject *resultobj = 0;
7229 wxWindow *arg1 = (wxWindow *) 0 ;
7230 wxWindow *result = 0 ;
7231 void *argp1 = 0 ;
7232 int res1 = 0 ;
7233 PyObject * obj0 = 0 ;
7234 char * kwnames[] = {
7235 (char *) "win", NULL
7236 };
7237
7238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7240 if (!SWIG_IsOK(res1)) {
7241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7242 }
7243 arg1 = reinterpret_cast< wxWindow * >(argp1);
7244 {
7245 if (!wxPyCheckForApp()) SWIG_fail;
7246 PyThreadState* __tstate = wxPyBeginAllowThreads();
7247 result = (wxWindow *)wxGetTopLevelParent(arg1);
7248 wxPyEndAllowThreads(__tstate);
7249 if (PyErr_Occurred()) SWIG_fail;
7250 }
7251 {
7252 resultobj = wxPyMake_wxObject(result, 0);
7253 }
7254 return resultobj;
7255 fail:
7256 return NULL;
7257 }
7258
7259
7260 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7261 PyObject *resultobj = 0;
7262 wxString *arg1 = 0 ;
7263 bool result;
7264 bool temp1 = false ;
7265 PyObject * obj0 = 0 ;
7266 char * kwnames[] = {
7267 (char *) "url", NULL
7268 };
7269
7270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7271 {
7272 arg1 = wxString_in_helper(obj0);
7273 if (arg1 == NULL) SWIG_fail;
7274 temp1 = true;
7275 }
7276 {
7277 PyThreadState* __tstate = wxPyBeginAllowThreads();
7278 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7279 wxPyEndAllowThreads(__tstate);
7280 if (PyErr_Occurred()) SWIG_fail;
7281 }
7282 {
7283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7284 }
7285 {
7286 if (temp1)
7287 delete arg1;
7288 }
7289 return resultobj;
7290 fail:
7291 {
7292 if (temp1)
7293 delete arg1;
7294 }
7295 return NULL;
7296 }
7297
7298
7299 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7300 PyObject *resultobj = 0;
7301 wxKeyCode arg1 ;
7302 bool result;
7303 int val1 ;
7304 int ecode1 = 0 ;
7305 PyObject * obj0 = 0 ;
7306 char * kwnames[] = {
7307 (char *) "key", NULL
7308 };
7309
7310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7311 ecode1 = SWIG_AsVal_int(obj0, &val1);
7312 if (!SWIG_IsOK(ecode1)) {
7313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7314 }
7315 arg1 = static_cast< wxKeyCode >(val1);
7316 {
7317 if (!wxPyCheckForApp()) SWIG_fail;
7318 PyThreadState* __tstate = wxPyBeginAllowThreads();
7319 result = (bool)wxGetKeyState(arg1);
7320 wxPyEndAllowThreads(__tstate);
7321 if (PyErr_Occurred()) SWIG_fail;
7322 }
7323 {
7324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7325 }
7326 return resultobj;
7327 fail:
7328 return NULL;
7329 }
7330
7331
7332 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7333 PyObject *resultobj = 0;
7334 wxMouseState *result = 0 ;
7335
7336 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7337 {
7338 PyThreadState* __tstate = wxPyBeginAllowThreads();
7339 result = (wxMouseState *)new wxMouseState();
7340 wxPyEndAllowThreads(__tstate);
7341 if (PyErr_Occurred()) SWIG_fail;
7342 }
7343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7344 return resultobj;
7345 fail:
7346 return NULL;
7347 }
7348
7349
7350 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7351 PyObject *resultobj = 0;
7352 wxMouseState *arg1 = (wxMouseState *) 0 ;
7353 void *argp1 = 0 ;
7354 int res1 = 0 ;
7355 PyObject *swig_obj[1] ;
7356
7357 if (!args) SWIG_fail;
7358 swig_obj[0] = args;
7359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7360 if (!SWIG_IsOK(res1)) {
7361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7362 }
7363 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7364 {
7365 PyThreadState* __tstate = wxPyBeginAllowThreads();
7366 delete arg1;
7367
7368 wxPyEndAllowThreads(__tstate);
7369 if (PyErr_Occurred()) SWIG_fail;
7370 }
7371 resultobj = SWIG_Py_Void();
7372 return resultobj;
7373 fail:
7374 return NULL;
7375 }
7376
7377
7378 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7379 PyObject *resultobj = 0;
7380 wxMouseState *arg1 = (wxMouseState *) 0 ;
7381 int result;
7382 void *argp1 = 0 ;
7383 int res1 = 0 ;
7384 PyObject *swig_obj[1] ;
7385
7386 if (!args) SWIG_fail;
7387 swig_obj[0] = args;
7388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7389 if (!SWIG_IsOK(res1)) {
7390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7391 }
7392 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7393 {
7394 PyThreadState* __tstate = wxPyBeginAllowThreads();
7395 result = (int)(arg1)->GetX();
7396 wxPyEndAllowThreads(__tstate);
7397 if (PyErr_Occurred()) SWIG_fail;
7398 }
7399 resultobj = SWIG_From_int(static_cast< int >(result));
7400 return resultobj;
7401 fail:
7402 return NULL;
7403 }
7404
7405
7406 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7407 PyObject *resultobj = 0;
7408 wxMouseState *arg1 = (wxMouseState *) 0 ;
7409 int result;
7410 void *argp1 = 0 ;
7411 int res1 = 0 ;
7412 PyObject *swig_obj[1] ;
7413
7414 if (!args) SWIG_fail;
7415 swig_obj[0] = args;
7416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7417 if (!SWIG_IsOK(res1)) {
7418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7419 }
7420 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7421 {
7422 PyThreadState* __tstate = wxPyBeginAllowThreads();
7423 result = (int)(arg1)->GetY();
7424 wxPyEndAllowThreads(__tstate);
7425 if (PyErr_Occurred()) SWIG_fail;
7426 }
7427 resultobj = SWIG_From_int(static_cast< int >(result));
7428 return resultobj;
7429 fail:
7430 return NULL;
7431 }
7432
7433
7434 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7435 PyObject *resultobj = 0;
7436 wxMouseState *arg1 = (wxMouseState *) 0 ;
7437 bool result;
7438 void *argp1 = 0 ;
7439 int res1 = 0 ;
7440 PyObject *swig_obj[1] ;
7441
7442 if (!args) SWIG_fail;
7443 swig_obj[0] = args;
7444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7445 if (!SWIG_IsOK(res1)) {
7446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7447 }
7448 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7449 {
7450 PyThreadState* __tstate = wxPyBeginAllowThreads();
7451 result = (bool)(arg1)->LeftDown();
7452 wxPyEndAllowThreads(__tstate);
7453 if (PyErr_Occurred()) SWIG_fail;
7454 }
7455 {
7456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7457 }
7458 return resultobj;
7459 fail:
7460 return NULL;
7461 }
7462
7463
7464 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7465 PyObject *resultobj = 0;
7466 wxMouseState *arg1 = (wxMouseState *) 0 ;
7467 bool result;
7468 void *argp1 = 0 ;
7469 int res1 = 0 ;
7470 PyObject *swig_obj[1] ;
7471
7472 if (!args) SWIG_fail;
7473 swig_obj[0] = args;
7474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7475 if (!SWIG_IsOK(res1)) {
7476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7477 }
7478 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7479 {
7480 PyThreadState* __tstate = wxPyBeginAllowThreads();
7481 result = (bool)(arg1)->MiddleDown();
7482 wxPyEndAllowThreads(__tstate);
7483 if (PyErr_Occurred()) SWIG_fail;
7484 }
7485 {
7486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7487 }
7488 return resultobj;
7489 fail:
7490 return NULL;
7491 }
7492
7493
7494 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7495 PyObject *resultobj = 0;
7496 wxMouseState *arg1 = (wxMouseState *) 0 ;
7497 bool result;
7498 void *argp1 = 0 ;
7499 int res1 = 0 ;
7500 PyObject *swig_obj[1] ;
7501
7502 if (!args) SWIG_fail;
7503 swig_obj[0] = args;
7504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7505 if (!SWIG_IsOK(res1)) {
7506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7507 }
7508 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7509 {
7510 PyThreadState* __tstate = wxPyBeginAllowThreads();
7511 result = (bool)(arg1)->RightDown();
7512 wxPyEndAllowThreads(__tstate);
7513 if (PyErr_Occurred()) SWIG_fail;
7514 }
7515 {
7516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7517 }
7518 return resultobj;
7519 fail:
7520 return NULL;
7521 }
7522
7523
7524 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7525 PyObject *resultobj = 0;
7526 wxMouseState *arg1 = (wxMouseState *) 0 ;
7527 bool result;
7528 void *argp1 = 0 ;
7529 int res1 = 0 ;
7530 PyObject *swig_obj[1] ;
7531
7532 if (!args) SWIG_fail;
7533 swig_obj[0] = args;
7534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7535 if (!SWIG_IsOK(res1)) {
7536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7537 }
7538 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7539 {
7540 PyThreadState* __tstate = wxPyBeginAllowThreads();
7541 result = (bool)(arg1)->ControlDown();
7542 wxPyEndAllowThreads(__tstate);
7543 if (PyErr_Occurred()) SWIG_fail;
7544 }
7545 {
7546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7547 }
7548 return resultobj;
7549 fail:
7550 return NULL;
7551 }
7552
7553
7554 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7555 PyObject *resultobj = 0;
7556 wxMouseState *arg1 = (wxMouseState *) 0 ;
7557 bool result;
7558 void *argp1 = 0 ;
7559 int res1 = 0 ;
7560 PyObject *swig_obj[1] ;
7561
7562 if (!args) SWIG_fail;
7563 swig_obj[0] = args;
7564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7565 if (!SWIG_IsOK(res1)) {
7566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7567 }
7568 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7569 {
7570 PyThreadState* __tstate = wxPyBeginAllowThreads();
7571 result = (bool)(arg1)->ShiftDown();
7572 wxPyEndAllowThreads(__tstate);
7573 if (PyErr_Occurred()) SWIG_fail;
7574 }
7575 {
7576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7577 }
7578 return resultobj;
7579 fail:
7580 return NULL;
7581 }
7582
7583
7584 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7585 PyObject *resultobj = 0;
7586 wxMouseState *arg1 = (wxMouseState *) 0 ;
7587 bool result;
7588 void *argp1 = 0 ;
7589 int res1 = 0 ;
7590 PyObject *swig_obj[1] ;
7591
7592 if (!args) SWIG_fail;
7593 swig_obj[0] = args;
7594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7595 if (!SWIG_IsOK(res1)) {
7596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7597 }
7598 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7599 {
7600 PyThreadState* __tstate = wxPyBeginAllowThreads();
7601 result = (bool)(arg1)->AltDown();
7602 wxPyEndAllowThreads(__tstate);
7603 if (PyErr_Occurred()) SWIG_fail;
7604 }
7605 {
7606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7607 }
7608 return resultobj;
7609 fail:
7610 return NULL;
7611 }
7612
7613
7614 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7615 PyObject *resultobj = 0;
7616 wxMouseState *arg1 = (wxMouseState *) 0 ;
7617 bool result;
7618 void *argp1 = 0 ;
7619 int res1 = 0 ;
7620 PyObject *swig_obj[1] ;
7621
7622 if (!args) SWIG_fail;
7623 swig_obj[0] = args;
7624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7625 if (!SWIG_IsOK(res1)) {
7626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7627 }
7628 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7629 {
7630 PyThreadState* __tstate = wxPyBeginAllowThreads();
7631 result = (bool)(arg1)->MetaDown();
7632 wxPyEndAllowThreads(__tstate);
7633 if (PyErr_Occurred()) SWIG_fail;
7634 }
7635 {
7636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7637 }
7638 return resultobj;
7639 fail:
7640 return NULL;
7641 }
7642
7643
7644 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7645 PyObject *resultobj = 0;
7646 wxMouseState *arg1 = (wxMouseState *) 0 ;
7647 bool result;
7648 void *argp1 = 0 ;
7649 int res1 = 0 ;
7650 PyObject *swig_obj[1] ;
7651
7652 if (!args) SWIG_fail;
7653 swig_obj[0] = args;
7654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7655 if (!SWIG_IsOK(res1)) {
7656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7657 }
7658 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7659 {
7660 PyThreadState* __tstate = wxPyBeginAllowThreads();
7661 result = (bool)(arg1)->CmdDown();
7662 wxPyEndAllowThreads(__tstate);
7663 if (PyErr_Occurred()) SWIG_fail;
7664 }
7665 {
7666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7667 }
7668 return resultobj;
7669 fail:
7670 return NULL;
7671 }
7672
7673
7674 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7675 PyObject *resultobj = 0;
7676 wxMouseState *arg1 = (wxMouseState *) 0 ;
7677 int arg2 ;
7678 void *argp1 = 0 ;
7679 int res1 = 0 ;
7680 int val2 ;
7681 int ecode2 = 0 ;
7682 PyObject * obj0 = 0 ;
7683 PyObject * obj1 = 0 ;
7684 char * kwnames[] = {
7685 (char *) "self",(char *) "x", NULL
7686 };
7687
7688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7690 if (!SWIG_IsOK(res1)) {
7691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7692 }
7693 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7694 ecode2 = SWIG_AsVal_int(obj1, &val2);
7695 if (!SWIG_IsOK(ecode2)) {
7696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7697 }
7698 arg2 = static_cast< int >(val2);
7699 {
7700 PyThreadState* __tstate = wxPyBeginAllowThreads();
7701 (arg1)->SetX(arg2);
7702 wxPyEndAllowThreads(__tstate);
7703 if (PyErr_Occurred()) SWIG_fail;
7704 }
7705 resultobj = SWIG_Py_Void();
7706 return resultobj;
7707 fail:
7708 return NULL;
7709 }
7710
7711
7712 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7713 PyObject *resultobj = 0;
7714 wxMouseState *arg1 = (wxMouseState *) 0 ;
7715 int arg2 ;
7716 void *argp1 = 0 ;
7717 int res1 = 0 ;
7718 int val2 ;
7719 int ecode2 = 0 ;
7720 PyObject * obj0 = 0 ;
7721 PyObject * obj1 = 0 ;
7722 char * kwnames[] = {
7723 (char *) "self",(char *) "y", NULL
7724 };
7725
7726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7728 if (!SWIG_IsOK(res1)) {
7729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7730 }
7731 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7732 ecode2 = SWIG_AsVal_int(obj1, &val2);
7733 if (!SWIG_IsOK(ecode2)) {
7734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7735 }
7736 arg2 = static_cast< int >(val2);
7737 {
7738 PyThreadState* __tstate = wxPyBeginAllowThreads();
7739 (arg1)->SetY(arg2);
7740 wxPyEndAllowThreads(__tstate);
7741 if (PyErr_Occurred()) SWIG_fail;
7742 }
7743 resultobj = SWIG_Py_Void();
7744 return resultobj;
7745 fail:
7746 return NULL;
7747 }
7748
7749
7750 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7751 PyObject *resultobj = 0;
7752 wxMouseState *arg1 = (wxMouseState *) 0 ;
7753 bool arg2 ;
7754 void *argp1 = 0 ;
7755 int res1 = 0 ;
7756 bool val2 ;
7757 int ecode2 = 0 ;
7758 PyObject * obj0 = 0 ;
7759 PyObject * obj1 = 0 ;
7760 char * kwnames[] = {
7761 (char *) "self",(char *) "down", NULL
7762 };
7763
7764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7766 if (!SWIG_IsOK(res1)) {
7767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7768 }
7769 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7770 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7771 if (!SWIG_IsOK(ecode2)) {
7772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7773 }
7774 arg2 = static_cast< bool >(val2);
7775 {
7776 PyThreadState* __tstate = wxPyBeginAllowThreads();
7777 (arg1)->SetLeftDown(arg2);
7778 wxPyEndAllowThreads(__tstate);
7779 if (PyErr_Occurred()) SWIG_fail;
7780 }
7781 resultobj = SWIG_Py_Void();
7782 return resultobj;
7783 fail:
7784 return NULL;
7785 }
7786
7787
7788 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7789 PyObject *resultobj = 0;
7790 wxMouseState *arg1 = (wxMouseState *) 0 ;
7791 bool arg2 ;
7792 void *argp1 = 0 ;
7793 int res1 = 0 ;
7794 bool val2 ;
7795 int ecode2 = 0 ;
7796 PyObject * obj0 = 0 ;
7797 PyObject * obj1 = 0 ;
7798 char * kwnames[] = {
7799 (char *) "self",(char *) "down", NULL
7800 };
7801
7802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7804 if (!SWIG_IsOK(res1)) {
7805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7806 }
7807 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7808 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7809 if (!SWIG_IsOK(ecode2)) {
7810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7811 }
7812 arg2 = static_cast< bool >(val2);
7813 {
7814 PyThreadState* __tstate = wxPyBeginAllowThreads();
7815 (arg1)->SetMiddleDown(arg2);
7816 wxPyEndAllowThreads(__tstate);
7817 if (PyErr_Occurred()) SWIG_fail;
7818 }
7819 resultobj = SWIG_Py_Void();
7820 return resultobj;
7821 fail:
7822 return NULL;
7823 }
7824
7825
7826 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7827 PyObject *resultobj = 0;
7828 wxMouseState *arg1 = (wxMouseState *) 0 ;
7829 bool arg2 ;
7830 void *argp1 = 0 ;
7831 int res1 = 0 ;
7832 bool val2 ;
7833 int ecode2 = 0 ;
7834 PyObject * obj0 = 0 ;
7835 PyObject * obj1 = 0 ;
7836 char * kwnames[] = {
7837 (char *) "self",(char *) "down", NULL
7838 };
7839
7840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7842 if (!SWIG_IsOK(res1)) {
7843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7844 }
7845 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7846 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7847 if (!SWIG_IsOK(ecode2)) {
7848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7849 }
7850 arg2 = static_cast< bool >(val2);
7851 {
7852 PyThreadState* __tstate = wxPyBeginAllowThreads();
7853 (arg1)->SetRightDown(arg2);
7854 wxPyEndAllowThreads(__tstate);
7855 if (PyErr_Occurred()) SWIG_fail;
7856 }
7857 resultobj = SWIG_Py_Void();
7858 return resultobj;
7859 fail:
7860 return NULL;
7861 }
7862
7863
7864 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7865 PyObject *resultobj = 0;
7866 wxMouseState *arg1 = (wxMouseState *) 0 ;
7867 bool arg2 ;
7868 void *argp1 = 0 ;
7869 int res1 = 0 ;
7870 bool val2 ;
7871 int ecode2 = 0 ;
7872 PyObject * obj0 = 0 ;
7873 PyObject * obj1 = 0 ;
7874 char * kwnames[] = {
7875 (char *) "self",(char *) "down", NULL
7876 };
7877
7878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7880 if (!SWIG_IsOK(res1)) {
7881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7882 }
7883 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7884 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7885 if (!SWIG_IsOK(ecode2)) {
7886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7887 }
7888 arg2 = static_cast< bool >(val2);
7889 {
7890 PyThreadState* __tstate = wxPyBeginAllowThreads();
7891 (arg1)->SetControlDown(arg2);
7892 wxPyEndAllowThreads(__tstate);
7893 if (PyErr_Occurred()) SWIG_fail;
7894 }
7895 resultobj = SWIG_Py_Void();
7896 return resultobj;
7897 fail:
7898 return NULL;
7899 }
7900
7901
7902 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7903 PyObject *resultobj = 0;
7904 wxMouseState *arg1 = (wxMouseState *) 0 ;
7905 bool arg2 ;
7906 void *argp1 = 0 ;
7907 int res1 = 0 ;
7908 bool val2 ;
7909 int ecode2 = 0 ;
7910 PyObject * obj0 = 0 ;
7911 PyObject * obj1 = 0 ;
7912 char * kwnames[] = {
7913 (char *) "self",(char *) "down", NULL
7914 };
7915
7916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7918 if (!SWIG_IsOK(res1)) {
7919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7920 }
7921 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7922 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7923 if (!SWIG_IsOK(ecode2)) {
7924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7925 }
7926 arg2 = static_cast< bool >(val2);
7927 {
7928 PyThreadState* __tstate = wxPyBeginAllowThreads();
7929 (arg1)->SetShiftDown(arg2);
7930 wxPyEndAllowThreads(__tstate);
7931 if (PyErr_Occurred()) SWIG_fail;
7932 }
7933 resultobj = SWIG_Py_Void();
7934 return resultobj;
7935 fail:
7936 return NULL;
7937 }
7938
7939
7940 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7941 PyObject *resultobj = 0;
7942 wxMouseState *arg1 = (wxMouseState *) 0 ;
7943 bool arg2 ;
7944 void *argp1 = 0 ;
7945 int res1 = 0 ;
7946 bool val2 ;
7947 int ecode2 = 0 ;
7948 PyObject * obj0 = 0 ;
7949 PyObject * obj1 = 0 ;
7950 char * kwnames[] = {
7951 (char *) "self",(char *) "down", NULL
7952 };
7953
7954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7956 if (!SWIG_IsOK(res1)) {
7957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7958 }
7959 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7960 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7961 if (!SWIG_IsOK(ecode2)) {
7962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7963 }
7964 arg2 = static_cast< bool >(val2);
7965 {
7966 PyThreadState* __tstate = wxPyBeginAllowThreads();
7967 (arg1)->SetAltDown(arg2);
7968 wxPyEndAllowThreads(__tstate);
7969 if (PyErr_Occurred()) SWIG_fail;
7970 }
7971 resultobj = SWIG_Py_Void();
7972 return resultobj;
7973 fail:
7974 return NULL;
7975 }
7976
7977
7978 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7979 PyObject *resultobj = 0;
7980 wxMouseState *arg1 = (wxMouseState *) 0 ;
7981 bool arg2 ;
7982 void *argp1 = 0 ;
7983 int res1 = 0 ;
7984 bool val2 ;
7985 int ecode2 = 0 ;
7986 PyObject * obj0 = 0 ;
7987 PyObject * obj1 = 0 ;
7988 char * kwnames[] = {
7989 (char *) "self",(char *) "down", NULL
7990 };
7991
7992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7994 if (!SWIG_IsOK(res1)) {
7995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7996 }
7997 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7998 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7999 if (!SWIG_IsOK(ecode2)) {
8000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
8001 }
8002 arg2 = static_cast< bool >(val2);
8003 {
8004 PyThreadState* __tstate = wxPyBeginAllowThreads();
8005 (arg1)->SetMetaDown(arg2);
8006 wxPyEndAllowThreads(__tstate);
8007 if (PyErr_Occurred()) SWIG_fail;
8008 }
8009 resultobj = SWIG_Py_Void();
8010 return resultobj;
8011 fail:
8012 return NULL;
8013 }
8014
8015
8016 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8017 PyObject *obj;
8018 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8019 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8020 return SWIG_Py_Void();
8021 }
8022
8023 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8024 return SWIG_Python_InitShadowInstance(args);
8025 }
8026
8027 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8028 PyObject *resultobj = 0;
8029 wxMouseState result;
8030
8031 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8032 {
8033 PyThreadState* __tstate = wxPyBeginAllowThreads();
8034 result = wxGetMouseState();
8035 wxPyEndAllowThreads(__tstate);
8036 if (PyErr_Occurred()) SWIG_fail;
8037 }
8038 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8039 return resultobj;
8040 fail:
8041 return NULL;
8042 }
8043
8044
8045 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8046 PyObject *resultobj = 0;
8047
8048 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8049 {
8050 if (!wxPyCheckForApp()) SWIG_fail;
8051 PyThreadState* __tstate = wxPyBeginAllowThreads();
8052 wxWakeUpMainThread();
8053 wxPyEndAllowThreads(__tstate);
8054 if (PyErr_Occurred()) SWIG_fail;
8055 }
8056 resultobj = SWIG_Py_Void();
8057 return resultobj;
8058 fail:
8059 return NULL;
8060 }
8061
8062
8063 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8064 PyObject *resultobj = 0;
8065
8066 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8067 {
8068 if (!wxPyCheckForApp()) SWIG_fail;
8069 PyThreadState* __tstate = wxPyBeginAllowThreads();
8070 wxMutexGuiEnter();
8071 wxPyEndAllowThreads(__tstate);
8072 if (PyErr_Occurred()) SWIG_fail;
8073 }
8074 resultobj = SWIG_Py_Void();
8075 return resultobj;
8076 fail:
8077 return NULL;
8078 }
8079
8080
8081 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8082 PyObject *resultobj = 0;
8083
8084 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8085 {
8086 if (!wxPyCheckForApp()) SWIG_fail;
8087 PyThreadState* __tstate = wxPyBeginAllowThreads();
8088 wxMutexGuiLeave();
8089 wxPyEndAllowThreads(__tstate);
8090 if (PyErr_Occurred()) SWIG_fail;
8091 }
8092 resultobj = SWIG_Py_Void();
8093 return resultobj;
8094 fail:
8095 return NULL;
8096 }
8097
8098
8099 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8100 PyObject *resultobj = 0;
8101 wxMutexGuiLocker *result = 0 ;
8102
8103 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8104 {
8105 if (!wxPyCheckForApp()) SWIG_fail;
8106 PyThreadState* __tstate = wxPyBeginAllowThreads();
8107 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8108 wxPyEndAllowThreads(__tstate);
8109 if (PyErr_Occurred()) SWIG_fail;
8110 }
8111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8112 return resultobj;
8113 fail:
8114 return NULL;
8115 }
8116
8117
8118 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8119 PyObject *resultobj = 0;
8120 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8121 void *argp1 = 0 ;
8122 int res1 = 0 ;
8123 PyObject *swig_obj[1] ;
8124
8125 if (!args) SWIG_fail;
8126 swig_obj[0] = args;
8127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8128 if (!SWIG_IsOK(res1)) {
8129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8130 }
8131 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8132 {
8133 PyThreadState* __tstate = wxPyBeginAllowThreads();
8134 delete arg1;
8135
8136 wxPyEndAllowThreads(__tstate);
8137 if (PyErr_Occurred()) SWIG_fail;
8138 }
8139 resultobj = SWIG_Py_Void();
8140 return resultobj;
8141 fail:
8142 return NULL;
8143 }
8144
8145
8146 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8147 PyObject *obj;
8148 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8149 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8150 return SWIG_Py_Void();
8151 }
8152
8153 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8154 return SWIG_Python_InitShadowInstance(args);
8155 }
8156
8157 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8158 PyObject *resultobj = 0;
8159 bool result;
8160
8161 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8162 {
8163 PyThreadState* __tstate = wxPyBeginAllowThreads();
8164 result = (bool)wxThread_IsMain();
8165 wxPyEndAllowThreads(__tstate);
8166 if (PyErr_Occurred()) SWIG_fail;
8167 }
8168 {
8169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8170 }
8171 return resultobj;
8172 fail:
8173 return NULL;
8174 }
8175
8176
8177 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8178 PyObject *resultobj = 0;
8179 wxString *arg1 = 0 ;
8180 wxToolTip *result = 0 ;
8181 bool temp1 = false ;
8182 PyObject * obj0 = 0 ;
8183 char * kwnames[] = {
8184 (char *) "tip", NULL
8185 };
8186
8187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8188 {
8189 arg1 = wxString_in_helper(obj0);
8190 if (arg1 == NULL) SWIG_fail;
8191 temp1 = true;
8192 }
8193 {
8194 if (!wxPyCheckForApp()) SWIG_fail;
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8197 wxPyEndAllowThreads(__tstate);
8198 if (PyErr_Occurred()) SWIG_fail;
8199 }
8200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8201 {
8202 if (temp1)
8203 delete arg1;
8204 }
8205 return resultobj;
8206 fail:
8207 {
8208 if (temp1)
8209 delete arg1;
8210 }
8211 return NULL;
8212 }
8213
8214
8215 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8216 PyObject *resultobj = 0;
8217 wxToolTip *arg1 = (wxToolTip *) 0 ;
8218 void *argp1 = 0 ;
8219 int res1 = 0 ;
8220 PyObject *swig_obj[1] ;
8221
8222 if (!args) SWIG_fail;
8223 swig_obj[0] = args;
8224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8225 if (!SWIG_IsOK(res1)) {
8226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8227 }
8228 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8229 {
8230 PyThreadState* __tstate = wxPyBeginAllowThreads();
8231 delete arg1;
8232
8233 wxPyEndAllowThreads(__tstate);
8234 if (PyErr_Occurred()) SWIG_fail;
8235 }
8236 resultobj = SWIG_Py_Void();
8237 return resultobj;
8238 fail:
8239 return NULL;
8240 }
8241
8242
8243 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8244 PyObject *resultobj = 0;
8245 wxToolTip *arg1 = (wxToolTip *) 0 ;
8246 wxString *arg2 = 0 ;
8247 void *argp1 = 0 ;
8248 int res1 = 0 ;
8249 bool temp2 = false ;
8250 PyObject * obj0 = 0 ;
8251 PyObject * obj1 = 0 ;
8252 char * kwnames[] = {
8253 (char *) "self",(char *) "tip", NULL
8254 };
8255
8256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8258 if (!SWIG_IsOK(res1)) {
8259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8260 }
8261 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8262 {
8263 arg2 = wxString_in_helper(obj1);
8264 if (arg2 == NULL) SWIG_fail;
8265 temp2 = true;
8266 }
8267 {
8268 PyThreadState* __tstate = wxPyBeginAllowThreads();
8269 (arg1)->SetTip((wxString const &)*arg2);
8270 wxPyEndAllowThreads(__tstate);
8271 if (PyErr_Occurred()) SWIG_fail;
8272 }
8273 resultobj = SWIG_Py_Void();
8274 {
8275 if (temp2)
8276 delete arg2;
8277 }
8278 return resultobj;
8279 fail:
8280 {
8281 if (temp2)
8282 delete arg2;
8283 }
8284 return NULL;
8285 }
8286
8287
8288 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8289 PyObject *resultobj = 0;
8290 wxToolTip *arg1 = (wxToolTip *) 0 ;
8291 wxString result;
8292 void *argp1 = 0 ;
8293 int res1 = 0 ;
8294 PyObject *swig_obj[1] ;
8295
8296 if (!args) SWIG_fail;
8297 swig_obj[0] = args;
8298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8299 if (!SWIG_IsOK(res1)) {
8300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8301 }
8302 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8303 {
8304 PyThreadState* __tstate = wxPyBeginAllowThreads();
8305 result = (arg1)->GetTip();
8306 wxPyEndAllowThreads(__tstate);
8307 if (PyErr_Occurred()) SWIG_fail;
8308 }
8309 {
8310 #if wxUSE_UNICODE
8311 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8312 #else
8313 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8314 #endif
8315 }
8316 return resultobj;
8317 fail:
8318 return NULL;
8319 }
8320
8321
8322 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8323 PyObject *resultobj = 0;
8324 wxToolTip *arg1 = (wxToolTip *) 0 ;
8325 wxWindow *result = 0 ;
8326 void *argp1 = 0 ;
8327 int res1 = 0 ;
8328 PyObject *swig_obj[1] ;
8329
8330 if (!args) SWIG_fail;
8331 swig_obj[0] = args;
8332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8333 if (!SWIG_IsOK(res1)) {
8334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8335 }
8336 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8337 {
8338 PyThreadState* __tstate = wxPyBeginAllowThreads();
8339 result = (wxWindow *)(arg1)->GetWindow();
8340 wxPyEndAllowThreads(__tstate);
8341 if (PyErr_Occurred()) SWIG_fail;
8342 }
8343 {
8344 resultobj = wxPyMake_wxObject(result, 0);
8345 }
8346 return resultobj;
8347 fail:
8348 return NULL;
8349 }
8350
8351
8352 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8353 PyObject *resultobj = 0;
8354 bool arg1 ;
8355 bool val1 ;
8356 int ecode1 = 0 ;
8357 PyObject * obj0 = 0 ;
8358 char * kwnames[] = {
8359 (char *) "flag", NULL
8360 };
8361
8362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8363 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8364 if (!SWIG_IsOK(ecode1)) {
8365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8366 }
8367 arg1 = static_cast< bool >(val1);
8368 {
8369 PyThreadState* __tstate = wxPyBeginAllowThreads();
8370 wxToolTip::Enable(arg1);
8371 wxPyEndAllowThreads(__tstate);
8372 if (PyErr_Occurred()) SWIG_fail;
8373 }
8374 resultobj = SWIG_Py_Void();
8375 return resultobj;
8376 fail:
8377 return NULL;
8378 }
8379
8380
8381 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8382 PyObject *resultobj = 0;
8383 long arg1 ;
8384 long val1 ;
8385 int ecode1 = 0 ;
8386 PyObject * obj0 = 0 ;
8387 char * kwnames[] = {
8388 (char *) "milliseconds", NULL
8389 };
8390
8391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8392 ecode1 = SWIG_AsVal_long(obj0, &val1);
8393 if (!SWIG_IsOK(ecode1)) {
8394 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8395 }
8396 arg1 = static_cast< long >(val1);
8397 {
8398 PyThreadState* __tstate = wxPyBeginAllowThreads();
8399 wxToolTip::SetDelay(arg1);
8400 wxPyEndAllowThreads(__tstate);
8401 if (PyErr_Occurred()) SWIG_fail;
8402 }
8403 resultobj = SWIG_Py_Void();
8404 return resultobj;
8405 fail:
8406 return NULL;
8407 }
8408
8409
8410 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8411 PyObject *obj;
8412 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8413 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8414 return SWIG_Py_Void();
8415 }
8416
8417 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8418 return SWIG_Python_InitShadowInstance(args);
8419 }
8420
8421 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8422 PyObject *resultobj = 0;
8423 wxWindow *arg1 = (wxWindow *) 0 ;
8424 wxSize *arg2 = 0 ;
8425 wxCaret *result = 0 ;
8426 void *argp1 = 0 ;
8427 int res1 = 0 ;
8428 wxSize temp2 ;
8429 PyObject * obj0 = 0 ;
8430 PyObject * obj1 = 0 ;
8431 char * kwnames[] = {
8432 (char *) "window",(char *) "size", NULL
8433 };
8434
8435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8437 if (!SWIG_IsOK(res1)) {
8438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8439 }
8440 arg1 = reinterpret_cast< wxWindow * >(argp1);
8441 {
8442 arg2 = &temp2;
8443 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8444 }
8445 {
8446 if (!wxPyCheckForApp()) SWIG_fail;
8447 PyThreadState* __tstate = wxPyBeginAllowThreads();
8448 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8449 wxPyEndAllowThreads(__tstate);
8450 if (PyErr_Occurred()) SWIG_fail;
8451 }
8452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8453 return resultobj;
8454 fail:
8455 return NULL;
8456 }
8457
8458
8459 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8460 PyObject *resultobj = 0;
8461 wxCaret *arg1 = (wxCaret *) 0 ;
8462 void *argp1 = 0 ;
8463 int res1 = 0 ;
8464 PyObject *swig_obj[1] ;
8465
8466 if (!args) SWIG_fail;
8467 swig_obj[0] = args;
8468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8469 if (!SWIG_IsOK(res1)) {
8470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8471 }
8472 arg1 = reinterpret_cast< wxCaret * >(argp1);
8473 {
8474 PyThreadState* __tstate = wxPyBeginAllowThreads();
8475 delete arg1;
8476
8477 wxPyEndAllowThreads(__tstate);
8478 if (PyErr_Occurred()) SWIG_fail;
8479 }
8480 resultobj = SWIG_Py_Void();
8481 return resultobj;
8482 fail:
8483 return NULL;
8484 }
8485
8486
8487 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8488 PyObject *resultobj = 0;
8489 wxCaret *arg1 = (wxCaret *) 0 ;
8490 void *argp1 = 0 ;
8491 int res1 = 0 ;
8492 PyObject *swig_obj[1] ;
8493
8494 if (!args) SWIG_fail;
8495 swig_obj[0] = args;
8496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8497 if (!SWIG_IsOK(res1)) {
8498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8499 }
8500 arg1 = reinterpret_cast< wxCaret * >(argp1);
8501 {
8502 PyThreadState* __tstate = wxPyBeginAllowThreads();
8503 wxCaret_Destroy(arg1);
8504 wxPyEndAllowThreads(__tstate);
8505 if (PyErr_Occurred()) SWIG_fail;
8506 }
8507 resultobj = SWIG_Py_Void();
8508 return resultobj;
8509 fail:
8510 return NULL;
8511 }
8512
8513
8514 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8515 PyObject *resultobj = 0;
8516 wxCaret *arg1 = (wxCaret *) 0 ;
8517 bool result;
8518 void *argp1 = 0 ;
8519 int res1 = 0 ;
8520 PyObject *swig_obj[1] ;
8521
8522 if (!args) SWIG_fail;
8523 swig_obj[0] = args;
8524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8525 if (!SWIG_IsOK(res1)) {
8526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8527 }
8528 arg1 = reinterpret_cast< wxCaret * >(argp1);
8529 {
8530 PyThreadState* __tstate = wxPyBeginAllowThreads();
8531 result = (bool)(arg1)->IsOk();
8532 wxPyEndAllowThreads(__tstate);
8533 if (PyErr_Occurred()) SWIG_fail;
8534 }
8535 {
8536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8537 }
8538 return resultobj;
8539 fail:
8540 return NULL;
8541 }
8542
8543
8544 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8545 PyObject *resultobj = 0;
8546 wxCaret *arg1 = (wxCaret *) 0 ;
8547 bool result;
8548 void *argp1 = 0 ;
8549 int res1 = 0 ;
8550 PyObject *swig_obj[1] ;
8551
8552 if (!args) SWIG_fail;
8553 swig_obj[0] = args;
8554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8555 if (!SWIG_IsOK(res1)) {
8556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8557 }
8558 arg1 = reinterpret_cast< wxCaret * >(argp1);
8559 {
8560 PyThreadState* __tstate = wxPyBeginAllowThreads();
8561 result = (bool)(arg1)->IsVisible();
8562 wxPyEndAllowThreads(__tstate);
8563 if (PyErr_Occurred()) SWIG_fail;
8564 }
8565 {
8566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8567 }
8568 return resultobj;
8569 fail:
8570 return NULL;
8571 }
8572
8573
8574 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8575 PyObject *resultobj = 0;
8576 wxCaret *arg1 = (wxCaret *) 0 ;
8577 wxPoint result;
8578 void *argp1 = 0 ;
8579 int res1 = 0 ;
8580 PyObject *swig_obj[1] ;
8581
8582 if (!args) SWIG_fail;
8583 swig_obj[0] = args;
8584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8585 if (!SWIG_IsOK(res1)) {
8586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8587 }
8588 arg1 = reinterpret_cast< wxCaret * >(argp1);
8589 {
8590 PyThreadState* __tstate = wxPyBeginAllowThreads();
8591 result = (arg1)->GetPosition();
8592 wxPyEndAllowThreads(__tstate);
8593 if (PyErr_Occurred()) SWIG_fail;
8594 }
8595 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8596 return resultobj;
8597 fail:
8598 return NULL;
8599 }
8600
8601
8602 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8603 PyObject *resultobj = 0;
8604 wxCaret *arg1 = (wxCaret *) 0 ;
8605 int *arg2 = (int *) 0 ;
8606 int *arg3 = (int *) 0 ;
8607 void *argp1 = 0 ;
8608 int res1 = 0 ;
8609 int temp2 ;
8610 int res2 = SWIG_TMPOBJ ;
8611 int temp3 ;
8612 int res3 = SWIG_TMPOBJ ;
8613 PyObject *swig_obj[1] ;
8614
8615 arg2 = &temp2;
8616 arg3 = &temp3;
8617 if (!args) SWIG_fail;
8618 swig_obj[0] = args;
8619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8620 if (!SWIG_IsOK(res1)) {
8621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8622 }
8623 arg1 = reinterpret_cast< wxCaret * >(argp1);
8624 {
8625 PyThreadState* __tstate = wxPyBeginAllowThreads();
8626 (arg1)->GetPosition(arg2,arg3);
8627 wxPyEndAllowThreads(__tstate);
8628 if (PyErr_Occurred()) SWIG_fail;
8629 }
8630 resultobj = SWIG_Py_Void();
8631 if (SWIG_IsTmpObj(res2)) {
8632 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8633 } else {
8634 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8635 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8636 }
8637 if (SWIG_IsTmpObj(res3)) {
8638 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8639 } else {
8640 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8641 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8642 }
8643 return resultobj;
8644 fail:
8645 return NULL;
8646 }
8647
8648
8649 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8650 PyObject *resultobj = 0;
8651 wxCaret *arg1 = (wxCaret *) 0 ;
8652 wxSize result;
8653 void *argp1 = 0 ;
8654 int res1 = 0 ;
8655 PyObject *swig_obj[1] ;
8656
8657 if (!args) SWIG_fail;
8658 swig_obj[0] = args;
8659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8660 if (!SWIG_IsOK(res1)) {
8661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8662 }
8663 arg1 = reinterpret_cast< wxCaret * >(argp1);
8664 {
8665 PyThreadState* __tstate = wxPyBeginAllowThreads();
8666 result = (arg1)->GetSize();
8667 wxPyEndAllowThreads(__tstate);
8668 if (PyErr_Occurred()) SWIG_fail;
8669 }
8670 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8671 return resultobj;
8672 fail:
8673 return NULL;
8674 }
8675
8676
8677 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8678 PyObject *resultobj = 0;
8679 wxCaret *arg1 = (wxCaret *) 0 ;
8680 int *arg2 = (int *) 0 ;
8681 int *arg3 = (int *) 0 ;
8682 void *argp1 = 0 ;
8683 int res1 = 0 ;
8684 int temp2 ;
8685 int res2 = SWIG_TMPOBJ ;
8686 int temp3 ;
8687 int res3 = SWIG_TMPOBJ ;
8688 PyObject *swig_obj[1] ;
8689
8690 arg2 = &temp2;
8691 arg3 = &temp3;
8692 if (!args) SWIG_fail;
8693 swig_obj[0] = args;
8694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8695 if (!SWIG_IsOK(res1)) {
8696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8697 }
8698 arg1 = reinterpret_cast< wxCaret * >(argp1);
8699 {
8700 PyThreadState* __tstate = wxPyBeginAllowThreads();
8701 (arg1)->GetSize(arg2,arg3);
8702 wxPyEndAllowThreads(__tstate);
8703 if (PyErr_Occurred()) SWIG_fail;
8704 }
8705 resultobj = SWIG_Py_Void();
8706 if (SWIG_IsTmpObj(res2)) {
8707 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8708 } else {
8709 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8710 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8711 }
8712 if (SWIG_IsTmpObj(res3)) {
8713 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8714 } else {
8715 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8716 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8717 }
8718 return resultobj;
8719 fail:
8720 return NULL;
8721 }
8722
8723
8724 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8725 PyObject *resultobj = 0;
8726 wxCaret *arg1 = (wxCaret *) 0 ;
8727 wxWindow *result = 0 ;
8728 void *argp1 = 0 ;
8729 int res1 = 0 ;
8730 PyObject *swig_obj[1] ;
8731
8732 if (!args) SWIG_fail;
8733 swig_obj[0] = args;
8734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8735 if (!SWIG_IsOK(res1)) {
8736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8737 }
8738 arg1 = reinterpret_cast< wxCaret * >(argp1);
8739 {
8740 PyThreadState* __tstate = wxPyBeginAllowThreads();
8741 result = (wxWindow *)(arg1)->GetWindow();
8742 wxPyEndAllowThreads(__tstate);
8743 if (PyErr_Occurred()) SWIG_fail;
8744 }
8745 {
8746 resultobj = wxPyMake_wxObject(result, 0);
8747 }
8748 return resultobj;
8749 fail:
8750 return NULL;
8751 }
8752
8753
8754 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8755 PyObject *resultobj = 0;
8756 wxCaret *arg1 = (wxCaret *) 0 ;
8757 int arg2 ;
8758 int arg3 ;
8759 void *argp1 = 0 ;
8760 int res1 = 0 ;
8761 int val2 ;
8762 int ecode2 = 0 ;
8763 int val3 ;
8764 int ecode3 = 0 ;
8765 PyObject * obj0 = 0 ;
8766 PyObject * obj1 = 0 ;
8767 PyObject * obj2 = 0 ;
8768 char * kwnames[] = {
8769 (char *) "self",(char *) "x",(char *) "y", NULL
8770 };
8771
8772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8774 if (!SWIG_IsOK(res1)) {
8775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8776 }
8777 arg1 = reinterpret_cast< wxCaret * >(argp1);
8778 ecode2 = SWIG_AsVal_int(obj1, &val2);
8779 if (!SWIG_IsOK(ecode2)) {
8780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8781 }
8782 arg2 = static_cast< int >(val2);
8783 ecode3 = SWIG_AsVal_int(obj2, &val3);
8784 if (!SWIG_IsOK(ecode3)) {
8785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8786 }
8787 arg3 = static_cast< int >(val3);
8788 {
8789 PyThreadState* __tstate = wxPyBeginAllowThreads();
8790 (arg1)->Move(arg2,arg3);
8791 wxPyEndAllowThreads(__tstate);
8792 if (PyErr_Occurred()) SWIG_fail;
8793 }
8794 resultobj = SWIG_Py_Void();
8795 return resultobj;
8796 fail:
8797 return NULL;
8798 }
8799
8800
8801 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8802 PyObject *resultobj = 0;
8803 wxCaret *arg1 = (wxCaret *) 0 ;
8804 wxPoint *arg2 = 0 ;
8805 void *argp1 = 0 ;
8806 int res1 = 0 ;
8807 wxPoint temp2 ;
8808 PyObject * obj0 = 0 ;
8809 PyObject * obj1 = 0 ;
8810 char * kwnames[] = {
8811 (char *) "self",(char *) "pt", NULL
8812 };
8813
8814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8816 if (!SWIG_IsOK(res1)) {
8817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8818 }
8819 arg1 = reinterpret_cast< wxCaret * >(argp1);
8820 {
8821 arg2 = &temp2;
8822 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8823 }
8824 {
8825 PyThreadState* __tstate = wxPyBeginAllowThreads();
8826 (arg1)->Move((wxPoint const &)*arg2);
8827 wxPyEndAllowThreads(__tstate);
8828 if (PyErr_Occurred()) SWIG_fail;
8829 }
8830 resultobj = SWIG_Py_Void();
8831 return resultobj;
8832 fail:
8833 return NULL;
8834 }
8835
8836
8837 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8838 PyObject *resultobj = 0;
8839 wxCaret *arg1 = (wxCaret *) 0 ;
8840 int arg2 ;
8841 int arg3 ;
8842 void *argp1 = 0 ;
8843 int res1 = 0 ;
8844 int val2 ;
8845 int ecode2 = 0 ;
8846 int val3 ;
8847 int ecode3 = 0 ;
8848 PyObject * obj0 = 0 ;
8849 PyObject * obj1 = 0 ;
8850 PyObject * obj2 = 0 ;
8851 char * kwnames[] = {
8852 (char *) "self",(char *) "width",(char *) "height", NULL
8853 };
8854
8855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8857 if (!SWIG_IsOK(res1)) {
8858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8859 }
8860 arg1 = reinterpret_cast< wxCaret * >(argp1);
8861 ecode2 = SWIG_AsVal_int(obj1, &val2);
8862 if (!SWIG_IsOK(ecode2)) {
8863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8864 }
8865 arg2 = static_cast< int >(val2);
8866 ecode3 = SWIG_AsVal_int(obj2, &val3);
8867 if (!SWIG_IsOK(ecode3)) {
8868 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8869 }
8870 arg3 = static_cast< int >(val3);
8871 {
8872 PyThreadState* __tstate = wxPyBeginAllowThreads();
8873 (arg1)->SetSize(arg2,arg3);
8874 wxPyEndAllowThreads(__tstate);
8875 if (PyErr_Occurred()) SWIG_fail;
8876 }
8877 resultobj = SWIG_Py_Void();
8878 return resultobj;
8879 fail:
8880 return NULL;
8881 }
8882
8883
8884 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8885 PyObject *resultobj = 0;
8886 wxCaret *arg1 = (wxCaret *) 0 ;
8887 wxSize *arg2 = 0 ;
8888 void *argp1 = 0 ;
8889 int res1 = 0 ;
8890 wxSize temp2 ;
8891 PyObject * obj0 = 0 ;
8892 PyObject * obj1 = 0 ;
8893 char * kwnames[] = {
8894 (char *) "self",(char *) "size", NULL
8895 };
8896
8897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8899 if (!SWIG_IsOK(res1)) {
8900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8901 }
8902 arg1 = reinterpret_cast< wxCaret * >(argp1);
8903 {
8904 arg2 = &temp2;
8905 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8906 }
8907 {
8908 PyThreadState* __tstate = wxPyBeginAllowThreads();
8909 (arg1)->SetSize((wxSize const &)*arg2);
8910 wxPyEndAllowThreads(__tstate);
8911 if (PyErr_Occurred()) SWIG_fail;
8912 }
8913 resultobj = SWIG_Py_Void();
8914 return resultobj;
8915 fail:
8916 return NULL;
8917 }
8918
8919
8920 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8921 PyObject *resultobj = 0;
8922 wxCaret *arg1 = (wxCaret *) 0 ;
8923 int arg2 = (int) true ;
8924 void *argp1 = 0 ;
8925 int res1 = 0 ;
8926 int val2 ;
8927 int ecode2 = 0 ;
8928 PyObject * obj0 = 0 ;
8929 PyObject * obj1 = 0 ;
8930 char * kwnames[] = {
8931 (char *) "self",(char *) "show", NULL
8932 };
8933
8934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8936 if (!SWIG_IsOK(res1)) {
8937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8938 }
8939 arg1 = reinterpret_cast< wxCaret * >(argp1);
8940 if (obj1) {
8941 ecode2 = SWIG_AsVal_int(obj1, &val2);
8942 if (!SWIG_IsOK(ecode2)) {
8943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8944 }
8945 arg2 = static_cast< int >(val2);
8946 }
8947 {
8948 PyThreadState* __tstate = wxPyBeginAllowThreads();
8949 (arg1)->Show(arg2);
8950 wxPyEndAllowThreads(__tstate);
8951 if (PyErr_Occurred()) SWIG_fail;
8952 }
8953 resultobj = SWIG_Py_Void();
8954 return resultobj;
8955 fail:
8956 return NULL;
8957 }
8958
8959
8960 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8961 PyObject *resultobj = 0;
8962 wxCaret *arg1 = (wxCaret *) 0 ;
8963 void *argp1 = 0 ;
8964 int res1 = 0 ;
8965 PyObject *swig_obj[1] ;
8966
8967 if (!args) SWIG_fail;
8968 swig_obj[0] = args;
8969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8970 if (!SWIG_IsOK(res1)) {
8971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8972 }
8973 arg1 = reinterpret_cast< wxCaret * >(argp1);
8974 {
8975 PyThreadState* __tstate = wxPyBeginAllowThreads();
8976 (arg1)->Hide();
8977 wxPyEndAllowThreads(__tstate);
8978 if (PyErr_Occurred()) SWIG_fail;
8979 }
8980 resultobj = SWIG_Py_Void();
8981 return resultobj;
8982 fail:
8983 return NULL;
8984 }
8985
8986
8987 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8988 PyObject *resultobj = 0;
8989 int result;
8990
8991 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8992 {
8993 PyThreadState* __tstate = wxPyBeginAllowThreads();
8994 result = (int)wxCaret::GetBlinkTime();
8995 wxPyEndAllowThreads(__tstate);
8996 if (PyErr_Occurred()) SWIG_fail;
8997 }
8998 resultobj = SWIG_From_int(static_cast< int >(result));
8999 return resultobj;
9000 fail:
9001 return NULL;
9002 }
9003
9004
9005 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9006 PyObject *resultobj = 0;
9007 int arg1 ;
9008 int val1 ;
9009 int ecode1 = 0 ;
9010 PyObject * obj0 = 0 ;
9011 char * kwnames[] = {
9012 (char *) "milliseconds", NULL
9013 };
9014
9015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9016 ecode1 = SWIG_AsVal_int(obj0, &val1);
9017 if (!SWIG_IsOK(ecode1)) {
9018 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9019 }
9020 arg1 = static_cast< int >(val1);
9021 {
9022 PyThreadState* __tstate = wxPyBeginAllowThreads();
9023 wxCaret::SetBlinkTime(arg1);
9024 wxPyEndAllowThreads(__tstate);
9025 if (PyErr_Occurred()) SWIG_fail;
9026 }
9027 resultobj = SWIG_Py_Void();
9028 return resultobj;
9029 fail:
9030 return NULL;
9031 }
9032
9033
9034 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9035 PyObject *obj;
9036 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9037 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9038 return SWIG_Py_Void();
9039 }
9040
9041 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9042 return SWIG_Python_InitShadowInstance(args);
9043 }
9044
9045 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9046 PyObject *resultobj = 0;
9047 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9048 wxBusyCursor *result = 0 ;
9049 void *argp1 = 0 ;
9050 int res1 = 0 ;
9051 PyObject * obj0 = 0 ;
9052 char * kwnames[] = {
9053 (char *) "cursor", NULL
9054 };
9055
9056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9057 if (obj0) {
9058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9059 if (!SWIG_IsOK(res1)) {
9060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9061 }
9062 arg1 = reinterpret_cast< wxCursor * >(argp1);
9063 }
9064 {
9065 if (!wxPyCheckForApp()) SWIG_fail;
9066 PyThreadState* __tstate = wxPyBeginAllowThreads();
9067 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9068 wxPyEndAllowThreads(__tstate);
9069 if (PyErr_Occurred()) SWIG_fail;
9070 }
9071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9072 return resultobj;
9073 fail:
9074 return NULL;
9075 }
9076
9077
9078 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9079 PyObject *resultobj = 0;
9080 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9081 void *argp1 = 0 ;
9082 int res1 = 0 ;
9083 PyObject *swig_obj[1] ;
9084
9085 if (!args) SWIG_fail;
9086 swig_obj[0] = args;
9087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9088 if (!SWIG_IsOK(res1)) {
9089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9090 }
9091 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9092 {
9093 PyThreadState* __tstate = wxPyBeginAllowThreads();
9094 delete arg1;
9095
9096 wxPyEndAllowThreads(__tstate);
9097 if (PyErr_Occurred()) SWIG_fail;
9098 }
9099 resultobj = SWIG_Py_Void();
9100 return resultobj;
9101 fail:
9102 return NULL;
9103 }
9104
9105
9106 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9107 PyObject *obj;
9108 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9109 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9110 return SWIG_Py_Void();
9111 }
9112
9113 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9114 return SWIG_Python_InitShadowInstance(args);
9115 }
9116
9117 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9118 PyObject *resultobj = 0;
9119 wxWindow *arg1 = (wxWindow *) NULL ;
9120 wxWindowDisabler *result = 0 ;
9121 void *argp1 = 0 ;
9122 int res1 = 0 ;
9123 PyObject * obj0 = 0 ;
9124 char * kwnames[] = {
9125 (char *) "winToSkip", NULL
9126 };
9127
9128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9129 if (obj0) {
9130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9131 if (!SWIG_IsOK(res1)) {
9132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9133 }
9134 arg1 = reinterpret_cast< wxWindow * >(argp1);
9135 }
9136 {
9137 if (!wxPyCheckForApp()) SWIG_fail;
9138 PyThreadState* __tstate = wxPyBeginAllowThreads();
9139 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9140 wxPyEndAllowThreads(__tstate);
9141 if (PyErr_Occurred()) SWIG_fail;
9142 }
9143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9144 return resultobj;
9145 fail:
9146 return NULL;
9147 }
9148
9149
9150 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9151 PyObject *resultobj = 0;
9152 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9153 void *argp1 = 0 ;
9154 int res1 = 0 ;
9155 PyObject *swig_obj[1] ;
9156
9157 if (!args) SWIG_fail;
9158 swig_obj[0] = args;
9159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9160 if (!SWIG_IsOK(res1)) {
9161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9162 }
9163 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9164 {
9165 PyThreadState* __tstate = wxPyBeginAllowThreads();
9166 delete arg1;
9167
9168 wxPyEndAllowThreads(__tstate);
9169 if (PyErr_Occurred()) SWIG_fail;
9170 }
9171 resultobj = SWIG_Py_Void();
9172 return resultobj;
9173 fail:
9174 return NULL;
9175 }
9176
9177
9178 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9179 PyObject *obj;
9180 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9181 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9182 return SWIG_Py_Void();
9183 }
9184
9185 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9186 return SWIG_Python_InitShadowInstance(args);
9187 }
9188
9189 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9190 PyObject *resultobj = 0;
9191 wxString *arg1 = 0 ;
9192 wxBusyInfo *result = 0 ;
9193 bool temp1 = false ;
9194 PyObject * obj0 = 0 ;
9195 char * kwnames[] = {
9196 (char *) "message", NULL
9197 };
9198
9199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9200 {
9201 arg1 = wxString_in_helper(obj0);
9202 if (arg1 == NULL) SWIG_fail;
9203 temp1 = true;
9204 }
9205 {
9206 if (!wxPyCheckForApp()) SWIG_fail;
9207 PyThreadState* __tstate = wxPyBeginAllowThreads();
9208 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9209 wxPyEndAllowThreads(__tstate);
9210 if (PyErr_Occurred()) SWIG_fail;
9211 }
9212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9213 {
9214 if (temp1)
9215 delete arg1;
9216 }
9217 return resultobj;
9218 fail:
9219 {
9220 if (temp1)
9221 delete arg1;
9222 }
9223 return NULL;
9224 }
9225
9226
9227 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9228 PyObject *resultobj = 0;
9229 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9230 void *argp1 = 0 ;
9231 int res1 = 0 ;
9232 PyObject *swig_obj[1] ;
9233
9234 if (!args) SWIG_fail;
9235 swig_obj[0] = args;
9236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9237 if (!SWIG_IsOK(res1)) {
9238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9239 }
9240 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9241 {
9242 PyThreadState* __tstate = wxPyBeginAllowThreads();
9243 delete arg1;
9244
9245 wxPyEndAllowThreads(__tstate);
9246 if (PyErr_Occurred()) SWIG_fail;
9247 }
9248 resultobj = SWIG_Py_Void();
9249 return resultobj;
9250 fail:
9251 return NULL;
9252 }
9253
9254
9255 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9256 PyObject *obj;
9257 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9258 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9259 return SWIG_Py_Void();
9260 }
9261
9262 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9263 return SWIG_Python_InitShadowInstance(args);
9264 }
9265
9266 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9267 PyObject *resultobj = 0;
9268 wxStopWatch *result = 0 ;
9269
9270 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9271 {
9272 PyThreadState* __tstate = wxPyBeginAllowThreads();
9273 result = (wxStopWatch *)new wxStopWatch();
9274 wxPyEndAllowThreads(__tstate);
9275 if (PyErr_Occurred()) SWIG_fail;
9276 }
9277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9278 return resultobj;
9279 fail:
9280 return NULL;
9281 }
9282
9283
9284 SWIGINTERN PyObject *_wrap_delete_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9285 PyObject *resultobj = 0;
9286 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9287 void *argp1 = 0 ;
9288 int res1 = 0 ;
9289 PyObject *swig_obj[1] ;
9290
9291 if (!args) SWIG_fail;
9292 swig_obj[0] = args;
9293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, SWIG_POINTER_DISOWN | 0 );
9294 if (!SWIG_IsOK(res1)) {
9295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StopWatch" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9296 }
9297 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9298 {
9299 PyThreadState* __tstate = wxPyBeginAllowThreads();
9300 delete arg1;
9301
9302 wxPyEndAllowThreads(__tstate);
9303 if (PyErr_Occurred()) SWIG_fail;
9304 }
9305 resultobj = SWIG_Py_Void();
9306 return resultobj;
9307 fail:
9308 return NULL;
9309 }
9310
9311
9312 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9313 PyObject *resultobj = 0;
9314 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9315 long arg2 = (long) 0 ;
9316 void *argp1 = 0 ;
9317 int res1 = 0 ;
9318 long val2 ;
9319 int ecode2 = 0 ;
9320 PyObject * obj0 = 0 ;
9321 PyObject * obj1 = 0 ;
9322 char * kwnames[] = {
9323 (char *) "self",(char *) "t0", NULL
9324 };
9325
9326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9328 if (!SWIG_IsOK(res1)) {
9329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9330 }
9331 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9332 if (obj1) {
9333 ecode2 = SWIG_AsVal_long(obj1, &val2);
9334 if (!SWIG_IsOK(ecode2)) {
9335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9336 }
9337 arg2 = static_cast< long >(val2);
9338 }
9339 {
9340 PyThreadState* __tstate = wxPyBeginAllowThreads();
9341 (arg1)->Start(arg2);
9342 wxPyEndAllowThreads(__tstate);
9343 if (PyErr_Occurred()) SWIG_fail;
9344 }
9345 resultobj = SWIG_Py_Void();
9346 return resultobj;
9347 fail:
9348 return NULL;
9349 }
9350
9351
9352 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9353 PyObject *resultobj = 0;
9354 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9355 void *argp1 = 0 ;
9356 int res1 = 0 ;
9357 PyObject *swig_obj[1] ;
9358
9359 if (!args) SWIG_fail;
9360 swig_obj[0] = args;
9361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9362 if (!SWIG_IsOK(res1)) {
9363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9364 }
9365 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9366 {
9367 PyThreadState* __tstate = wxPyBeginAllowThreads();
9368 (arg1)->Pause();
9369 wxPyEndAllowThreads(__tstate);
9370 if (PyErr_Occurred()) SWIG_fail;
9371 }
9372 resultobj = SWIG_Py_Void();
9373 return resultobj;
9374 fail:
9375 return NULL;
9376 }
9377
9378
9379 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9380 PyObject *resultobj = 0;
9381 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9382 void *argp1 = 0 ;
9383 int res1 = 0 ;
9384 PyObject *swig_obj[1] ;
9385
9386 if (!args) SWIG_fail;
9387 swig_obj[0] = args;
9388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9389 if (!SWIG_IsOK(res1)) {
9390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9391 }
9392 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9393 {
9394 PyThreadState* __tstate = wxPyBeginAllowThreads();
9395 (arg1)->Resume();
9396 wxPyEndAllowThreads(__tstate);
9397 if (PyErr_Occurred()) SWIG_fail;
9398 }
9399 resultobj = SWIG_Py_Void();
9400 return resultobj;
9401 fail:
9402 return NULL;
9403 }
9404
9405
9406 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9407 PyObject *resultobj = 0;
9408 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9409 long result;
9410 void *argp1 = 0 ;
9411 int res1 = 0 ;
9412 PyObject *swig_obj[1] ;
9413
9414 if (!args) SWIG_fail;
9415 swig_obj[0] = args;
9416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9417 if (!SWIG_IsOK(res1)) {
9418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9419 }
9420 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9421 {
9422 PyThreadState* __tstate = wxPyBeginAllowThreads();
9423 result = (long)((wxStopWatch const *)arg1)->Time();
9424 wxPyEndAllowThreads(__tstate);
9425 if (PyErr_Occurred()) SWIG_fail;
9426 }
9427 resultobj = SWIG_From_long(static_cast< long >(result));
9428 return resultobj;
9429 fail:
9430 return NULL;
9431 }
9432
9433
9434 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9435 PyObject *obj;
9436 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9437 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9438 return SWIG_Py_Void();
9439 }
9440
9441 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9442 return SWIG_Python_InitShadowInstance(args);
9443 }
9444
9445 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9446 PyObject *resultobj = 0;
9447 int arg1 = (int) 9 ;
9448 int arg2 = (int) wxID_FILE1 ;
9449 wxFileHistory *result = 0 ;
9450 int val1 ;
9451 int ecode1 = 0 ;
9452 int val2 ;
9453 int ecode2 = 0 ;
9454 PyObject * obj0 = 0 ;
9455 PyObject * obj1 = 0 ;
9456 char * kwnames[] = {
9457 (char *) "maxFiles",(char *) "idBase", NULL
9458 };
9459
9460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9461 if (obj0) {
9462 ecode1 = SWIG_AsVal_int(obj0, &val1);
9463 if (!SWIG_IsOK(ecode1)) {
9464 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9465 }
9466 arg1 = static_cast< int >(val1);
9467 }
9468 if (obj1) {
9469 ecode2 = SWIG_AsVal_int(obj1, &val2);
9470 if (!SWIG_IsOK(ecode2)) {
9471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9472 }
9473 arg2 = static_cast< int >(val2);
9474 }
9475 {
9476 PyThreadState* __tstate = wxPyBeginAllowThreads();
9477 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9478 wxPyEndAllowThreads(__tstate);
9479 if (PyErr_Occurred()) SWIG_fail;
9480 }
9481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9482 return resultobj;
9483 fail:
9484 return NULL;
9485 }
9486
9487
9488 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9489 PyObject *resultobj = 0;
9490 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9491 void *argp1 = 0 ;
9492 int res1 = 0 ;
9493 PyObject *swig_obj[1] ;
9494
9495 if (!args) SWIG_fail;
9496 swig_obj[0] = args;
9497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9498 if (!SWIG_IsOK(res1)) {
9499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9500 }
9501 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9502 {
9503 PyThreadState* __tstate = wxPyBeginAllowThreads();
9504 delete arg1;
9505
9506 wxPyEndAllowThreads(__tstate);
9507 if (PyErr_Occurred()) SWIG_fail;
9508 }
9509 resultobj = SWIG_Py_Void();
9510 return resultobj;
9511 fail:
9512 return NULL;
9513 }
9514
9515
9516 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9517 PyObject *resultobj = 0;
9518 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9519 wxString *arg2 = 0 ;
9520 void *argp1 = 0 ;
9521 int res1 = 0 ;
9522 bool temp2 = false ;
9523 PyObject * obj0 = 0 ;
9524 PyObject * obj1 = 0 ;
9525 char * kwnames[] = {
9526 (char *) "self",(char *) "file", NULL
9527 };
9528
9529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9531 if (!SWIG_IsOK(res1)) {
9532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9533 }
9534 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9535 {
9536 arg2 = wxString_in_helper(obj1);
9537 if (arg2 == NULL) SWIG_fail;
9538 temp2 = true;
9539 }
9540 {
9541 PyThreadState* __tstate = wxPyBeginAllowThreads();
9542 (arg1)->AddFileToHistory((wxString const &)*arg2);
9543 wxPyEndAllowThreads(__tstate);
9544 if (PyErr_Occurred()) SWIG_fail;
9545 }
9546 resultobj = SWIG_Py_Void();
9547 {
9548 if (temp2)
9549 delete arg2;
9550 }
9551 return resultobj;
9552 fail:
9553 {
9554 if (temp2)
9555 delete arg2;
9556 }
9557 return NULL;
9558 }
9559
9560
9561 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9562 PyObject *resultobj = 0;
9563 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9564 int arg2 ;
9565 void *argp1 = 0 ;
9566 int res1 = 0 ;
9567 int val2 ;
9568 int ecode2 = 0 ;
9569 PyObject * obj0 = 0 ;
9570 PyObject * obj1 = 0 ;
9571 char * kwnames[] = {
9572 (char *) "self",(char *) "i", NULL
9573 };
9574
9575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9577 if (!SWIG_IsOK(res1)) {
9578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9579 }
9580 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9581 ecode2 = SWIG_AsVal_int(obj1, &val2);
9582 if (!SWIG_IsOK(ecode2)) {
9583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9584 }
9585 arg2 = static_cast< int >(val2);
9586 {
9587 PyThreadState* __tstate = wxPyBeginAllowThreads();
9588 (arg1)->RemoveFileFromHistory(arg2);
9589 wxPyEndAllowThreads(__tstate);
9590 if (PyErr_Occurred()) SWIG_fail;
9591 }
9592 resultobj = SWIG_Py_Void();
9593 return resultobj;
9594 fail:
9595 return NULL;
9596 }
9597
9598
9599 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9600 PyObject *resultobj = 0;
9601 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9602 int result;
9603 void *argp1 = 0 ;
9604 int res1 = 0 ;
9605 PyObject *swig_obj[1] ;
9606
9607 if (!args) SWIG_fail;
9608 swig_obj[0] = args;
9609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9610 if (!SWIG_IsOK(res1)) {
9611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9612 }
9613 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9614 {
9615 PyThreadState* __tstate = wxPyBeginAllowThreads();
9616 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9617 wxPyEndAllowThreads(__tstate);
9618 if (PyErr_Occurred()) SWIG_fail;
9619 }
9620 resultobj = SWIG_From_int(static_cast< int >(result));
9621 return resultobj;
9622 fail:
9623 return NULL;
9624 }
9625
9626
9627 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9628 PyObject *resultobj = 0;
9629 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9630 wxMenu *arg2 = (wxMenu *) 0 ;
9631 void *argp1 = 0 ;
9632 int res1 = 0 ;
9633 void *argp2 = 0 ;
9634 int res2 = 0 ;
9635 PyObject * obj0 = 0 ;
9636 PyObject * obj1 = 0 ;
9637 char * kwnames[] = {
9638 (char *) "self",(char *) "menu", NULL
9639 };
9640
9641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9643 if (!SWIG_IsOK(res1)) {
9644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9645 }
9646 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9647 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9648 if (!SWIG_IsOK(res2)) {
9649 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9650 }
9651 arg2 = reinterpret_cast< wxMenu * >(argp2);
9652 {
9653 PyThreadState* __tstate = wxPyBeginAllowThreads();
9654 (arg1)->UseMenu(arg2);
9655 wxPyEndAllowThreads(__tstate);
9656 if (PyErr_Occurred()) SWIG_fail;
9657 }
9658 resultobj = SWIG_Py_Void();
9659 return resultobj;
9660 fail:
9661 return NULL;
9662 }
9663
9664
9665 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9666 PyObject *resultobj = 0;
9667 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9668 wxMenu *arg2 = (wxMenu *) 0 ;
9669 void *argp1 = 0 ;
9670 int res1 = 0 ;
9671 void *argp2 = 0 ;
9672 int res2 = 0 ;
9673 PyObject * obj0 = 0 ;
9674 PyObject * obj1 = 0 ;
9675 char * kwnames[] = {
9676 (char *) "self",(char *) "menu", NULL
9677 };
9678
9679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9681 if (!SWIG_IsOK(res1)) {
9682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9683 }
9684 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9685 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9686 if (!SWIG_IsOK(res2)) {
9687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9688 }
9689 arg2 = reinterpret_cast< wxMenu * >(argp2);
9690 {
9691 PyThreadState* __tstate = wxPyBeginAllowThreads();
9692 (arg1)->RemoveMenu(arg2);
9693 wxPyEndAllowThreads(__tstate);
9694 if (PyErr_Occurred()) SWIG_fail;
9695 }
9696 resultobj = SWIG_Py_Void();
9697 return resultobj;
9698 fail:
9699 return NULL;
9700 }
9701
9702
9703 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9704 PyObject *resultobj = 0;
9705 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9706 wxConfigBase *arg2 = 0 ;
9707 void *argp1 = 0 ;
9708 int res1 = 0 ;
9709 void *argp2 = 0 ;
9710 int res2 = 0 ;
9711 PyObject * obj0 = 0 ;
9712 PyObject * obj1 = 0 ;
9713 char * kwnames[] = {
9714 (char *) "self",(char *) "config", NULL
9715 };
9716
9717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9719 if (!SWIG_IsOK(res1)) {
9720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9721 }
9722 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9723 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9724 if (!SWIG_IsOK(res2)) {
9725 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9726 }
9727 if (!argp2) {
9728 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9729 }
9730 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9731 {
9732 PyThreadState* __tstate = wxPyBeginAllowThreads();
9733 (arg1)->Load(*arg2);
9734 wxPyEndAllowThreads(__tstate);
9735 if (PyErr_Occurred()) SWIG_fail;
9736 }
9737 resultobj = SWIG_Py_Void();
9738 return resultobj;
9739 fail:
9740 return NULL;
9741 }
9742
9743
9744 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9745 PyObject *resultobj = 0;
9746 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9747 wxConfigBase *arg2 = 0 ;
9748 void *argp1 = 0 ;
9749 int res1 = 0 ;
9750 void *argp2 = 0 ;
9751 int res2 = 0 ;
9752 PyObject * obj0 = 0 ;
9753 PyObject * obj1 = 0 ;
9754 char * kwnames[] = {
9755 (char *) "self",(char *) "config", NULL
9756 };
9757
9758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9760 if (!SWIG_IsOK(res1)) {
9761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9762 }
9763 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9764 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9765 if (!SWIG_IsOK(res2)) {
9766 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9767 }
9768 if (!argp2) {
9769 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9770 }
9771 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9772 {
9773 PyThreadState* __tstate = wxPyBeginAllowThreads();
9774 (arg1)->Save(*arg2);
9775 wxPyEndAllowThreads(__tstate);
9776 if (PyErr_Occurred()) SWIG_fail;
9777 }
9778 resultobj = SWIG_Py_Void();
9779 return resultobj;
9780 fail:
9781 return NULL;
9782 }
9783
9784
9785 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9786 PyObject *resultobj = 0;
9787 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9788 void *argp1 = 0 ;
9789 int res1 = 0 ;
9790 PyObject *swig_obj[1] ;
9791
9792 if (!args) SWIG_fail;
9793 swig_obj[0] = args;
9794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9795 if (!SWIG_IsOK(res1)) {
9796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9797 }
9798 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9799 {
9800 PyThreadState* __tstate = wxPyBeginAllowThreads();
9801 (arg1)->AddFilesToMenu();
9802 wxPyEndAllowThreads(__tstate);
9803 if (PyErr_Occurred()) SWIG_fail;
9804 }
9805 resultobj = SWIG_Py_Void();
9806 return resultobj;
9807 fail:
9808 return NULL;
9809 }
9810
9811
9812 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9813 PyObject *resultobj = 0;
9814 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9815 wxMenu *arg2 = (wxMenu *) 0 ;
9816 void *argp1 = 0 ;
9817 int res1 = 0 ;
9818 void *argp2 = 0 ;
9819 int res2 = 0 ;
9820 PyObject * obj0 = 0 ;
9821 PyObject * obj1 = 0 ;
9822 char * kwnames[] = {
9823 (char *) "self",(char *) "menu", NULL
9824 };
9825
9826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9828 if (!SWIG_IsOK(res1)) {
9829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9830 }
9831 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9832 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9833 if (!SWIG_IsOK(res2)) {
9834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9835 }
9836 arg2 = reinterpret_cast< wxMenu * >(argp2);
9837 {
9838 PyThreadState* __tstate = wxPyBeginAllowThreads();
9839 (arg1)->AddFilesToMenu(arg2);
9840 wxPyEndAllowThreads(__tstate);
9841 if (PyErr_Occurred()) SWIG_fail;
9842 }
9843 resultobj = SWIG_Py_Void();
9844 return resultobj;
9845 fail:
9846 return NULL;
9847 }
9848
9849
9850 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9851 PyObject *resultobj = 0;
9852 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9853 int arg2 ;
9854 wxString result;
9855 void *argp1 = 0 ;
9856 int res1 = 0 ;
9857 int val2 ;
9858 int ecode2 = 0 ;
9859 PyObject * obj0 = 0 ;
9860 PyObject * obj1 = 0 ;
9861 char * kwnames[] = {
9862 (char *) "self",(char *) "i", NULL
9863 };
9864
9865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9867 if (!SWIG_IsOK(res1)) {
9868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9869 }
9870 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9871 ecode2 = SWIG_AsVal_int(obj1, &val2);
9872 if (!SWIG_IsOK(ecode2)) {
9873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9874 }
9875 arg2 = static_cast< int >(val2);
9876 {
9877 PyThreadState* __tstate = wxPyBeginAllowThreads();
9878 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9879 wxPyEndAllowThreads(__tstate);
9880 if (PyErr_Occurred()) SWIG_fail;
9881 }
9882 {
9883 #if wxUSE_UNICODE
9884 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9885 #else
9886 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9887 #endif
9888 }
9889 return resultobj;
9890 fail:
9891 return NULL;
9892 }
9893
9894
9895 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9896 PyObject *resultobj = 0;
9897 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9898 int result;
9899 void *argp1 = 0 ;
9900 int res1 = 0 ;
9901 PyObject *swig_obj[1] ;
9902
9903 if (!args) SWIG_fail;
9904 swig_obj[0] = args;
9905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9906 if (!SWIG_IsOK(res1)) {
9907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9908 }
9909 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9910 {
9911 PyThreadState* __tstate = wxPyBeginAllowThreads();
9912 result = (int)((wxFileHistory const *)arg1)->GetCount();
9913 wxPyEndAllowThreads(__tstate);
9914 if (PyErr_Occurred()) SWIG_fail;
9915 }
9916 resultobj = SWIG_From_int(static_cast< int >(result));
9917 return resultobj;
9918 fail:
9919 return NULL;
9920 }
9921
9922
9923 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9924 PyObject *obj;
9925 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9926 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9927 return SWIG_Py_Void();
9928 }
9929
9930 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9931 return SWIG_Python_InitShadowInstance(args);
9932 }
9933
9934 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9935 PyObject *resultobj = 0;
9936 wxString *arg1 = 0 ;
9937 wxString const &arg2_defvalue = wxPyEmptyString ;
9938 wxString *arg2 = (wxString *) &arg2_defvalue ;
9939 wxSingleInstanceChecker *result = 0 ;
9940 bool temp1 = false ;
9941 bool temp2 = false ;
9942 PyObject * obj0 = 0 ;
9943 PyObject * obj1 = 0 ;
9944 char * kwnames[] = {
9945 (char *) "name",(char *) "path", NULL
9946 };
9947
9948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9949 {
9950 arg1 = wxString_in_helper(obj0);
9951 if (arg1 == NULL) SWIG_fail;
9952 temp1 = true;
9953 }
9954 if (obj1) {
9955 {
9956 arg2 = wxString_in_helper(obj1);
9957 if (arg2 == NULL) SWIG_fail;
9958 temp2 = true;
9959 }
9960 }
9961 {
9962 PyThreadState* __tstate = wxPyBeginAllowThreads();
9963 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9964 wxPyEndAllowThreads(__tstate);
9965 if (PyErr_Occurred()) SWIG_fail;
9966 }
9967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9968 {
9969 if (temp1)
9970 delete arg1;
9971 }
9972 {
9973 if (temp2)
9974 delete arg2;
9975 }
9976 return resultobj;
9977 fail:
9978 {
9979 if (temp1)
9980 delete arg1;
9981 }
9982 {
9983 if (temp2)
9984 delete arg2;
9985 }
9986 return NULL;
9987 }
9988
9989
9990 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9991 PyObject *resultobj = 0;
9992 wxSingleInstanceChecker *result = 0 ;
9993
9994 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9995 {
9996 PyThreadState* __tstate = wxPyBeginAllowThreads();
9997 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9998 wxPyEndAllowThreads(__tstate);
9999 if (PyErr_Occurred()) SWIG_fail;
10000 }
10001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
10002 return resultobj;
10003 fail:
10004 return NULL;
10005 }
10006
10007
10008 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10009 PyObject *resultobj = 0;
10010 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10011 void *argp1 = 0 ;
10012 int res1 = 0 ;
10013 PyObject *swig_obj[1] ;
10014
10015 if (!args) SWIG_fail;
10016 swig_obj[0] = args;
10017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
10018 if (!SWIG_IsOK(res1)) {
10019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10020 }
10021 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10022 {
10023 PyThreadState* __tstate = wxPyBeginAllowThreads();
10024 delete arg1;
10025
10026 wxPyEndAllowThreads(__tstate);
10027 if (PyErr_Occurred()) SWIG_fail;
10028 }
10029 resultobj = SWIG_Py_Void();
10030 return resultobj;
10031 fail:
10032 return NULL;
10033 }
10034
10035
10036 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10037 PyObject *resultobj = 0;
10038 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10039 wxString *arg2 = 0 ;
10040 wxString const &arg3_defvalue = wxPyEmptyString ;
10041 wxString *arg3 = (wxString *) &arg3_defvalue ;
10042 bool result;
10043 void *argp1 = 0 ;
10044 int res1 = 0 ;
10045 bool temp2 = false ;
10046 bool temp3 = false ;
10047 PyObject * obj0 = 0 ;
10048 PyObject * obj1 = 0 ;
10049 PyObject * obj2 = 0 ;
10050 char * kwnames[] = {
10051 (char *) "self",(char *) "name",(char *) "path", NULL
10052 };
10053
10054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10056 if (!SWIG_IsOK(res1)) {
10057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10058 }
10059 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10060 {
10061 arg2 = wxString_in_helper(obj1);
10062 if (arg2 == NULL) SWIG_fail;
10063 temp2 = true;
10064 }
10065 if (obj2) {
10066 {
10067 arg3 = wxString_in_helper(obj2);
10068 if (arg3 == NULL) SWIG_fail;
10069 temp3 = true;
10070 }
10071 }
10072 {
10073 PyThreadState* __tstate = wxPyBeginAllowThreads();
10074 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10075 wxPyEndAllowThreads(__tstate);
10076 if (PyErr_Occurred()) SWIG_fail;
10077 }
10078 {
10079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10080 }
10081 {
10082 if (temp2)
10083 delete arg2;
10084 }
10085 {
10086 if (temp3)
10087 delete arg3;
10088 }
10089 return resultobj;
10090 fail:
10091 {
10092 if (temp2)
10093 delete arg2;
10094 }
10095 {
10096 if (temp3)
10097 delete arg3;
10098 }
10099 return NULL;
10100 }
10101
10102
10103 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10104 PyObject *resultobj = 0;
10105 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10106 bool result;
10107 void *argp1 = 0 ;
10108 int res1 = 0 ;
10109 PyObject *swig_obj[1] ;
10110
10111 if (!args) SWIG_fail;
10112 swig_obj[0] = args;
10113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10114 if (!SWIG_IsOK(res1)) {
10115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10116 }
10117 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10118 {
10119 PyThreadState* __tstate = wxPyBeginAllowThreads();
10120 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10121 wxPyEndAllowThreads(__tstate);
10122 if (PyErr_Occurred()) SWIG_fail;
10123 }
10124 {
10125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10126 }
10127 return resultobj;
10128 fail:
10129 return NULL;
10130 }
10131
10132
10133 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10134 PyObject *obj;
10135 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10136 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10137 return SWIG_Py_Void();
10138 }
10139
10140 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10141 return SWIG_Python_InitShadowInstance(args);
10142 }
10143
10144 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10145 PyObject *resultobj = 0;
10146 wxPlatformInfo *result = 0 ;
10147
10148 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10149 {
10150 PyThreadState* __tstate = wxPyBeginAllowThreads();
10151 result = (wxPlatformInfo *)new wxPlatformInfo();
10152 wxPyEndAllowThreads(__tstate);
10153 if (PyErr_Occurred()) SWIG_fail;
10154 }
10155 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10156 return resultobj;
10157 fail:
10158 return NULL;
10159 }
10160
10161
10162 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10163 PyObject *resultobj = 0;
10164 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10165 wxPlatformInfo *arg2 = 0 ;
10166 bool result;
10167 void *argp1 = 0 ;
10168 int res1 = 0 ;
10169 void *argp2 = 0 ;
10170 int res2 = 0 ;
10171 PyObject * obj0 = 0 ;
10172 PyObject * obj1 = 0 ;
10173 char * kwnames[] = {
10174 (char *) "self",(char *) "t", NULL
10175 };
10176
10177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10179 if (!SWIG_IsOK(res1)) {
10180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10181 }
10182 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10183 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10184 if (!SWIG_IsOK(res2)) {
10185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10186 }
10187 if (!argp2) {
10188 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10189 }
10190 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10191 {
10192 PyThreadState* __tstate = wxPyBeginAllowThreads();
10193 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10194 wxPyEndAllowThreads(__tstate);
10195 if (PyErr_Occurred()) SWIG_fail;
10196 }
10197 {
10198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10199 }
10200 return resultobj;
10201 fail:
10202 return NULL;
10203 }
10204
10205
10206 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10207 PyObject *resultobj = 0;
10208 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10209 wxPlatformInfo *arg2 = 0 ;
10210 bool result;
10211 void *argp1 = 0 ;
10212 int res1 = 0 ;
10213 void *argp2 = 0 ;
10214 int res2 = 0 ;
10215 PyObject * obj0 = 0 ;
10216 PyObject * obj1 = 0 ;
10217 char * kwnames[] = {
10218 (char *) "self",(char *) "t", NULL
10219 };
10220
10221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10223 if (!SWIG_IsOK(res1)) {
10224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10225 }
10226 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10227 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10228 if (!SWIG_IsOK(res2)) {
10229 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10230 }
10231 if (!argp2) {
10232 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10233 }
10234 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10235 {
10236 PyThreadState* __tstate = wxPyBeginAllowThreads();
10237 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10238 wxPyEndAllowThreads(__tstate);
10239 if (PyErr_Occurred()) SWIG_fail;
10240 }
10241 {
10242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10243 }
10244 return resultobj;
10245 fail:
10246 return NULL;
10247 }
10248
10249
10250 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10251 PyObject *resultobj = 0;
10252 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10253 int result;
10254 void *argp1 = 0 ;
10255 int res1 = 0 ;
10256 PyObject *swig_obj[1] ;
10257
10258 if (!args) SWIG_fail;
10259 swig_obj[0] = args;
10260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10261 if (!SWIG_IsOK(res1)) {
10262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10263 }
10264 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10265 {
10266 PyThreadState* __tstate = wxPyBeginAllowThreads();
10267 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10268 wxPyEndAllowThreads(__tstate);
10269 if (PyErr_Occurred()) SWIG_fail;
10270 }
10271 resultobj = SWIG_From_int(static_cast< int >(result));
10272 return resultobj;
10273 fail:
10274 return NULL;
10275 }
10276
10277
10278 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10279 PyObject *resultobj = 0;
10280 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10281 int result;
10282 void *argp1 = 0 ;
10283 int res1 = 0 ;
10284 PyObject *swig_obj[1] ;
10285
10286 if (!args) SWIG_fail;
10287 swig_obj[0] = args;
10288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10289 if (!SWIG_IsOK(res1)) {
10290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10291 }
10292 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10293 {
10294 PyThreadState* __tstate = wxPyBeginAllowThreads();
10295 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10296 wxPyEndAllowThreads(__tstate);
10297 if (PyErr_Occurred()) SWIG_fail;
10298 }
10299 resultobj = SWIG_From_int(static_cast< int >(result));
10300 return resultobj;
10301 fail:
10302 return NULL;
10303 }
10304
10305
10306 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10307 PyObject *resultobj = 0;
10308 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10309 int arg2 ;
10310 int arg3 ;
10311 bool result;
10312 void *argp1 = 0 ;
10313 int res1 = 0 ;
10314 int val2 ;
10315 int ecode2 = 0 ;
10316 int val3 ;
10317 int ecode3 = 0 ;
10318 PyObject * obj0 = 0 ;
10319 PyObject * obj1 = 0 ;
10320 PyObject * obj2 = 0 ;
10321 char * kwnames[] = {
10322 (char *) "self",(char *) "major",(char *) "minor", NULL
10323 };
10324
10325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10327 if (!SWIG_IsOK(res1)) {
10328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10329 }
10330 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10331 ecode2 = SWIG_AsVal_int(obj1, &val2);
10332 if (!SWIG_IsOK(ecode2)) {
10333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10334 }
10335 arg2 = static_cast< int >(val2);
10336 ecode3 = SWIG_AsVal_int(obj2, &val3);
10337 if (!SWIG_IsOK(ecode3)) {
10338 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10339 }
10340 arg3 = static_cast< int >(val3);
10341 {
10342 PyThreadState* __tstate = wxPyBeginAllowThreads();
10343 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10344 wxPyEndAllowThreads(__tstate);
10345 if (PyErr_Occurred()) SWIG_fail;
10346 }
10347 {
10348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10349 }
10350 return resultobj;
10351 fail:
10352 return NULL;
10353 }
10354
10355
10356 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10357 PyObject *resultobj = 0;
10358 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10359 int result;
10360 void *argp1 = 0 ;
10361 int res1 = 0 ;
10362 PyObject *swig_obj[1] ;
10363
10364 if (!args) SWIG_fail;
10365 swig_obj[0] = args;
10366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10367 if (!SWIG_IsOK(res1)) {
10368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10369 }
10370 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10371 {
10372 PyThreadState* __tstate = wxPyBeginAllowThreads();
10373 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10374 wxPyEndAllowThreads(__tstate);
10375 if (PyErr_Occurred()) SWIG_fail;
10376 }
10377 resultobj = SWIG_From_int(static_cast< int >(result));
10378 return resultobj;
10379 fail:
10380 return NULL;
10381 }
10382
10383
10384 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10385 PyObject *resultobj = 0;
10386 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10387 int result;
10388 void *argp1 = 0 ;
10389 int res1 = 0 ;
10390 PyObject *swig_obj[1] ;
10391
10392 if (!args) SWIG_fail;
10393 swig_obj[0] = args;
10394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10395 if (!SWIG_IsOK(res1)) {
10396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10397 }
10398 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10399 {
10400 PyThreadState* __tstate = wxPyBeginAllowThreads();
10401 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10402 wxPyEndAllowThreads(__tstate);
10403 if (PyErr_Occurred()) SWIG_fail;
10404 }
10405 resultobj = SWIG_From_int(static_cast< int >(result));
10406 return resultobj;
10407 fail:
10408 return NULL;
10409 }
10410
10411
10412 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10413 PyObject *resultobj = 0;
10414 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10415 int arg2 ;
10416 int arg3 ;
10417 bool result;
10418 void *argp1 = 0 ;
10419 int res1 = 0 ;
10420 int val2 ;
10421 int ecode2 = 0 ;
10422 int val3 ;
10423 int ecode3 = 0 ;
10424 PyObject * obj0 = 0 ;
10425 PyObject * obj1 = 0 ;
10426 PyObject * obj2 = 0 ;
10427 char * kwnames[] = {
10428 (char *) "self",(char *) "major",(char *) "minor", NULL
10429 };
10430
10431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10433 if (!SWIG_IsOK(res1)) {
10434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10435 }
10436 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10437 ecode2 = SWIG_AsVal_int(obj1, &val2);
10438 if (!SWIG_IsOK(ecode2)) {
10439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10440 }
10441 arg2 = static_cast< int >(val2);
10442 ecode3 = SWIG_AsVal_int(obj2, &val3);
10443 if (!SWIG_IsOK(ecode3)) {
10444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10445 }
10446 arg3 = static_cast< int >(val3);
10447 {
10448 PyThreadState* __tstate = wxPyBeginAllowThreads();
10449 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10450 wxPyEndAllowThreads(__tstate);
10451 if (PyErr_Occurred()) SWIG_fail;
10452 }
10453 {
10454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10455 }
10456 return resultobj;
10457 fail:
10458 return NULL;
10459 }
10460
10461
10462 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10463 PyObject *resultobj = 0;
10464 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10465 bool result;
10466 void *argp1 = 0 ;
10467 int res1 = 0 ;
10468 PyObject *swig_obj[1] ;
10469
10470 if (!args) SWIG_fail;
10471 swig_obj[0] = args;
10472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10473 if (!SWIG_IsOK(res1)) {
10474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10475 }
10476 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10477 {
10478 PyThreadState* __tstate = wxPyBeginAllowThreads();
10479 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10480 wxPyEndAllowThreads(__tstate);
10481 if (PyErr_Occurred()) SWIG_fail;
10482 }
10483 {
10484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10485 }
10486 return resultobj;
10487 fail:
10488 return NULL;
10489 }
10490
10491
10492 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10493 PyObject *resultobj = 0;
10494 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10495 wxOperatingSystemId result;
10496 void *argp1 = 0 ;
10497 int res1 = 0 ;
10498 PyObject *swig_obj[1] ;
10499
10500 if (!args) SWIG_fail;
10501 swig_obj[0] = args;
10502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10503 if (!SWIG_IsOK(res1)) {
10504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10505 }
10506 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10507 {
10508 PyThreadState* __tstate = wxPyBeginAllowThreads();
10509 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10510 wxPyEndAllowThreads(__tstate);
10511 if (PyErr_Occurred()) SWIG_fail;
10512 }
10513 resultobj = SWIG_From_int(static_cast< int >(result));
10514 return resultobj;
10515 fail:
10516 return NULL;
10517 }
10518
10519
10520 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10521 PyObject *resultobj = 0;
10522 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10523 wxPortId result;
10524 void *argp1 = 0 ;
10525 int res1 = 0 ;
10526 PyObject *swig_obj[1] ;
10527
10528 if (!args) SWIG_fail;
10529 swig_obj[0] = args;
10530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10531 if (!SWIG_IsOK(res1)) {
10532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10533 }
10534 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10535 {
10536 PyThreadState* __tstate = wxPyBeginAllowThreads();
10537 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10538 wxPyEndAllowThreads(__tstate);
10539 if (PyErr_Occurred()) SWIG_fail;
10540 }
10541 resultobj = SWIG_From_int(static_cast< int >(result));
10542 return resultobj;
10543 fail:
10544 return NULL;
10545 }
10546
10547
10548 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10549 PyObject *resultobj = 0;
10550 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10551 wxArchitecture result;
10552 void *argp1 = 0 ;
10553 int res1 = 0 ;
10554 PyObject *swig_obj[1] ;
10555
10556 if (!args) SWIG_fail;
10557 swig_obj[0] = args;
10558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10559 if (!SWIG_IsOK(res1)) {
10560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10561 }
10562 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10563 {
10564 PyThreadState* __tstate = wxPyBeginAllowThreads();
10565 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10566 wxPyEndAllowThreads(__tstate);
10567 if (PyErr_Occurred()) SWIG_fail;
10568 }
10569 resultobj = SWIG_From_int(static_cast< int >(result));
10570 return resultobj;
10571 fail:
10572 return NULL;
10573 }
10574
10575
10576 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10577 PyObject *resultobj = 0;
10578 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10579 wxEndianness result;
10580 void *argp1 = 0 ;
10581 int res1 = 0 ;
10582 PyObject *swig_obj[1] ;
10583
10584 if (!args) SWIG_fail;
10585 swig_obj[0] = args;
10586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10587 if (!SWIG_IsOK(res1)) {
10588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10589 }
10590 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10591 {
10592 PyThreadState* __tstate = wxPyBeginAllowThreads();
10593 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10594 wxPyEndAllowThreads(__tstate);
10595 if (PyErr_Occurred()) SWIG_fail;
10596 }
10597 resultobj = SWIG_From_int(static_cast< int >(result));
10598 return resultobj;
10599 fail:
10600 return NULL;
10601 }
10602
10603
10604 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10605 PyObject *resultobj = 0;
10606 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10607 wxString result;
10608 void *argp1 = 0 ;
10609 int res1 = 0 ;
10610 PyObject *swig_obj[1] ;
10611
10612 if (!args) SWIG_fail;
10613 swig_obj[0] = args;
10614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10615 if (!SWIG_IsOK(res1)) {
10616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10617 }
10618 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10619 {
10620 PyThreadState* __tstate = wxPyBeginAllowThreads();
10621 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10622 wxPyEndAllowThreads(__tstate);
10623 if (PyErr_Occurred()) SWIG_fail;
10624 }
10625 {
10626 #if wxUSE_UNICODE
10627 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10628 #else
10629 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10630 #endif
10631 }
10632 return resultobj;
10633 fail:
10634 return NULL;
10635 }
10636
10637
10638 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10639 PyObject *resultobj = 0;
10640 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10641 wxString result;
10642 void *argp1 = 0 ;
10643 int res1 = 0 ;
10644 PyObject *swig_obj[1] ;
10645
10646 if (!args) SWIG_fail;
10647 swig_obj[0] = args;
10648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10649 if (!SWIG_IsOK(res1)) {
10650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10651 }
10652 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10653 {
10654 PyThreadState* __tstate = wxPyBeginAllowThreads();
10655 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10656 wxPyEndAllowThreads(__tstate);
10657 if (PyErr_Occurred()) SWIG_fail;
10658 }
10659 {
10660 #if wxUSE_UNICODE
10661 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10662 #else
10663 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10664 #endif
10665 }
10666 return resultobj;
10667 fail:
10668 return NULL;
10669 }
10670
10671
10672 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10673 PyObject *resultobj = 0;
10674 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10675 wxString result;
10676 void *argp1 = 0 ;
10677 int res1 = 0 ;
10678 PyObject *swig_obj[1] ;
10679
10680 if (!args) SWIG_fail;
10681 swig_obj[0] = args;
10682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10683 if (!SWIG_IsOK(res1)) {
10684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10685 }
10686 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10687 {
10688 PyThreadState* __tstate = wxPyBeginAllowThreads();
10689 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10690 wxPyEndAllowThreads(__tstate);
10691 if (PyErr_Occurred()) SWIG_fail;
10692 }
10693 {
10694 #if wxUSE_UNICODE
10695 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10696 #else
10697 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10698 #endif
10699 }
10700 return resultobj;
10701 fail:
10702 return NULL;
10703 }
10704
10705
10706 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10707 PyObject *resultobj = 0;
10708 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10709 wxString result;
10710 void *argp1 = 0 ;
10711 int res1 = 0 ;
10712 PyObject *swig_obj[1] ;
10713
10714 if (!args) SWIG_fail;
10715 swig_obj[0] = args;
10716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10717 if (!SWIG_IsOK(res1)) {
10718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10719 }
10720 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10721 {
10722 PyThreadState* __tstate = wxPyBeginAllowThreads();
10723 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10724 wxPyEndAllowThreads(__tstate);
10725 if (PyErr_Occurred()) SWIG_fail;
10726 }
10727 {
10728 #if wxUSE_UNICODE
10729 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10730 #else
10731 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10732 #endif
10733 }
10734 return resultobj;
10735 fail:
10736 return NULL;
10737 }
10738
10739
10740 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10741 PyObject *resultobj = 0;
10742 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10743 wxString result;
10744 void *argp1 = 0 ;
10745 int res1 = 0 ;
10746 PyObject *swig_obj[1] ;
10747
10748 if (!args) SWIG_fail;
10749 swig_obj[0] = args;
10750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10751 if (!SWIG_IsOK(res1)) {
10752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10753 }
10754 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10755 {
10756 PyThreadState* __tstate = wxPyBeginAllowThreads();
10757 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10758 wxPyEndAllowThreads(__tstate);
10759 if (PyErr_Occurred()) SWIG_fail;
10760 }
10761 {
10762 #if wxUSE_UNICODE
10763 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10764 #else
10765 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10766 #endif
10767 }
10768 return resultobj;
10769 fail:
10770 return NULL;
10771 }
10772
10773
10774 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10775 PyObject *resultobj = 0;
10776 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10777 wxString result;
10778 void *argp1 = 0 ;
10779 int res1 = 0 ;
10780 PyObject *swig_obj[1] ;
10781
10782 if (!args) SWIG_fail;
10783 swig_obj[0] = args;
10784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10785 if (!SWIG_IsOK(res1)) {
10786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10787 }
10788 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10789 {
10790 PyThreadState* __tstate = wxPyBeginAllowThreads();
10791 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10792 wxPyEndAllowThreads(__tstate);
10793 if (PyErr_Occurred()) SWIG_fail;
10794 }
10795 {
10796 #if wxUSE_UNICODE
10797 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10798 #else
10799 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10800 #endif
10801 }
10802 return resultobj;
10803 fail:
10804 return NULL;
10805 }
10806
10807
10808 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10809 PyObject *resultobj = 0;
10810 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10811 int arg2 ;
10812 int arg3 ;
10813 void *argp1 = 0 ;
10814 int res1 = 0 ;
10815 int val2 ;
10816 int ecode2 = 0 ;
10817 int val3 ;
10818 int ecode3 = 0 ;
10819 PyObject * obj0 = 0 ;
10820 PyObject * obj1 = 0 ;
10821 PyObject * obj2 = 0 ;
10822 char * kwnames[] = {
10823 (char *) "self",(char *) "major",(char *) "minor", NULL
10824 };
10825
10826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10828 if (!SWIG_IsOK(res1)) {
10829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10830 }
10831 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10832 ecode2 = SWIG_AsVal_int(obj1, &val2);
10833 if (!SWIG_IsOK(ecode2)) {
10834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10835 }
10836 arg2 = static_cast< int >(val2);
10837 ecode3 = SWIG_AsVal_int(obj2, &val3);
10838 if (!SWIG_IsOK(ecode3)) {
10839 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10840 }
10841 arg3 = static_cast< int >(val3);
10842 {
10843 PyThreadState* __tstate = wxPyBeginAllowThreads();
10844 (arg1)->SetOSVersion(arg2,arg3);
10845 wxPyEndAllowThreads(__tstate);
10846 if (PyErr_Occurred()) SWIG_fail;
10847 }
10848 resultobj = SWIG_Py_Void();
10849 return resultobj;
10850 fail:
10851 return NULL;
10852 }
10853
10854
10855 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10856 PyObject *resultobj = 0;
10857 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10858 int arg2 ;
10859 int arg3 ;
10860 void *argp1 = 0 ;
10861 int res1 = 0 ;
10862 int val2 ;
10863 int ecode2 = 0 ;
10864 int val3 ;
10865 int ecode3 = 0 ;
10866 PyObject * obj0 = 0 ;
10867 PyObject * obj1 = 0 ;
10868 PyObject * obj2 = 0 ;
10869 char * kwnames[] = {
10870 (char *) "self",(char *) "major",(char *) "minor", NULL
10871 };
10872
10873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10875 if (!SWIG_IsOK(res1)) {
10876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10877 }
10878 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10879 ecode2 = SWIG_AsVal_int(obj1, &val2);
10880 if (!SWIG_IsOK(ecode2)) {
10881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10882 }
10883 arg2 = static_cast< int >(val2);
10884 ecode3 = SWIG_AsVal_int(obj2, &val3);
10885 if (!SWIG_IsOK(ecode3)) {
10886 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10887 }
10888 arg3 = static_cast< int >(val3);
10889 {
10890 PyThreadState* __tstate = wxPyBeginAllowThreads();
10891 (arg1)->SetToolkitVersion(arg2,arg3);
10892 wxPyEndAllowThreads(__tstate);
10893 if (PyErr_Occurred()) SWIG_fail;
10894 }
10895 resultobj = SWIG_Py_Void();
10896 return resultobj;
10897 fail:
10898 return NULL;
10899 }
10900
10901
10902 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10903 PyObject *resultobj = 0;
10904 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10905 wxOperatingSystemId arg2 ;
10906 void *argp1 = 0 ;
10907 int res1 = 0 ;
10908 int val2 ;
10909 int ecode2 = 0 ;
10910 PyObject * obj0 = 0 ;
10911 PyObject * obj1 = 0 ;
10912 char * kwnames[] = {
10913 (char *) "self",(char *) "n", NULL
10914 };
10915
10916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10918 if (!SWIG_IsOK(res1)) {
10919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10920 }
10921 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10922 ecode2 = SWIG_AsVal_int(obj1, &val2);
10923 if (!SWIG_IsOK(ecode2)) {
10924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10925 }
10926 arg2 = static_cast< wxOperatingSystemId >(val2);
10927 {
10928 PyThreadState* __tstate = wxPyBeginAllowThreads();
10929 (arg1)->SetOperatingSystemId(arg2);
10930 wxPyEndAllowThreads(__tstate);
10931 if (PyErr_Occurred()) SWIG_fail;
10932 }
10933 resultobj = SWIG_Py_Void();
10934 return resultobj;
10935 fail:
10936 return NULL;
10937 }
10938
10939
10940 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10941 PyObject *resultobj = 0;
10942 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10943 wxPortId arg2 ;
10944 void *argp1 = 0 ;
10945 int res1 = 0 ;
10946 int val2 ;
10947 int ecode2 = 0 ;
10948 PyObject * obj0 = 0 ;
10949 PyObject * obj1 = 0 ;
10950 char * kwnames[] = {
10951 (char *) "self",(char *) "n", NULL
10952 };
10953
10954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10956 if (!SWIG_IsOK(res1)) {
10957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10958 }
10959 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10960 ecode2 = SWIG_AsVal_int(obj1, &val2);
10961 if (!SWIG_IsOK(ecode2)) {
10962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10963 }
10964 arg2 = static_cast< wxPortId >(val2);
10965 {
10966 PyThreadState* __tstate = wxPyBeginAllowThreads();
10967 (arg1)->SetPortId(arg2);
10968 wxPyEndAllowThreads(__tstate);
10969 if (PyErr_Occurred()) SWIG_fail;
10970 }
10971 resultobj = SWIG_Py_Void();
10972 return resultobj;
10973 fail:
10974 return NULL;
10975 }
10976
10977
10978 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10979 PyObject *resultobj = 0;
10980 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10981 wxArchitecture arg2 ;
10982 void *argp1 = 0 ;
10983 int res1 = 0 ;
10984 int val2 ;
10985 int ecode2 = 0 ;
10986 PyObject * obj0 = 0 ;
10987 PyObject * obj1 = 0 ;
10988 char * kwnames[] = {
10989 (char *) "self",(char *) "n", NULL
10990 };
10991
10992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
10993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10994 if (!SWIG_IsOK(res1)) {
10995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10996 }
10997 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10998 ecode2 = SWIG_AsVal_int(obj1, &val2);
10999 if (!SWIG_IsOK(ecode2)) {
11000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
11001 }
11002 arg2 = static_cast< wxArchitecture >(val2);
11003 {
11004 PyThreadState* __tstate = wxPyBeginAllowThreads();
11005 (arg1)->SetArchitecture(arg2);
11006 wxPyEndAllowThreads(__tstate);
11007 if (PyErr_Occurred()) SWIG_fail;
11008 }
11009 resultobj = SWIG_Py_Void();
11010 return resultobj;
11011 fail:
11012 return NULL;
11013 }
11014
11015
11016 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11017 PyObject *resultobj = 0;
11018 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11019 wxEndianness arg2 ;
11020 void *argp1 = 0 ;
11021 int res1 = 0 ;
11022 int val2 ;
11023 int ecode2 = 0 ;
11024 PyObject * obj0 = 0 ;
11025 PyObject * obj1 = 0 ;
11026 char * kwnames[] = {
11027 (char *) "self",(char *) "n", NULL
11028 };
11029
11030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
11031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11032 if (!SWIG_IsOK(res1)) {
11033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11034 }
11035 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11036 ecode2 = SWIG_AsVal_int(obj1, &val2);
11037 if (!SWIG_IsOK(ecode2)) {
11038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11039 }
11040 arg2 = static_cast< wxEndianness >(val2);
11041 {
11042 PyThreadState* __tstate = wxPyBeginAllowThreads();
11043 (arg1)->SetEndianness(arg2);
11044 wxPyEndAllowThreads(__tstate);
11045 if (PyErr_Occurred()) SWIG_fail;
11046 }
11047 resultobj = SWIG_Py_Void();
11048 return resultobj;
11049 fail:
11050 return NULL;
11051 }
11052
11053
11054 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11055 PyObject *resultobj = 0;
11056 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11057 bool result;
11058 void *argp1 = 0 ;
11059 int res1 = 0 ;
11060 PyObject *swig_obj[1] ;
11061
11062 if (!args) SWIG_fail;
11063 swig_obj[0] = args;
11064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11065 if (!SWIG_IsOK(res1)) {
11066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11067 }
11068 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11069 {
11070 PyThreadState* __tstate = wxPyBeginAllowThreads();
11071 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11072 wxPyEndAllowThreads(__tstate);
11073 if (PyErr_Occurred()) SWIG_fail;
11074 }
11075 {
11076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11077 }
11078 return resultobj;
11079 fail:
11080 return NULL;
11081 }
11082
11083
11084 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11085 PyObject *obj;
11086 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11087 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11088 return SWIG_Py_Void();
11089 }
11090
11091 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11092 return SWIG_Python_InitShadowInstance(args);
11093 }
11094
11095 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11096 PyObject *resultobj = 0;
11097 wxWindow *arg1 = (wxWindow *) 0 ;
11098 wxDC *arg2 = 0 ;
11099 bool result;
11100 void *argp1 = 0 ;
11101 int res1 = 0 ;
11102 void *argp2 = 0 ;
11103 int res2 = 0 ;
11104 PyObject * obj0 = 0 ;
11105 PyObject * obj1 = 0 ;
11106 char * kwnames[] = {
11107 (char *) "window",(char *) "dc", NULL
11108 };
11109
11110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11112 if (!SWIG_IsOK(res1)) {
11113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11114 }
11115 arg1 = reinterpret_cast< wxWindow * >(argp1);
11116 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11117 if (!SWIG_IsOK(res2)) {
11118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11119 }
11120 if (!argp2) {
11121 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11122 }
11123 arg2 = reinterpret_cast< wxDC * >(argp2);
11124 {
11125 PyThreadState* __tstate = wxPyBeginAllowThreads();
11126 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11127 wxPyEndAllowThreads(__tstate);
11128 if (PyErr_Occurred()) SWIG_fail;
11129 }
11130 {
11131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11132 }
11133 return resultobj;
11134 fail:
11135 return NULL;
11136 }
11137
11138
11139 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11140 PyObject *resultobj = 0;
11141 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11142 void *argp1 = 0 ;
11143 int res1 = 0 ;
11144 PyObject *swig_obj[1] ;
11145
11146 if (!args) SWIG_fail;
11147 swig_obj[0] = args;
11148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11149 if (!SWIG_IsOK(res1)) {
11150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11151 }
11152 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11153 {
11154 PyThreadState* __tstate = wxPyBeginAllowThreads();
11155 delete arg1;
11156
11157 wxPyEndAllowThreads(__tstate);
11158 if (PyErr_Occurred()) SWIG_fail;
11159 }
11160 resultobj = SWIG_Py_Void();
11161 return resultobj;
11162 fail:
11163 return NULL;
11164 }
11165
11166
11167 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11168 PyObject *resultobj = 0;
11169 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11170 wxString result;
11171 void *argp1 = 0 ;
11172 int res1 = 0 ;
11173 PyObject *swig_obj[1] ;
11174
11175 if (!args) SWIG_fail;
11176 swig_obj[0] = args;
11177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11178 if (!SWIG_IsOK(res1)) {
11179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11180 }
11181 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11182 {
11183 PyThreadState* __tstate = wxPyBeginAllowThreads();
11184 result = (arg1)->GetTip();
11185 wxPyEndAllowThreads(__tstate);
11186 if (PyErr_Occurred()) SWIG_fail;
11187 }
11188 {
11189 #if wxUSE_UNICODE
11190 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11191 #else
11192 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11193 #endif
11194 }
11195 return resultobj;
11196 fail:
11197 return NULL;
11198 }
11199
11200
11201 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11202 PyObject *resultobj = 0;
11203 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11204 size_t result;
11205 void *argp1 = 0 ;
11206 int res1 = 0 ;
11207 PyObject *swig_obj[1] ;
11208
11209 if (!args) SWIG_fail;
11210 swig_obj[0] = args;
11211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11212 if (!SWIG_IsOK(res1)) {
11213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11214 }
11215 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11216 {
11217 PyThreadState* __tstate = wxPyBeginAllowThreads();
11218 result = (size_t)(arg1)->GetCurrentTip();
11219 wxPyEndAllowThreads(__tstate);
11220 if (PyErr_Occurred()) SWIG_fail;
11221 }
11222 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11223 return resultobj;
11224 fail:
11225 return NULL;
11226 }
11227
11228
11229 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11230 PyObject *resultobj = 0;
11231 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11232 wxString *arg2 = 0 ;
11233 wxString result;
11234 void *argp1 = 0 ;
11235 int res1 = 0 ;
11236 bool temp2 = false ;
11237 PyObject * obj0 = 0 ;
11238 PyObject * obj1 = 0 ;
11239 char * kwnames[] = {
11240 (char *) "self",(char *) "tip", NULL
11241 };
11242
11243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11245 if (!SWIG_IsOK(res1)) {
11246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11247 }
11248 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11249 {
11250 arg2 = wxString_in_helper(obj1);
11251 if (arg2 == NULL) SWIG_fail;
11252 temp2 = true;
11253 }
11254 {
11255 PyThreadState* __tstate = wxPyBeginAllowThreads();
11256 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11257 wxPyEndAllowThreads(__tstate);
11258 if (PyErr_Occurred()) SWIG_fail;
11259 }
11260 {
11261 #if wxUSE_UNICODE
11262 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11263 #else
11264 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11265 #endif
11266 }
11267 {
11268 if (temp2)
11269 delete arg2;
11270 }
11271 return resultobj;
11272 fail:
11273 {
11274 if (temp2)
11275 delete arg2;
11276 }
11277 return NULL;
11278 }
11279
11280
11281 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11282 PyObject *obj;
11283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11284 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11285 return SWIG_Py_Void();
11286 }
11287
11288 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11289 PyObject *resultobj = 0;
11290 size_t arg1 ;
11291 wxPyTipProvider *result = 0 ;
11292 size_t val1 ;
11293 int ecode1 = 0 ;
11294 PyObject * obj0 = 0 ;
11295 char * kwnames[] = {
11296 (char *) "currentTip", NULL
11297 };
11298
11299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11300 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11301 if (!SWIG_IsOK(ecode1)) {
11302 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11303 }
11304 arg1 = static_cast< size_t >(val1);
11305 {
11306 PyThreadState* __tstate = wxPyBeginAllowThreads();
11307 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11308 wxPyEndAllowThreads(__tstate);
11309 if (PyErr_Occurred()) SWIG_fail;
11310 }
11311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11312 return resultobj;
11313 fail:
11314 return NULL;
11315 }
11316
11317
11318 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11319 PyObject *resultobj = 0;
11320 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11321 PyObject *arg2 = (PyObject *) 0 ;
11322 PyObject *arg3 = (PyObject *) 0 ;
11323 void *argp1 = 0 ;
11324 int res1 = 0 ;
11325 PyObject * obj0 = 0 ;
11326 PyObject * obj1 = 0 ;
11327 PyObject * obj2 = 0 ;
11328 char * kwnames[] = {
11329 (char *) "self",(char *) "self",(char *) "_class", NULL
11330 };
11331
11332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11334 if (!SWIG_IsOK(res1)) {
11335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11336 }
11337 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11338 arg2 = obj1;
11339 arg3 = obj2;
11340 {
11341 PyThreadState* __tstate = wxPyBeginAllowThreads();
11342 (arg1)->_setCallbackInfo(arg2,arg3);
11343 wxPyEndAllowThreads(__tstate);
11344 if (PyErr_Occurred()) SWIG_fail;
11345 }
11346 resultobj = SWIG_Py_Void();
11347 return resultobj;
11348 fail:
11349 return NULL;
11350 }
11351
11352
11353 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11354 PyObject *obj;
11355 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11356 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11357 return SWIG_Py_Void();
11358 }
11359
11360 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11361 return SWIG_Python_InitShadowInstance(args);
11362 }
11363
11364 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11365 PyObject *resultobj = 0;
11366 wxWindow *arg1 = (wxWindow *) 0 ;
11367 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11368 bool arg3 = (bool) true ;
11369 bool result;
11370 void *argp1 = 0 ;
11371 int res1 = 0 ;
11372 void *argp2 = 0 ;
11373 int res2 = 0 ;
11374 bool val3 ;
11375 int ecode3 = 0 ;
11376 PyObject * obj0 = 0 ;
11377 PyObject * obj1 = 0 ;
11378 PyObject * obj2 = 0 ;
11379 char * kwnames[] = {
11380 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11381 };
11382
11383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11385 if (!SWIG_IsOK(res1)) {
11386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11387 }
11388 arg1 = reinterpret_cast< wxWindow * >(argp1);
11389 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11390 if (!SWIG_IsOK(res2)) {
11391 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11392 }
11393 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11394 if (obj2) {
11395 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11396 if (!SWIG_IsOK(ecode3)) {
11397 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11398 }
11399 arg3 = static_cast< bool >(val3);
11400 }
11401 {
11402 if (!wxPyCheckForApp()) SWIG_fail;
11403 PyThreadState* __tstate = wxPyBeginAllowThreads();
11404 result = (bool)wxShowTip(arg1,arg2,arg3);
11405 wxPyEndAllowThreads(__tstate);
11406 if (PyErr_Occurred()) SWIG_fail;
11407 }
11408 {
11409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11410 }
11411 return resultobj;
11412 fail:
11413 return NULL;
11414 }
11415
11416
11417 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11418 PyObject *resultobj = 0;
11419 wxString *arg1 = 0 ;
11420 size_t arg2 ;
11421 wxTipProvider *result = 0 ;
11422 bool temp1 = false ;
11423 size_t val2 ;
11424 int ecode2 = 0 ;
11425 PyObject * obj0 = 0 ;
11426 PyObject * obj1 = 0 ;
11427 char * kwnames[] = {
11428 (char *) "filename",(char *) "currentTip", NULL
11429 };
11430
11431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11432 {
11433 arg1 = wxString_in_helper(obj0);
11434 if (arg1 == NULL) SWIG_fail;
11435 temp1 = true;
11436 }
11437 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11438 if (!SWIG_IsOK(ecode2)) {
11439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11440 }
11441 arg2 = static_cast< size_t >(val2);
11442 {
11443 if (!wxPyCheckForApp()) SWIG_fail;
11444 PyThreadState* __tstate = wxPyBeginAllowThreads();
11445 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11446 wxPyEndAllowThreads(__tstate);
11447 if (PyErr_Occurred()) SWIG_fail;
11448 }
11449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11450 {
11451 if (temp1)
11452 delete arg1;
11453 }
11454 return resultobj;
11455 fail:
11456 {
11457 if (temp1)
11458 delete arg1;
11459 }
11460 return NULL;
11461 }
11462
11463
11464 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11465 PyObject *resultobj = 0;
11466 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11467 int arg2 = (int) wxID_ANY ;
11468 wxPyTimer *result = 0 ;
11469 void *argp1 = 0 ;
11470 int res1 = 0 ;
11471 int val2 ;
11472 int ecode2 = 0 ;
11473 PyObject * obj0 = 0 ;
11474 PyObject * obj1 = 0 ;
11475 char * kwnames[] = {
11476 (char *) "owner",(char *) "id", NULL
11477 };
11478
11479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11480 if (obj0) {
11481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11482 if (!SWIG_IsOK(res1)) {
11483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11484 }
11485 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11486 }
11487 if (obj1) {
11488 ecode2 = SWIG_AsVal_int(obj1, &val2);
11489 if (!SWIG_IsOK(ecode2)) {
11490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11491 }
11492 arg2 = static_cast< int >(val2);
11493 }
11494 {
11495 if (!wxPyCheckForApp()) SWIG_fail;
11496 PyThreadState* __tstate = wxPyBeginAllowThreads();
11497 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11498 wxPyEndAllowThreads(__tstate);
11499 if (PyErr_Occurred()) SWIG_fail;
11500 }
11501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11502 return resultobj;
11503 fail:
11504 return NULL;
11505 }
11506
11507
11508 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11509 PyObject *resultobj = 0;
11510 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11511 void *argp1 = 0 ;
11512 int res1 = 0 ;
11513 PyObject *swig_obj[1] ;
11514
11515 if (!args) SWIG_fail;
11516 swig_obj[0] = args;
11517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11518 if (!SWIG_IsOK(res1)) {
11519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11520 }
11521 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11522 {
11523 PyThreadState* __tstate = wxPyBeginAllowThreads();
11524 delete arg1;
11525
11526 wxPyEndAllowThreads(__tstate);
11527 if (PyErr_Occurred()) SWIG_fail;
11528 }
11529 resultobj = SWIG_Py_Void();
11530 return resultobj;
11531 fail:
11532 return NULL;
11533 }
11534
11535
11536 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11537 PyObject *resultobj = 0;
11538 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11539 PyObject *arg2 = (PyObject *) 0 ;
11540 PyObject *arg3 = (PyObject *) 0 ;
11541 int arg4 = (int) 1 ;
11542 void *argp1 = 0 ;
11543 int res1 = 0 ;
11544 int val4 ;
11545 int ecode4 = 0 ;
11546 PyObject * obj0 = 0 ;
11547 PyObject * obj1 = 0 ;
11548 PyObject * obj2 = 0 ;
11549 PyObject * obj3 = 0 ;
11550 char * kwnames[] = {
11551 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11552 };
11553
11554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11556 if (!SWIG_IsOK(res1)) {
11557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11558 }
11559 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11560 arg2 = obj1;
11561 arg3 = obj2;
11562 if (obj3) {
11563 ecode4 = SWIG_AsVal_int(obj3, &val4);
11564 if (!SWIG_IsOK(ecode4)) {
11565 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11566 }
11567 arg4 = static_cast< int >(val4);
11568 }
11569 {
11570 PyThreadState* __tstate = wxPyBeginAllowThreads();
11571 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11572 wxPyEndAllowThreads(__tstate);
11573 if (PyErr_Occurred()) SWIG_fail;
11574 }
11575 resultobj = SWIG_Py_Void();
11576 return resultobj;
11577 fail:
11578 return NULL;
11579 }
11580
11581
11582 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11583 PyObject *resultobj = 0;
11584 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11585 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11586 int arg3 = (int) wxID_ANY ;
11587 void *argp1 = 0 ;
11588 int res1 = 0 ;
11589 void *argp2 = 0 ;
11590 int res2 = 0 ;
11591 int val3 ;
11592 int ecode3 = 0 ;
11593 PyObject * obj0 = 0 ;
11594 PyObject * obj1 = 0 ;
11595 PyObject * obj2 = 0 ;
11596 char * kwnames[] = {
11597 (char *) "self",(char *) "owner",(char *) "id", NULL
11598 };
11599
11600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11602 if (!SWIG_IsOK(res1)) {
11603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11604 }
11605 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11606 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11607 if (!SWIG_IsOK(res2)) {
11608 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11609 }
11610 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11611 if (obj2) {
11612 ecode3 = SWIG_AsVal_int(obj2, &val3);
11613 if (!SWIG_IsOK(ecode3)) {
11614 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11615 }
11616 arg3 = static_cast< int >(val3);
11617 }
11618 {
11619 PyThreadState* __tstate = wxPyBeginAllowThreads();
11620 (arg1)->SetOwner(arg2,arg3);
11621 wxPyEndAllowThreads(__tstate);
11622 if (PyErr_Occurred()) SWIG_fail;
11623 }
11624 resultobj = SWIG_Py_Void();
11625 return resultobj;
11626 fail:
11627 return NULL;
11628 }
11629
11630
11631 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11632 PyObject *resultobj = 0;
11633 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11634 wxEvtHandler *result = 0 ;
11635 void *argp1 = 0 ;
11636 int res1 = 0 ;
11637 PyObject *swig_obj[1] ;
11638
11639 if (!args) SWIG_fail;
11640 swig_obj[0] = args;
11641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11642 if (!SWIG_IsOK(res1)) {
11643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11644 }
11645 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11646 {
11647 PyThreadState* __tstate = wxPyBeginAllowThreads();
11648 result = (wxEvtHandler *)(arg1)->GetOwner();
11649 wxPyEndAllowThreads(__tstate);
11650 if (PyErr_Occurred()) SWIG_fail;
11651 }
11652 {
11653 resultobj = wxPyMake_wxObject(result, 0);
11654 }
11655 return resultobj;
11656 fail:
11657 return NULL;
11658 }
11659
11660
11661 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11662 PyObject *resultobj = 0;
11663 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11664 int arg2 = (int) -1 ;
11665 bool arg3 = (bool) false ;
11666 bool result;
11667 void *argp1 = 0 ;
11668 int res1 = 0 ;
11669 int val2 ;
11670 int ecode2 = 0 ;
11671 bool val3 ;
11672 int ecode3 = 0 ;
11673 PyObject * obj0 = 0 ;
11674 PyObject * obj1 = 0 ;
11675 PyObject * obj2 = 0 ;
11676 char * kwnames[] = {
11677 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11678 };
11679
11680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11682 if (!SWIG_IsOK(res1)) {
11683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11684 }
11685 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11686 if (obj1) {
11687 ecode2 = SWIG_AsVal_int(obj1, &val2);
11688 if (!SWIG_IsOK(ecode2)) {
11689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11690 }
11691 arg2 = static_cast< int >(val2);
11692 }
11693 if (obj2) {
11694 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11695 if (!SWIG_IsOK(ecode3)) {
11696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11697 }
11698 arg3 = static_cast< bool >(val3);
11699 }
11700 {
11701 PyThreadState* __tstate = wxPyBeginAllowThreads();
11702 result = (bool)(arg1)->Start(arg2,arg3);
11703 wxPyEndAllowThreads(__tstate);
11704 if (PyErr_Occurred()) SWIG_fail;
11705 }
11706 {
11707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11708 }
11709 return resultobj;
11710 fail:
11711 return NULL;
11712 }
11713
11714
11715 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11716 PyObject *resultobj = 0;
11717 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11718 void *argp1 = 0 ;
11719 int res1 = 0 ;
11720 PyObject *swig_obj[1] ;
11721
11722 if (!args) SWIG_fail;
11723 swig_obj[0] = args;
11724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11725 if (!SWIG_IsOK(res1)) {
11726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11727 }
11728 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11729 {
11730 PyThreadState* __tstate = wxPyBeginAllowThreads();
11731 (arg1)->Stop();
11732 wxPyEndAllowThreads(__tstate);
11733 if (PyErr_Occurred()) SWIG_fail;
11734 }
11735 resultobj = SWIG_Py_Void();
11736 return resultobj;
11737 fail:
11738 return NULL;
11739 }
11740
11741
11742 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11743 PyObject *resultobj = 0;
11744 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11745 void *argp1 = 0 ;
11746 int res1 = 0 ;
11747 PyObject *swig_obj[1] ;
11748
11749 if (!args) SWIG_fail;
11750 swig_obj[0] = args;
11751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11752 if (!SWIG_IsOK(res1)) {
11753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11754 }
11755 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11756 {
11757 PyThreadState* __tstate = wxPyBeginAllowThreads();
11758 (arg1)->Notify();
11759 wxPyEndAllowThreads(__tstate);
11760 if (PyErr_Occurred()) SWIG_fail;
11761 }
11762 resultobj = SWIG_Py_Void();
11763 return resultobj;
11764 fail:
11765 return NULL;
11766 }
11767
11768
11769 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11770 PyObject *resultobj = 0;
11771 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11772 bool result;
11773 void *argp1 = 0 ;
11774 int res1 = 0 ;
11775 PyObject *swig_obj[1] ;
11776
11777 if (!args) SWIG_fail;
11778 swig_obj[0] = args;
11779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11780 if (!SWIG_IsOK(res1)) {
11781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11782 }
11783 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11784 {
11785 PyThreadState* __tstate = wxPyBeginAllowThreads();
11786 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11787 wxPyEndAllowThreads(__tstate);
11788 if (PyErr_Occurred()) SWIG_fail;
11789 }
11790 {
11791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11792 }
11793 return resultobj;
11794 fail:
11795 return NULL;
11796 }
11797
11798
11799 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11800 PyObject *resultobj = 0;
11801 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11802 int result;
11803 void *argp1 = 0 ;
11804 int res1 = 0 ;
11805 PyObject *swig_obj[1] ;
11806
11807 if (!args) SWIG_fail;
11808 swig_obj[0] = args;
11809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11810 if (!SWIG_IsOK(res1)) {
11811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11812 }
11813 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11814 {
11815 PyThreadState* __tstate = wxPyBeginAllowThreads();
11816 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11817 wxPyEndAllowThreads(__tstate);
11818 if (PyErr_Occurred()) SWIG_fail;
11819 }
11820 resultobj = SWIG_From_int(static_cast< int >(result));
11821 return resultobj;
11822 fail:
11823 return NULL;
11824 }
11825
11826
11827 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11828 PyObject *resultobj = 0;
11829 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11830 int result;
11831 void *argp1 = 0 ;
11832 int res1 = 0 ;
11833 PyObject *swig_obj[1] ;
11834
11835 if (!args) SWIG_fail;
11836 swig_obj[0] = args;
11837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11838 if (!SWIG_IsOK(res1)) {
11839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11840 }
11841 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11842 {
11843 PyThreadState* __tstate = wxPyBeginAllowThreads();
11844 result = (int)((wxPyTimer const *)arg1)->GetId();
11845 wxPyEndAllowThreads(__tstate);
11846 if (PyErr_Occurred()) SWIG_fail;
11847 }
11848 resultobj = SWIG_From_int(static_cast< int >(result));
11849 return resultobj;
11850 fail:
11851 return NULL;
11852 }
11853
11854
11855 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11856 PyObject *resultobj = 0;
11857 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11858 bool result;
11859 void *argp1 = 0 ;
11860 int res1 = 0 ;
11861 PyObject *swig_obj[1] ;
11862
11863 if (!args) SWIG_fail;
11864 swig_obj[0] = args;
11865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11866 if (!SWIG_IsOK(res1)) {
11867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11868 }
11869 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11870 {
11871 PyThreadState* __tstate = wxPyBeginAllowThreads();
11872 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11873 wxPyEndAllowThreads(__tstate);
11874 if (PyErr_Occurred()) SWIG_fail;
11875 }
11876 {
11877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11878 }
11879 return resultobj;
11880 fail:
11881 return NULL;
11882 }
11883
11884
11885 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11886 PyObject *obj;
11887 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11888 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11889 return SWIG_Py_Void();
11890 }
11891
11892 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11893 return SWIG_Python_InitShadowInstance(args);
11894 }
11895
11896 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11897 PyObject *resultobj = 0;
11898 int arg1 = (int) 0 ;
11899 int arg2 = (int) 0 ;
11900 wxTimerEvent *result = 0 ;
11901 int val1 ;
11902 int ecode1 = 0 ;
11903 int val2 ;
11904 int ecode2 = 0 ;
11905 PyObject * obj0 = 0 ;
11906 PyObject * obj1 = 0 ;
11907 char * kwnames[] = {
11908 (char *) "timerid",(char *) "interval", NULL
11909 };
11910
11911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11912 if (obj0) {
11913 ecode1 = SWIG_AsVal_int(obj0, &val1);
11914 if (!SWIG_IsOK(ecode1)) {
11915 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11916 }
11917 arg1 = static_cast< int >(val1);
11918 }
11919 if (obj1) {
11920 ecode2 = SWIG_AsVal_int(obj1, &val2);
11921 if (!SWIG_IsOK(ecode2)) {
11922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11923 }
11924 arg2 = static_cast< int >(val2);
11925 }
11926 {
11927 PyThreadState* __tstate = wxPyBeginAllowThreads();
11928 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11929 wxPyEndAllowThreads(__tstate);
11930 if (PyErr_Occurred()) SWIG_fail;
11931 }
11932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11933 return resultobj;
11934 fail:
11935 return NULL;
11936 }
11937
11938
11939 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11940 PyObject *resultobj = 0;
11941 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11942 int result;
11943 void *argp1 = 0 ;
11944 int res1 = 0 ;
11945 PyObject *swig_obj[1] ;
11946
11947 if (!args) SWIG_fail;
11948 swig_obj[0] = args;
11949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11950 if (!SWIG_IsOK(res1)) {
11951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11952 }
11953 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11954 {
11955 PyThreadState* __tstate = wxPyBeginAllowThreads();
11956 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11957 wxPyEndAllowThreads(__tstate);
11958 if (PyErr_Occurred()) SWIG_fail;
11959 }
11960 resultobj = SWIG_From_int(static_cast< int >(result));
11961 return resultobj;
11962 fail:
11963 return NULL;
11964 }
11965
11966
11967 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11968 PyObject *obj;
11969 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11970 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11971 return SWIG_Py_Void();
11972 }
11973
11974 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11975 return SWIG_Python_InitShadowInstance(args);
11976 }
11977
11978 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11979 PyObject *resultobj = 0;
11980 wxTimer *arg1 = 0 ;
11981 wxTimerRunner *result = 0 ;
11982 void *argp1 = 0 ;
11983 int res1 = 0 ;
11984
11985 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11987 if (!SWIG_IsOK(res1)) {
11988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11989 }
11990 if (!argp1) {
11991 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11992 }
11993 arg1 = reinterpret_cast< wxTimer * >(argp1);
11994 {
11995 if (!wxPyCheckForApp()) SWIG_fail;
11996 PyThreadState* __tstate = wxPyBeginAllowThreads();
11997 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
11998 wxPyEndAllowThreads(__tstate);
11999 if (PyErr_Occurred()) SWIG_fail;
12000 }
12001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12002 return resultobj;
12003 fail:
12004 return NULL;
12005 }
12006
12007
12008 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12009 PyObject *resultobj = 0;
12010 wxTimer *arg1 = 0 ;
12011 int arg2 ;
12012 bool arg3 = (bool) false ;
12013 wxTimerRunner *result = 0 ;
12014 void *argp1 = 0 ;
12015 int res1 = 0 ;
12016 int val2 ;
12017 int ecode2 = 0 ;
12018 bool val3 ;
12019 int ecode3 = 0 ;
12020
12021 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
12022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
12023 if (!SWIG_IsOK(res1)) {
12024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12025 }
12026 if (!argp1) {
12027 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12028 }
12029 arg1 = reinterpret_cast< wxTimer * >(argp1);
12030 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12031 if (!SWIG_IsOK(ecode2)) {
12032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
12033 }
12034 arg2 = static_cast< int >(val2);
12035 if (swig_obj[2]) {
12036 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12037 if (!SWIG_IsOK(ecode3)) {
12038 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12039 }
12040 arg3 = static_cast< bool >(val3);
12041 }
12042 {
12043 if (!wxPyCheckForApp()) SWIG_fail;
12044 PyThreadState* __tstate = wxPyBeginAllowThreads();
12045 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12046 wxPyEndAllowThreads(__tstate);
12047 if (PyErr_Occurred()) SWIG_fail;
12048 }
12049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12050 return resultobj;
12051 fail:
12052 return NULL;
12053 }
12054
12055
12056 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12057 int argc;
12058 PyObject *argv[4];
12059
12060 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12061 --argc;
12062 if (argc == 1) {
12063 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12064 }
12065 if ((argc >= 2) && (argc <= 3)) {
12066 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12067 }
12068
12069 fail:
12070 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12071 return NULL;
12072 }
12073
12074
12075 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12076 PyObject *resultobj = 0;
12077 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12078 void *argp1 = 0 ;
12079 int res1 = 0 ;
12080 PyObject *swig_obj[1] ;
12081
12082 if (!args) SWIG_fail;
12083 swig_obj[0] = args;
12084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12085 if (!SWIG_IsOK(res1)) {
12086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12087 }
12088 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12089 {
12090 PyThreadState* __tstate = wxPyBeginAllowThreads();
12091 delete arg1;
12092
12093 wxPyEndAllowThreads(__tstate);
12094 if (PyErr_Occurred()) SWIG_fail;
12095 }
12096 resultobj = SWIG_Py_Void();
12097 return resultobj;
12098 fail:
12099 return NULL;
12100 }
12101
12102
12103 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12104 PyObject *resultobj = 0;
12105 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12106 int arg2 ;
12107 bool arg3 = (bool) false ;
12108 void *argp1 = 0 ;
12109 int res1 = 0 ;
12110 int val2 ;
12111 int ecode2 = 0 ;
12112 bool val3 ;
12113 int ecode3 = 0 ;
12114 PyObject * obj0 = 0 ;
12115 PyObject * obj1 = 0 ;
12116 PyObject * obj2 = 0 ;
12117 char * kwnames[] = {
12118 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12119 };
12120
12121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12123 if (!SWIG_IsOK(res1)) {
12124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12125 }
12126 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12127 ecode2 = SWIG_AsVal_int(obj1, &val2);
12128 if (!SWIG_IsOK(ecode2)) {
12129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12130 }
12131 arg2 = static_cast< int >(val2);
12132 if (obj2) {
12133 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12134 if (!SWIG_IsOK(ecode3)) {
12135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12136 }
12137 arg3 = static_cast< bool >(val3);
12138 }
12139 {
12140 PyThreadState* __tstate = wxPyBeginAllowThreads();
12141 (arg1)->Start(arg2,arg3);
12142 wxPyEndAllowThreads(__tstate);
12143 if (PyErr_Occurred()) SWIG_fail;
12144 }
12145 resultobj = SWIG_Py_Void();
12146 return resultobj;
12147 fail:
12148 return NULL;
12149 }
12150
12151
12152 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12153 PyObject *obj;
12154 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12155 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12156 return SWIG_Py_Void();
12157 }
12158
12159 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12160 return SWIG_Python_InitShadowInstance(args);
12161 }
12162
12163 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12164 PyObject *resultobj = 0;
12165 wxLog *result = 0 ;
12166
12167 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12168 {
12169 PyThreadState* __tstate = wxPyBeginAllowThreads();
12170 result = (wxLog *)new wxLog();
12171 wxPyEndAllowThreads(__tstate);
12172 if (PyErr_Occurred()) SWIG_fail;
12173 }
12174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12175 return resultobj;
12176 fail:
12177 return NULL;
12178 }
12179
12180
12181 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12182 PyObject *resultobj = 0;
12183 wxLog *arg1 = (wxLog *) 0 ;
12184 void *argp1 = 0 ;
12185 int res1 = 0 ;
12186 PyObject *swig_obj[1] ;
12187
12188 if (!args) SWIG_fail;
12189 swig_obj[0] = args;
12190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12191 if (!SWIG_IsOK(res1)) {
12192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12193 }
12194 arg1 = reinterpret_cast< wxLog * >(argp1);
12195 {
12196 PyThreadState* __tstate = wxPyBeginAllowThreads();
12197 delete arg1;
12198
12199 wxPyEndAllowThreads(__tstate);
12200 if (PyErr_Occurred()) SWIG_fail;
12201 }
12202 resultobj = SWIG_Py_Void();
12203 return resultobj;
12204 fail:
12205 return NULL;
12206 }
12207
12208
12209 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12210 PyObject *resultobj = 0;
12211 bool result;
12212
12213 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12214 {
12215 PyThreadState* __tstate = wxPyBeginAllowThreads();
12216 result = (bool)wxLog::IsEnabled();
12217 wxPyEndAllowThreads(__tstate);
12218 if (PyErr_Occurred()) SWIG_fail;
12219 }
12220 {
12221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12222 }
12223 return resultobj;
12224 fail:
12225 return NULL;
12226 }
12227
12228
12229 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12230 PyObject *resultobj = 0;
12231 bool arg1 = (bool) true ;
12232 bool result;
12233 bool val1 ;
12234 int ecode1 = 0 ;
12235 PyObject * obj0 = 0 ;
12236 char * kwnames[] = {
12237 (char *) "doIt", NULL
12238 };
12239
12240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12241 if (obj0) {
12242 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12243 if (!SWIG_IsOK(ecode1)) {
12244 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12245 }
12246 arg1 = static_cast< bool >(val1);
12247 }
12248 {
12249 PyThreadState* __tstate = wxPyBeginAllowThreads();
12250 result = (bool)wxLog::EnableLogging(arg1);
12251 wxPyEndAllowThreads(__tstate);
12252 if (PyErr_Occurred()) SWIG_fail;
12253 }
12254 {
12255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12256 }
12257 return resultobj;
12258 fail:
12259 return NULL;
12260 }
12261
12262
12263 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12264 PyObject *resultobj = 0;
12265 wxLogLevel arg1 ;
12266 wxChar *arg2 = (wxChar *) 0 ;
12267 time_t arg3 ;
12268 unsigned long val1 ;
12269 int ecode1 = 0 ;
12270 void *argp2 = 0 ;
12271 int res2 = 0 ;
12272 unsigned int val3 ;
12273 int ecode3 = 0 ;
12274 PyObject * obj0 = 0 ;
12275 PyObject * obj1 = 0 ;
12276 PyObject * obj2 = 0 ;
12277 char * kwnames[] = {
12278 (char *) "level",(char *) "szString",(char *) "t", NULL
12279 };
12280
12281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12282 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12283 if (!SWIG_IsOK(ecode1)) {
12284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12285 }
12286 arg1 = static_cast< wxLogLevel >(val1);
12287 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12288 if (!SWIG_IsOK(res2)) {
12289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12290 }
12291 arg2 = reinterpret_cast< wxChar * >(argp2);
12292 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12293 if (!SWIG_IsOK(ecode3)) {
12294 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12295 }
12296 arg3 = static_cast< time_t >(val3);
12297 {
12298 PyThreadState* __tstate = wxPyBeginAllowThreads();
12299 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12300 wxPyEndAllowThreads(__tstate);
12301 if (PyErr_Occurred()) SWIG_fail;
12302 }
12303 resultobj = SWIG_Py_Void();
12304 return resultobj;
12305 fail:
12306 return NULL;
12307 }
12308
12309
12310 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12311 PyObject *resultobj = 0;
12312 wxLog *arg1 = (wxLog *) 0 ;
12313 void *argp1 = 0 ;
12314 int res1 = 0 ;
12315 PyObject *swig_obj[1] ;
12316
12317 if (!args) SWIG_fail;
12318 swig_obj[0] = args;
12319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12320 if (!SWIG_IsOK(res1)) {
12321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12322 }
12323 arg1 = reinterpret_cast< wxLog * >(argp1);
12324 {
12325 PyThreadState* __tstate = wxPyBeginAllowThreads();
12326 (arg1)->Flush();
12327 wxPyEndAllowThreads(__tstate);
12328 if (PyErr_Occurred()) SWIG_fail;
12329 }
12330 resultobj = SWIG_Py_Void();
12331 return resultobj;
12332 fail:
12333 return NULL;
12334 }
12335
12336
12337 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12338 PyObject *resultobj = 0;
12339
12340 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12341 {
12342 PyThreadState* __tstate = wxPyBeginAllowThreads();
12343 wxLog::FlushActive();
12344 wxPyEndAllowThreads(__tstate);
12345 if (PyErr_Occurred()) SWIG_fail;
12346 }
12347 resultobj = SWIG_Py_Void();
12348 return resultobj;
12349 fail:
12350 return NULL;
12351 }
12352
12353
12354 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12355 PyObject *resultobj = 0;
12356 wxLog *result = 0 ;
12357
12358 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12359 {
12360 PyThreadState* __tstate = wxPyBeginAllowThreads();
12361 result = (wxLog *)wxLog::GetActiveTarget();
12362 wxPyEndAllowThreads(__tstate);
12363 if (PyErr_Occurred()) SWIG_fail;
12364 }
12365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12366 return resultobj;
12367 fail:
12368 return NULL;
12369 }
12370
12371
12372 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12373 PyObject *resultobj = 0;
12374 wxLog *arg1 = (wxLog *) 0 ;
12375 wxLog *result = 0 ;
12376 int res1 = 0 ;
12377 PyObject * obj0 = 0 ;
12378 char * kwnames[] = {
12379 (char *) "pLogger", NULL
12380 };
12381
12382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12383 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12384 if (!SWIG_IsOK(res1)) {
12385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12386 }
12387 {
12388 PyThreadState* __tstate = wxPyBeginAllowThreads();
12389 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12390 wxPyEndAllowThreads(__tstate);
12391 if (PyErr_Occurred()) SWIG_fail;
12392 }
12393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12394 return resultobj;
12395 fail:
12396 return NULL;
12397 }
12398
12399
12400 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12401 PyObject *resultobj = 0;
12402
12403 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12404 {
12405 PyThreadState* __tstate = wxPyBeginAllowThreads();
12406 wxLog::Suspend();
12407 wxPyEndAllowThreads(__tstate);
12408 if (PyErr_Occurred()) SWIG_fail;
12409 }
12410 resultobj = SWIG_Py_Void();
12411 return resultobj;
12412 fail:
12413 return NULL;
12414 }
12415
12416
12417 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12418 PyObject *resultobj = 0;
12419
12420 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12421 {
12422 PyThreadState* __tstate = wxPyBeginAllowThreads();
12423 wxLog::Resume();
12424 wxPyEndAllowThreads(__tstate);
12425 if (PyErr_Occurred()) SWIG_fail;
12426 }
12427 resultobj = SWIG_Py_Void();
12428 return resultobj;
12429 fail:
12430 return NULL;
12431 }
12432
12433
12434 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12435 PyObject *resultobj = 0;
12436 bool arg1 = (bool) true ;
12437 bool val1 ;
12438 int ecode1 = 0 ;
12439 PyObject * obj0 = 0 ;
12440 char * kwnames[] = {
12441 (char *) "bVerbose", NULL
12442 };
12443
12444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12445 if (obj0) {
12446 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12447 if (!SWIG_IsOK(ecode1)) {
12448 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12449 }
12450 arg1 = static_cast< bool >(val1);
12451 }
12452 {
12453 PyThreadState* __tstate = wxPyBeginAllowThreads();
12454 wxLog::SetVerbose(arg1);
12455 wxPyEndAllowThreads(__tstate);
12456 if (PyErr_Occurred()) SWIG_fail;
12457 }
12458 resultobj = SWIG_Py_Void();
12459 return resultobj;
12460 fail:
12461 return NULL;
12462 }
12463
12464
12465 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12466 PyObject *resultobj = 0;
12467 wxLogLevel arg1 ;
12468 unsigned long val1 ;
12469 int ecode1 = 0 ;
12470 PyObject * obj0 = 0 ;
12471 char * kwnames[] = {
12472 (char *) "logLevel", NULL
12473 };
12474
12475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12476 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12477 if (!SWIG_IsOK(ecode1)) {
12478 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12479 }
12480 arg1 = static_cast< wxLogLevel >(val1);
12481 {
12482 PyThreadState* __tstate = wxPyBeginAllowThreads();
12483 wxLog::SetLogLevel(arg1);
12484 wxPyEndAllowThreads(__tstate);
12485 if (PyErr_Occurred()) SWIG_fail;
12486 }
12487 resultobj = SWIG_Py_Void();
12488 return resultobj;
12489 fail:
12490 return NULL;
12491 }
12492
12493
12494 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12495 PyObject *resultobj = 0;
12496
12497 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12498 {
12499 PyThreadState* __tstate = wxPyBeginAllowThreads();
12500 wxLog::DontCreateOnDemand();
12501 wxPyEndAllowThreads(__tstate);
12502 if (PyErr_Occurred()) SWIG_fail;
12503 }
12504 resultobj = SWIG_Py_Void();
12505 return resultobj;
12506 fail:
12507 return NULL;
12508 }
12509
12510
12511 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12512 PyObject *resultobj = 0;
12513 bool arg1 = (bool) true ;
12514 bool val1 ;
12515 int ecode1 = 0 ;
12516 PyObject * obj0 = 0 ;
12517 char * kwnames[] = {
12518 (char *) "bRepetCounting", NULL
12519 };
12520
12521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12522 if (obj0) {
12523 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12524 if (!SWIG_IsOK(ecode1)) {
12525 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12526 }
12527 arg1 = static_cast< bool >(val1);
12528 }
12529 {
12530 PyThreadState* __tstate = wxPyBeginAllowThreads();
12531 wxLog::SetRepetitionCounting(arg1);
12532 wxPyEndAllowThreads(__tstate);
12533 if (PyErr_Occurred()) SWIG_fail;
12534 }
12535 resultobj = SWIG_Py_Void();
12536 return resultobj;
12537 fail:
12538 return NULL;
12539 }
12540
12541
12542 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12543 PyObject *resultobj = 0;
12544 bool result;
12545
12546 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12547 {
12548 PyThreadState* __tstate = wxPyBeginAllowThreads();
12549 result = (bool)wxLog::GetRepetitionCounting();
12550 wxPyEndAllowThreads(__tstate);
12551 if (PyErr_Occurred()) SWIG_fail;
12552 }
12553 {
12554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12555 }
12556 return resultobj;
12557 fail:
12558 return NULL;
12559 }
12560
12561
12562 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12563 PyObject *resultobj = 0;
12564 wxTraceMask arg1 ;
12565 unsigned long val1 ;
12566 int ecode1 = 0 ;
12567 PyObject * obj0 = 0 ;
12568 char * kwnames[] = {
12569 (char *) "ulMask", NULL
12570 };
12571
12572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12573 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12574 if (!SWIG_IsOK(ecode1)) {
12575 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12576 }
12577 arg1 = static_cast< wxTraceMask >(val1);
12578 {
12579 PyThreadState* __tstate = wxPyBeginAllowThreads();
12580 wxLog::SetTraceMask(arg1);
12581 wxPyEndAllowThreads(__tstate);
12582 if (PyErr_Occurred()) SWIG_fail;
12583 }
12584 resultobj = SWIG_Py_Void();
12585 return resultobj;
12586 fail:
12587 return NULL;
12588 }
12589
12590
12591 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12592 PyObject *resultobj = 0;
12593 wxString *arg1 = 0 ;
12594 bool temp1 = false ;
12595 PyObject * obj0 = 0 ;
12596 char * kwnames[] = {
12597 (char *) "str", NULL
12598 };
12599
12600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12601 {
12602 arg1 = wxString_in_helper(obj0);
12603 if (arg1 == NULL) SWIG_fail;
12604 temp1 = true;
12605 }
12606 {
12607 PyThreadState* __tstate = wxPyBeginAllowThreads();
12608 wxLog::AddTraceMask((wxString const &)*arg1);
12609 wxPyEndAllowThreads(__tstate);
12610 if (PyErr_Occurred()) SWIG_fail;
12611 }
12612 resultobj = SWIG_Py_Void();
12613 {
12614 if (temp1)
12615 delete arg1;
12616 }
12617 return resultobj;
12618 fail:
12619 {
12620 if (temp1)
12621 delete arg1;
12622 }
12623 return NULL;
12624 }
12625
12626
12627 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12628 PyObject *resultobj = 0;
12629 wxString *arg1 = 0 ;
12630 bool temp1 = false ;
12631 PyObject * obj0 = 0 ;
12632 char * kwnames[] = {
12633 (char *) "str", NULL
12634 };
12635
12636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12637 {
12638 arg1 = wxString_in_helper(obj0);
12639 if (arg1 == NULL) SWIG_fail;
12640 temp1 = true;
12641 }
12642 {
12643 PyThreadState* __tstate = wxPyBeginAllowThreads();
12644 wxLog::RemoveTraceMask((wxString const &)*arg1);
12645 wxPyEndAllowThreads(__tstate);
12646 if (PyErr_Occurred()) SWIG_fail;
12647 }
12648 resultobj = SWIG_Py_Void();
12649 {
12650 if (temp1)
12651 delete arg1;
12652 }
12653 return resultobj;
12654 fail:
12655 {
12656 if (temp1)
12657 delete arg1;
12658 }
12659 return NULL;
12660 }
12661
12662
12663 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12664 PyObject *resultobj = 0;
12665
12666 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12667 {
12668 PyThreadState* __tstate = wxPyBeginAllowThreads();
12669 wxLog::ClearTraceMasks();
12670 wxPyEndAllowThreads(__tstate);
12671 if (PyErr_Occurred()) SWIG_fail;
12672 }
12673 resultobj = SWIG_Py_Void();
12674 return resultobj;
12675 fail:
12676 return NULL;
12677 }
12678
12679
12680 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12681 PyObject *resultobj = 0;
12682 wxArrayString *result = 0 ;
12683
12684 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12685 {
12686 PyThreadState* __tstate = wxPyBeginAllowThreads();
12687 {
12688 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12689 result = (wxArrayString *) &_result_ref;
12690 }
12691 wxPyEndAllowThreads(__tstate);
12692 if (PyErr_Occurred()) SWIG_fail;
12693 }
12694 {
12695 resultobj = wxArrayString2PyList_helper(*result);
12696 }
12697 return resultobj;
12698 fail:
12699 return NULL;
12700 }
12701
12702
12703 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12704 PyObject *resultobj = 0;
12705 wxChar *arg1 = (wxChar *) 0 ;
12706 void *argp1 = 0 ;
12707 int res1 = 0 ;
12708 PyObject * obj0 = 0 ;
12709 char * kwnames[] = {
12710 (char *) "ts", NULL
12711 };
12712
12713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12715 if (!SWIG_IsOK(res1)) {
12716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12717 }
12718 arg1 = reinterpret_cast< wxChar * >(argp1);
12719 {
12720 PyThreadState* __tstate = wxPyBeginAllowThreads();
12721 wxLog::SetTimestamp((wxChar const *)arg1);
12722 wxPyEndAllowThreads(__tstate);
12723 if (PyErr_Occurred()) SWIG_fail;
12724 }
12725 resultobj = SWIG_Py_Void();
12726 return resultobj;
12727 fail:
12728 return NULL;
12729 }
12730
12731
12732 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12733 PyObject *resultobj = 0;
12734 bool result;
12735
12736 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12737 {
12738 PyThreadState* __tstate = wxPyBeginAllowThreads();
12739 result = (bool)wxLog::GetVerbose();
12740 wxPyEndAllowThreads(__tstate);
12741 if (PyErr_Occurred()) SWIG_fail;
12742 }
12743 {
12744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12745 }
12746 return resultobj;
12747 fail:
12748 return NULL;
12749 }
12750
12751
12752 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12753 PyObject *resultobj = 0;
12754 wxTraceMask result;
12755
12756 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12757 {
12758 PyThreadState* __tstate = wxPyBeginAllowThreads();
12759 result = (wxTraceMask)wxLog::GetTraceMask();
12760 wxPyEndAllowThreads(__tstate);
12761 if (PyErr_Occurred()) SWIG_fail;
12762 }
12763 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12764 return resultobj;
12765 fail:
12766 return NULL;
12767 }
12768
12769
12770 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12771 PyObject *resultobj = 0;
12772 wxChar *arg1 = (wxChar *) 0 ;
12773 bool result;
12774 void *argp1 = 0 ;
12775 int res1 = 0 ;
12776 PyObject * obj0 = 0 ;
12777 char * kwnames[] = {
12778 (char *) "mask", NULL
12779 };
12780
12781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12783 if (!SWIG_IsOK(res1)) {
12784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12785 }
12786 arg1 = reinterpret_cast< wxChar * >(argp1);
12787 {
12788 PyThreadState* __tstate = wxPyBeginAllowThreads();
12789 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12790 wxPyEndAllowThreads(__tstate);
12791 if (PyErr_Occurred()) SWIG_fail;
12792 }
12793 {
12794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12795 }
12796 return resultobj;
12797 fail:
12798 return NULL;
12799 }
12800
12801
12802 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12803 PyObject *resultobj = 0;
12804 wxLogLevel result;
12805
12806 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12807 {
12808 PyThreadState* __tstate = wxPyBeginAllowThreads();
12809 result = (wxLogLevel)wxLog::GetLogLevel();
12810 wxPyEndAllowThreads(__tstate);
12811 if (PyErr_Occurred()) SWIG_fail;
12812 }
12813 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12814 return resultobj;
12815 fail:
12816 return NULL;
12817 }
12818
12819
12820 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12821 PyObject *resultobj = 0;
12822 wxChar *result = 0 ;
12823
12824 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12825 {
12826 PyThreadState* __tstate = wxPyBeginAllowThreads();
12827 result = (wxChar *)wxLog::GetTimestamp();
12828 wxPyEndAllowThreads(__tstate);
12829 if (PyErr_Occurred()) SWIG_fail;
12830 }
12831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12832 return resultobj;
12833 fail:
12834 return NULL;
12835 }
12836
12837
12838 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12839 PyObject *resultobj = 0;
12840 wxString result;
12841
12842 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12843 {
12844 PyThreadState* __tstate = wxPyBeginAllowThreads();
12845 result = wxLog_TimeStamp();
12846 wxPyEndAllowThreads(__tstate);
12847 if (PyErr_Occurred()) SWIG_fail;
12848 }
12849 {
12850 #if wxUSE_UNICODE
12851 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12852 #else
12853 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12854 #endif
12855 }
12856 return resultobj;
12857 fail:
12858 return NULL;
12859 }
12860
12861
12862 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12863 PyObject *resultobj = 0;
12864 wxLog *arg1 = (wxLog *) 0 ;
12865 void *argp1 = 0 ;
12866 int res1 = 0 ;
12867 PyObject *swig_obj[1] ;
12868
12869 if (!args) SWIG_fail;
12870 swig_obj[0] = args;
12871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12872 if (!SWIG_IsOK(res1)) {
12873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12874 }
12875 arg1 = reinterpret_cast< wxLog * >(argp1);
12876 {
12877 PyThreadState* __tstate = wxPyBeginAllowThreads();
12878 wxLog_Destroy(arg1);
12879 wxPyEndAllowThreads(__tstate);
12880 if (PyErr_Occurred()) SWIG_fail;
12881 }
12882 resultobj = SWIG_Py_Void();
12883 return resultobj;
12884 fail:
12885 return NULL;
12886 }
12887
12888
12889 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12890 PyObject *obj;
12891 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12892 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12893 return SWIG_Py_Void();
12894 }
12895
12896 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12897 return SWIG_Python_InitShadowInstance(args);
12898 }
12899
12900 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12901 PyObject *resultobj = 0;
12902 wxLogStderr *result = 0 ;
12903
12904 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12905 {
12906 PyThreadState* __tstate = wxPyBeginAllowThreads();
12907 result = (wxLogStderr *)new wxLogStderr();
12908 wxPyEndAllowThreads(__tstate);
12909 if (PyErr_Occurred()) SWIG_fail;
12910 }
12911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12912 return resultobj;
12913 fail:
12914 return NULL;
12915 }
12916
12917
12918 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12919 PyObject *obj;
12920 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12921 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12922 return SWIG_Py_Void();
12923 }
12924
12925 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12926 return SWIG_Python_InitShadowInstance(args);
12927 }
12928
12929 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12930 PyObject *resultobj = 0;
12931 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12932 wxLogTextCtrl *result = 0 ;
12933 void *argp1 = 0 ;
12934 int res1 = 0 ;
12935 PyObject * obj0 = 0 ;
12936 char * kwnames[] = {
12937 (char *) "pTextCtrl", NULL
12938 };
12939
12940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12942 if (!SWIG_IsOK(res1)) {
12943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12944 }
12945 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12946 {
12947 PyThreadState* __tstate = wxPyBeginAllowThreads();
12948 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12949 wxPyEndAllowThreads(__tstate);
12950 if (PyErr_Occurred()) SWIG_fail;
12951 }
12952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12953 return resultobj;
12954 fail:
12955 return NULL;
12956 }
12957
12958
12959 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12960 PyObject *obj;
12961 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12962 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12963 return SWIG_Py_Void();
12964 }
12965
12966 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12967 return SWIG_Python_InitShadowInstance(args);
12968 }
12969
12970 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12971 PyObject *resultobj = 0;
12972 wxLogGui *result = 0 ;
12973
12974 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12975 {
12976 PyThreadState* __tstate = wxPyBeginAllowThreads();
12977 result = (wxLogGui *)new wxLogGui();
12978 wxPyEndAllowThreads(__tstate);
12979 if (PyErr_Occurred()) SWIG_fail;
12980 }
12981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12982 return resultobj;
12983 fail:
12984 return NULL;
12985 }
12986
12987
12988 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12989 PyObject *obj;
12990 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12991 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12992 return SWIG_Py_Void();
12993 }
12994
12995 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12996 return SWIG_Python_InitShadowInstance(args);
12997 }
12998
12999 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13000 PyObject *resultobj = 0;
13001 wxFrame *arg1 = (wxFrame *) 0 ;
13002 wxString *arg2 = 0 ;
13003 bool arg3 = (bool) true ;
13004 bool arg4 = (bool) true ;
13005 wxLogWindow *result = 0 ;
13006 void *argp1 = 0 ;
13007 int res1 = 0 ;
13008 bool temp2 = false ;
13009 bool val3 ;
13010 int ecode3 = 0 ;
13011 bool val4 ;
13012 int ecode4 = 0 ;
13013 PyObject * obj0 = 0 ;
13014 PyObject * obj1 = 0 ;
13015 PyObject * obj2 = 0 ;
13016 PyObject * obj3 = 0 ;
13017 char * kwnames[] = {
13018 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
13019 };
13020
13021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13023 if (!SWIG_IsOK(res1)) {
13024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
13025 }
13026 arg1 = reinterpret_cast< wxFrame * >(argp1);
13027 {
13028 arg2 = wxString_in_helper(obj1);
13029 if (arg2 == NULL) SWIG_fail;
13030 temp2 = true;
13031 }
13032 if (obj2) {
13033 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13034 if (!SWIG_IsOK(ecode3)) {
13035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13036 }
13037 arg3 = static_cast< bool >(val3);
13038 }
13039 if (obj3) {
13040 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13041 if (!SWIG_IsOK(ecode4)) {
13042 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13043 }
13044 arg4 = static_cast< bool >(val4);
13045 }
13046 {
13047 PyThreadState* __tstate = wxPyBeginAllowThreads();
13048 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13049 wxPyEndAllowThreads(__tstate);
13050 if (PyErr_Occurred()) SWIG_fail;
13051 }
13052 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13053 {
13054 if (temp2)
13055 delete arg2;
13056 }
13057 return resultobj;
13058 fail:
13059 {
13060 if (temp2)
13061 delete arg2;
13062 }
13063 return NULL;
13064 }
13065
13066
13067 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13068 PyObject *resultobj = 0;
13069 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13070 bool arg2 = (bool) true ;
13071 void *argp1 = 0 ;
13072 int res1 = 0 ;
13073 bool val2 ;
13074 int ecode2 = 0 ;
13075 PyObject * obj0 = 0 ;
13076 PyObject * obj1 = 0 ;
13077 char * kwnames[] = {
13078 (char *) "self",(char *) "bShow", NULL
13079 };
13080
13081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13083 if (!SWIG_IsOK(res1)) {
13084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13085 }
13086 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13087 if (obj1) {
13088 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13089 if (!SWIG_IsOK(ecode2)) {
13090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13091 }
13092 arg2 = static_cast< bool >(val2);
13093 }
13094 {
13095 PyThreadState* __tstate = wxPyBeginAllowThreads();
13096 (arg1)->Show(arg2);
13097 wxPyEndAllowThreads(__tstate);
13098 if (PyErr_Occurred()) SWIG_fail;
13099 }
13100 resultobj = SWIG_Py_Void();
13101 return resultobj;
13102 fail:
13103 return NULL;
13104 }
13105
13106
13107 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13108 PyObject *resultobj = 0;
13109 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13110 wxFrame *result = 0 ;
13111 void *argp1 = 0 ;
13112 int res1 = 0 ;
13113 PyObject *swig_obj[1] ;
13114
13115 if (!args) SWIG_fail;
13116 swig_obj[0] = args;
13117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13118 if (!SWIG_IsOK(res1)) {
13119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13120 }
13121 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13122 {
13123 PyThreadState* __tstate = wxPyBeginAllowThreads();
13124 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13125 wxPyEndAllowThreads(__tstate);
13126 if (PyErr_Occurred()) SWIG_fail;
13127 }
13128 {
13129 resultobj = wxPyMake_wxObject(result, (bool)0);
13130 }
13131 return resultobj;
13132 fail:
13133 return NULL;
13134 }
13135
13136
13137 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13138 PyObject *resultobj = 0;
13139 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13140 wxLog *result = 0 ;
13141 void *argp1 = 0 ;
13142 int res1 = 0 ;
13143 PyObject *swig_obj[1] ;
13144
13145 if (!args) SWIG_fail;
13146 swig_obj[0] = args;
13147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13148 if (!SWIG_IsOK(res1)) {
13149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13150 }
13151 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13152 {
13153 PyThreadState* __tstate = wxPyBeginAllowThreads();
13154 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13155 wxPyEndAllowThreads(__tstate);
13156 if (PyErr_Occurred()) SWIG_fail;
13157 }
13158 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13159 return resultobj;
13160 fail:
13161 return NULL;
13162 }
13163
13164
13165 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13166 PyObject *resultobj = 0;
13167 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13168 bool result;
13169 void *argp1 = 0 ;
13170 int res1 = 0 ;
13171 PyObject *swig_obj[1] ;
13172
13173 if (!args) SWIG_fail;
13174 swig_obj[0] = args;
13175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13176 if (!SWIG_IsOK(res1)) {
13177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13178 }
13179 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13180 {
13181 PyThreadState* __tstate = wxPyBeginAllowThreads();
13182 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13183 wxPyEndAllowThreads(__tstate);
13184 if (PyErr_Occurred()) SWIG_fail;
13185 }
13186 {
13187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13188 }
13189 return resultobj;
13190 fail:
13191 return NULL;
13192 }
13193
13194
13195 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13196 PyObject *resultobj = 0;
13197 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13198 bool arg2 ;
13199 void *argp1 = 0 ;
13200 int res1 = 0 ;
13201 bool val2 ;
13202 int ecode2 = 0 ;
13203 PyObject * obj0 = 0 ;
13204 PyObject * obj1 = 0 ;
13205 char * kwnames[] = {
13206 (char *) "self",(char *) "bDoPass", NULL
13207 };
13208
13209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13211 if (!SWIG_IsOK(res1)) {
13212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13213 }
13214 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13215 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13216 if (!SWIG_IsOK(ecode2)) {
13217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13218 }
13219 arg2 = static_cast< bool >(val2);
13220 {
13221 PyThreadState* __tstate = wxPyBeginAllowThreads();
13222 (arg1)->PassMessages(arg2);
13223 wxPyEndAllowThreads(__tstate);
13224 if (PyErr_Occurred()) SWIG_fail;
13225 }
13226 resultobj = SWIG_Py_Void();
13227 return resultobj;
13228 fail:
13229 return NULL;
13230 }
13231
13232
13233 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13234 PyObject *obj;
13235 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13236 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13237 return SWIG_Py_Void();
13238 }
13239
13240 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13241 return SWIG_Python_InitShadowInstance(args);
13242 }
13243
13244 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13245 PyObject *resultobj = 0;
13246 wxLog *arg1 = (wxLog *) 0 ;
13247 wxLogChain *result = 0 ;
13248 void *argp1 = 0 ;
13249 int res1 = 0 ;
13250 PyObject * obj0 = 0 ;
13251 char * kwnames[] = {
13252 (char *) "logger", NULL
13253 };
13254
13255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13257 if (!SWIG_IsOK(res1)) {
13258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13259 }
13260 arg1 = reinterpret_cast< wxLog * >(argp1);
13261 {
13262 PyThreadState* __tstate = wxPyBeginAllowThreads();
13263 result = (wxLogChain *)new wxLogChain(arg1);
13264 wxPyEndAllowThreads(__tstate);
13265 if (PyErr_Occurred()) SWIG_fail;
13266 }
13267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13268 return resultobj;
13269 fail:
13270 return NULL;
13271 }
13272
13273
13274 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13275 PyObject *resultobj = 0;
13276 wxLogChain *arg1 = (wxLogChain *) 0 ;
13277 wxLog *arg2 = (wxLog *) 0 ;
13278 void *argp1 = 0 ;
13279 int res1 = 0 ;
13280 void *argp2 = 0 ;
13281 int res2 = 0 ;
13282 PyObject * obj0 = 0 ;
13283 PyObject * obj1 = 0 ;
13284 char * kwnames[] = {
13285 (char *) "self",(char *) "logger", NULL
13286 };
13287
13288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13290 if (!SWIG_IsOK(res1)) {
13291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13292 }
13293 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13294 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13295 if (!SWIG_IsOK(res2)) {
13296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13297 }
13298 arg2 = reinterpret_cast< wxLog * >(argp2);
13299 {
13300 PyThreadState* __tstate = wxPyBeginAllowThreads();
13301 (arg1)->SetLog(arg2);
13302 wxPyEndAllowThreads(__tstate);
13303 if (PyErr_Occurred()) SWIG_fail;
13304 }
13305 resultobj = SWIG_Py_Void();
13306 return resultobj;
13307 fail:
13308 return NULL;
13309 }
13310
13311
13312 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13313 PyObject *resultobj = 0;
13314 wxLogChain *arg1 = (wxLogChain *) 0 ;
13315 bool arg2 ;
13316 void *argp1 = 0 ;
13317 int res1 = 0 ;
13318 bool val2 ;
13319 int ecode2 = 0 ;
13320 PyObject * obj0 = 0 ;
13321 PyObject * obj1 = 0 ;
13322 char * kwnames[] = {
13323 (char *) "self",(char *) "bDoPass", NULL
13324 };
13325
13326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13328 if (!SWIG_IsOK(res1)) {
13329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13330 }
13331 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13332 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13333 if (!SWIG_IsOK(ecode2)) {
13334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13335 }
13336 arg2 = static_cast< bool >(val2);
13337 {
13338 PyThreadState* __tstate = wxPyBeginAllowThreads();
13339 (arg1)->PassMessages(arg2);
13340 wxPyEndAllowThreads(__tstate);
13341 if (PyErr_Occurred()) SWIG_fail;
13342 }
13343 resultobj = SWIG_Py_Void();
13344 return resultobj;
13345 fail:
13346 return NULL;
13347 }
13348
13349
13350 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13351 PyObject *resultobj = 0;
13352 wxLogChain *arg1 = (wxLogChain *) 0 ;
13353 bool result;
13354 void *argp1 = 0 ;
13355 int res1 = 0 ;
13356 PyObject *swig_obj[1] ;
13357
13358 if (!args) SWIG_fail;
13359 swig_obj[0] = args;
13360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13361 if (!SWIG_IsOK(res1)) {
13362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13363 }
13364 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13365 {
13366 PyThreadState* __tstate = wxPyBeginAllowThreads();
13367 result = (bool)(arg1)->IsPassingMessages();
13368 wxPyEndAllowThreads(__tstate);
13369 if (PyErr_Occurred()) SWIG_fail;
13370 }
13371 {
13372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13373 }
13374 return resultobj;
13375 fail:
13376 return NULL;
13377 }
13378
13379
13380 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13381 PyObject *resultobj = 0;
13382 wxLogChain *arg1 = (wxLogChain *) 0 ;
13383 wxLog *result = 0 ;
13384 void *argp1 = 0 ;
13385 int res1 = 0 ;
13386 PyObject *swig_obj[1] ;
13387
13388 if (!args) SWIG_fail;
13389 swig_obj[0] = args;
13390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13391 if (!SWIG_IsOK(res1)) {
13392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13393 }
13394 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13395 {
13396 PyThreadState* __tstate = wxPyBeginAllowThreads();
13397 result = (wxLog *)(arg1)->GetOldLog();
13398 wxPyEndAllowThreads(__tstate);
13399 if (PyErr_Occurred()) SWIG_fail;
13400 }
13401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13402 return resultobj;
13403 fail:
13404 return NULL;
13405 }
13406
13407
13408 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13409 PyObject *obj;
13410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13411 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13412 return SWIG_Py_Void();
13413 }
13414
13415 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13416 return SWIG_Python_InitShadowInstance(args);
13417 }
13418
13419 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13420 PyObject *resultobj = 0;
13421 wxLogBuffer *result = 0 ;
13422
13423 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13424 {
13425 PyThreadState* __tstate = wxPyBeginAllowThreads();
13426 result = (wxLogBuffer *)new wxLogBuffer();
13427 wxPyEndAllowThreads(__tstate);
13428 if (PyErr_Occurred()) SWIG_fail;
13429 }
13430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13431 return resultobj;
13432 fail:
13433 return NULL;
13434 }
13435
13436
13437 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13438 PyObject *resultobj = 0;
13439 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13440 wxString *result = 0 ;
13441 void *argp1 = 0 ;
13442 int res1 = 0 ;
13443 PyObject *swig_obj[1] ;
13444
13445 if (!args) SWIG_fail;
13446 swig_obj[0] = args;
13447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13448 if (!SWIG_IsOK(res1)) {
13449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13450 }
13451 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13452 {
13453 PyThreadState* __tstate = wxPyBeginAllowThreads();
13454 {
13455 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13456 result = (wxString *) &_result_ref;
13457 }
13458 wxPyEndAllowThreads(__tstate);
13459 if (PyErr_Occurred()) SWIG_fail;
13460 }
13461 {
13462 #if wxUSE_UNICODE
13463 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13464 #else
13465 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13466 #endif
13467 }
13468 return resultobj;
13469 fail:
13470 return NULL;
13471 }
13472
13473
13474 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13475 PyObject *obj;
13476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13477 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13478 return SWIG_Py_Void();
13479 }
13480
13481 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13482 return SWIG_Python_InitShadowInstance(args);
13483 }
13484
13485 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13486 PyObject *resultobj = 0;
13487 unsigned long result;
13488
13489 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13490 {
13491 PyThreadState* __tstate = wxPyBeginAllowThreads();
13492 result = (unsigned long)wxSysErrorCode();
13493 wxPyEndAllowThreads(__tstate);
13494 if (PyErr_Occurred()) SWIG_fail;
13495 }
13496 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13497 return resultobj;
13498 fail:
13499 return NULL;
13500 }
13501
13502
13503 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13504 PyObject *resultobj = 0;
13505 unsigned long arg1 = (unsigned long) 0 ;
13506 wxString result;
13507 unsigned long val1 ;
13508 int ecode1 = 0 ;
13509 PyObject * obj0 = 0 ;
13510 char * kwnames[] = {
13511 (char *) "nErrCode", NULL
13512 };
13513
13514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13515 if (obj0) {
13516 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13517 if (!SWIG_IsOK(ecode1)) {
13518 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13519 }
13520 arg1 = static_cast< unsigned long >(val1);
13521 }
13522 {
13523 PyThreadState* __tstate = wxPyBeginAllowThreads();
13524 result = wxSysErrorMsg(arg1);
13525 wxPyEndAllowThreads(__tstate);
13526 if (PyErr_Occurred()) SWIG_fail;
13527 }
13528 {
13529 #if wxUSE_UNICODE
13530 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13531 #else
13532 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13533 #endif
13534 }
13535 return resultobj;
13536 fail:
13537 return NULL;
13538 }
13539
13540
13541 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13542 PyObject *resultobj = 0;
13543 wxString *arg1 = 0 ;
13544 bool temp1 = false ;
13545 PyObject * obj0 = 0 ;
13546 char * kwnames[] = {
13547 (char *) "msg", NULL
13548 };
13549
13550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13551 {
13552 arg1 = wxString_in_helper(obj0);
13553 if (arg1 == NULL) SWIG_fail;
13554 temp1 = true;
13555 }
13556 {
13557 PyThreadState* __tstate = wxPyBeginAllowThreads();
13558 wxPyLogFatalError((wxString const &)*arg1);
13559 wxPyEndAllowThreads(__tstate);
13560 if (PyErr_Occurred()) SWIG_fail;
13561 }
13562 resultobj = SWIG_Py_Void();
13563 {
13564 if (temp1)
13565 delete arg1;
13566 }
13567 return resultobj;
13568 fail:
13569 {
13570 if (temp1)
13571 delete arg1;
13572 }
13573 return NULL;
13574 }
13575
13576
13577 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13578 PyObject *resultobj = 0;
13579 wxString *arg1 = 0 ;
13580 bool temp1 = false ;
13581 PyObject * obj0 = 0 ;
13582 char * kwnames[] = {
13583 (char *) "msg", NULL
13584 };
13585
13586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13587 {
13588 arg1 = wxString_in_helper(obj0);
13589 if (arg1 == NULL) SWIG_fail;
13590 temp1 = true;
13591 }
13592 {
13593 PyThreadState* __tstate = wxPyBeginAllowThreads();
13594 wxPyLogError((wxString const &)*arg1);
13595 wxPyEndAllowThreads(__tstate);
13596 if (PyErr_Occurred()) SWIG_fail;
13597 }
13598 resultobj = SWIG_Py_Void();
13599 {
13600 if (temp1)
13601 delete arg1;
13602 }
13603 return resultobj;
13604 fail:
13605 {
13606 if (temp1)
13607 delete arg1;
13608 }
13609 return NULL;
13610 }
13611
13612
13613 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13614 PyObject *resultobj = 0;
13615 wxString *arg1 = 0 ;
13616 bool temp1 = false ;
13617 PyObject * obj0 = 0 ;
13618 char * kwnames[] = {
13619 (char *) "msg", NULL
13620 };
13621
13622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13623 {
13624 arg1 = wxString_in_helper(obj0);
13625 if (arg1 == NULL) SWIG_fail;
13626 temp1 = true;
13627 }
13628 {
13629 PyThreadState* __tstate = wxPyBeginAllowThreads();
13630 wxPyLogWarning((wxString const &)*arg1);
13631 wxPyEndAllowThreads(__tstate);
13632 if (PyErr_Occurred()) SWIG_fail;
13633 }
13634 resultobj = SWIG_Py_Void();
13635 {
13636 if (temp1)
13637 delete arg1;
13638 }
13639 return resultobj;
13640 fail:
13641 {
13642 if (temp1)
13643 delete arg1;
13644 }
13645 return NULL;
13646 }
13647
13648
13649 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13650 PyObject *resultobj = 0;
13651 wxString *arg1 = 0 ;
13652 bool temp1 = false ;
13653 PyObject * obj0 = 0 ;
13654 char * kwnames[] = {
13655 (char *) "msg", NULL
13656 };
13657
13658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13659 {
13660 arg1 = wxString_in_helper(obj0);
13661 if (arg1 == NULL) SWIG_fail;
13662 temp1 = true;
13663 }
13664 {
13665 PyThreadState* __tstate = wxPyBeginAllowThreads();
13666 wxPyLogMessage((wxString const &)*arg1);
13667 wxPyEndAllowThreads(__tstate);
13668 if (PyErr_Occurred()) SWIG_fail;
13669 }
13670 resultobj = SWIG_Py_Void();
13671 {
13672 if (temp1)
13673 delete arg1;
13674 }
13675 return resultobj;
13676 fail:
13677 {
13678 if (temp1)
13679 delete arg1;
13680 }
13681 return NULL;
13682 }
13683
13684
13685 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13686 PyObject *resultobj = 0;
13687 wxString *arg1 = 0 ;
13688 bool temp1 = false ;
13689 PyObject * obj0 = 0 ;
13690 char * kwnames[] = {
13691 (char *) "msg", NULL
13692 };
13693
13694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13695 {
13696 arg1 = wxString_in_helper(obj0);
13697 if (arg1 == NULL) SWIG_fail;
13698 temp1 = true;
13699 }
13700 {
13701 PyThreadState* __tstate = wxPyBeginAllowThreads();
13702 wxPyLogInfo((wxString const &)*arg1);
13703 wxPyEndAllowThreads(__tstate);
13704 if (PyErr_Occurred()) SWIG_fail;
13705 }
13706 resultobj = SWIG_Py_Void();
13707 {
13708 if (temp1)
13709 delete arg1;
13710 }
13711 return resultobj;
13712 fail:
13713 {
13714 if (temp1)
13715 delete arg1;
13716 }
13717 return NULL;
13718 }
13719
13720
13721 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13722 PyObject *resultobj = 0;
13723 wxString *arg1 = 0 ;
13724 bool temp1 = false ;
13725 PyObject * obj0 = 0 ;
13726 char * kwnames[] = {
13727 (char *) "msg", NULL
13728 };
13729
13730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13731 {
13732 arg1 = wxString_in_helper(obj0);
13733 if (arg1 == NULL) SWIG_fail;
13734 temp1 = true;
13735 }
13736 {
13737 PyThreadState* __tstate = wxPyBeginAllowThreads();
13738 wxPyLogDebug((wxString const &)*arg1);
13739 wxPyEndAllowThreads(__tstate);
13740 if (PyErr_Occurred()) SWIG_fail;
13741 }
13742 resultobj = SWIG_Py_Void();
13743 {
13744 if (temp1)
13745 delete arg1;
13746 }
13747 return resultobj;
13748 fail:
13749 {
13750 if (temp1)
13751 delete arg1;
13752 }
13753 return NULL;
13754 }
13755
13756
13757 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13758 PyObject *resultobj = 0;
13759 wxString *arg1 = 0 ;
13760 bool temp1 = false ;
13761 PyObject * obj0 = 0 ;
13762 char * kwnames[] = {
13763 (char *) "msg", NULL
13764 };
13765
13766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13767 {
13768 arg1 = wxString_in_helper(obj0);
13769 if (arg1 == NULL) SWIG_fail;
13770 temp1 = true;
13771 }
13772 {
13773 PyThreadState* __tstate = wxPyBeginAllowThreads();
13774 wxPyLogVerbose((wxString const &)*arg1);
13775 wxPyEndAllowThreads(__tstate);
13776 if (PyErr_Occurred()) SWIG_fail;
13777 }
13778 resultobj = SWIG_Py_Void();
13779 {
13780 if (temp1)
13781 delete arg1;
13782 }
13783 return resultobj;
13784 fail:
13785 {
13786 if (temp1)
13787 delete arg1;
13788 }
13789 return NULL;
13790 }
13791
13792
13793 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13794 PyObject *resultobj = 0;
13795 wxString *arg1 = 0 ;
13796 bool temp1 = false ;
13797 PyObject * obj0 = 0 ;
13798 char * kwnames[] = {
13799 (char *) "msg", NULL
13800 };
13801
13802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13803 {
13804 arg1 = wxString_in_helper(obj0);
13805 if (arg1 == NULL) SWIG_fail;
13806 temp1 = true;
13807 }
13808 {
13809 PyThreadState* __tstate = wxPyBeginAllowThreads();
13810 wxPyLogStatus((wxString const &)*arg1);
13811 wxPyEndAllowThreads(__tstate);
13812 if (PyErr_Occurred()) SWIG_fail;
13813 }
13814 resultobj = SWIG_Py_Void();
13815 {
13816 if (temp1)
13817 delete arg1;
13818 }
13819 return resultobj;
13820 fail:
13821 {
13822 if (temp1)
13823 delete arg1;
13824 }
13825 return NULL;
13826 }
13827
13828
13829 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13830 PyObject *resultobj = 0;
13831 wxFrame *arg1 = (wxFrame *) 0 ;
13832 wxString *arg2 = 0 ;
13833 void *argp1 = 0 ;
13834 int res1 = 0 ;
13835 bool temp2 = false ;
13836 PyObject * obj0 = 0 ;
13837 PyObject * obj1 = 0 ;
13838 char * kwnames[] = {
13839 (char *) "pFrame",(char *) "msg", NULL
13840 };
13841
13842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13844 if (!SWIG_IsOK(res1)) {
13845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13846 }
13847 arg1 = reinterpret_cast< wxFrame * >(argp1);
13848 {
13849 arg2 = wxString_in_helper(obj1);
13850 if (arg2 == NULL) SWIG_fail;
13851 temp2 = true;
13852 }
13853 {
13854 PyThreadState* __tstate = wxPyBeginAllowThreads();
13855 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13856 wxPyEndAllowThreads(__tstate);
13857 if (PyErr_Occurred()) SWIG_fail;
13858 }
13859 resultobj = SWIG_Py_Void();
13860 {
13861 if (temp2)
13862 delete arg2;
13863 }
13864 return resultobj;
13865 fail:
13866 {
13867 if (temp2)
13868 delete arg2;
13869 }
13870 return NULL;
13871 }
13872
13873
13874 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13875 PyObject *resultobj = 0;
13876 wxString *arg1 = 0 ;
13877 bool temp1 = false ;
13878 PyObject * obj0 = 0 ;
13879 char * kwnames[] = {
13880 (char *) "msg", NULL
13881 };
13882
13883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13884 {
13885 arg1 = wxString_in_helper(obj0);
13886 if (arg1 == NULL) SWIG_fail;
13887 temp1 = true;
13888 }
13889 {
13890 PyThreadState* __tstate = wxPyBeginAllowThreads();
13891 wxPyLogSysError((wxString const &)*arg1);
13892 wxPyEndAllowThreads(__tstate);
13893 if (PyErr_Occurred()) SWIG_fail;
13894 }
13895 resultobj = SWIG_Py_Void();
13896 {
13897 if (temp1)
13898 delete arg1;
13899 }
13900 return resultobj;
13901 fail:
13902 {
13903 if (temp1)
13904 delete arg1;
13905 }
13906 return NULL;
13907 }
13908
13909
13910 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13911 PyObject *resultobj = 0;
13912 unsigned long arg1 ;
13913 wxString *arg2 = 0 ;
13914 unsigned long val1 ;
13915 int ecode1 = 0 ;
13916 bool temp2 = false ;
13917 PyObject * obj0 = 0 ;
13918 PyObject * obj1 = 0 ;
13919 char * kwnames[] = {
13920 (char *) "level",(char *) "msg", NULL
13921 };
13922
13923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13924 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13925 if (!SWIG_IsOK(ecode1)) {
13926 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13927 }
13928 arg1 = static_cast< unsigned long >(val1);
13929 {
13930 arg2 = wxString_in_helper(obj1);
13931 if (arg2 == NULL) SWIG_fail;
13932 temp2 = true;
13933 }
13934 {
13935 PyThreadState* __tstate = wxPyBeginAllowThreads();
13936 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13937 wxPyEndAllowThreads(__tstate);
13938 if (PyErr_Occurred()) SWIG_fail;
13939 }
13940 resultobj = SWIG_Py_Void();
13941 {
13942 if (temp2)
13943 delete arg2;
13944 }
13945 return resultobj;
13946 fail:
13947 {
13948 if (temp2)
13949 delete arg2;
13950 }
13951 return NULL;
13952 }
13953
13954
13955 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13956 PyObject *resultobj = 0;
13957 unsigned long arg1 ;
13958 wxString *arg2 = 0 ;
13959 unsigned long val1 ;
13960 int ecode1 = 0 ;
13961 bool temp2 = false ;
13962
13963 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13964 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13965 if (!SWIG_IsOK(ecode1)) {
13966 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13967 }
13968 arg1 = static_cast< unsigned long >(val1);
13969 {
13970 arg2 = wxString_in_helper(swig_obj[1]);
13971 if (arg2 == NULL) SWIG_fail;
13972 temp2 = true;
13973 }
13974 {
13975 PyThreadState* __tstate = wxPyBeginAllowThreads();
13976 wxPyLogTrace(arg1,(wxString const &)*arg2);
13977 wxPyEndAllowThreads(__tstate);
13978 if (PyErr_Occurred()) SWIG_fail;
13979 }
13980 resultobj = SWIG_Py_Void();
13981 {
13982 if (temp2)
13983 delete arg2;
13984 }
13985 return resultobj;
13986 fail:
13987 {
13988 if (temp2)
13989 delete arg2;
13990 }
13991 return NULL;
13992 }
13993
13994
13995 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13996 PyObject *resultobj = 0;
13997 wxString *arg1 = 0 ;
13998 wxString *arg2 = 0 ;
13999 bool temp1 = false ;
14000 bool temp2 = false ;
14001
14002 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
14003 {
14004 arg1 = wxString_in_helper(swig_obj[0]);
14005 if (arg1 == NULL) SWIG_fail;
14006 temp1 = true;
14007 }
14008 {
14009 arg2 = wxString_in_helper(swig_obj[1]);
14010 if (arg2 == NULL) SWIG_fail;
14011 temp2 = true;
14012 }
14013 {
14014 PyThreadState* __tstate = wxPyBeginAllowThreads();
14015 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
14016 wxPyEndAllowThreads(__tstate);
14017 if (PyErr_Occurred()) SWIG_fail;
14018 }
14019 resultobj = SWIG_Py_Void();
14020 {
14021 if (temp1)
14022 delete arg1;
14023 }
14024 {
14025 if (temp2)
14026 delete arg2;
14027 }
14028 return resultobj;
14029 fail:
14030 {
14031 if (temp1)
14032 delete arg1;
14033 }
14034 {
14035 if (temp2)
14036 delete arg2;
14037 }
14038 return NULL;
14039 }
14040
14041
14042 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14043 int argc;
14044 PyObject *argv[3];
14045
14046 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14047 --argc;
14048 if (argc == 2) {
14049 int _v = 0;
14050 {
14051 {
14052 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14053 }
14054 }
14055 if (!_v) goto check_1;
14056 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14057 }
14058 check_1:
14059
14060 if (argc == 2) {
14061 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14062 }
14063
14064 fail:
14065 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14066 return NULL;
14067 }
14068
14069
14070 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14071 PyObject *resultobj = 0;
14072 wxString *arg1 = 0 ;
14073 wxString *arg2 = 0 ;
14074 bool temp1 = false ;
14075 bool temp2 = false ;
14076 PyObject * obj0 = 0 ;
14077 PyObject * obj1 = 0 ;
14078 char * kwnames[] = {
14079 (char *) "title",(char *) "text", NULL
14080 };
14081
14082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14083 {
14084 arg1 = wxString_in_helper(obj0);
14085 if (arg1 == NULL) SWIG_fail;
14086 temp1 = true;
14087 }
14088 {
14089 arg2 = wxString_in_helper(obj1);
14090 if (arg2 == NULL) SWIG_fail;
14091 temp2 = true;
14092 }
14093 {
14094 PyThreadState* __tstate = wxPyBeginAllowThreads();
14095 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14096 wxPyEndAllowThreads(__tstate);
14097 if (PyErr_Occurred()) SWIG_fail;
14098 }
14099 resultobj = SWIG_Py_Void();
14100 {
14101 if (temp1)
14102 delete arg1;
14103 }
14104 {
14105 if (temp2)
14106 delete arg2;
14107 }
14108 return resultobj;
14109 fail:
14110 {
14111 if (temp1)
14112 delete arg1;
14113 }
14114 {
14115 if (temp2)
14116 delete arg2;
14117 }
14118 return NULL;
14119 }
14120
14121
14122 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14123 PyObject *resultobj = 0;
14124 wxLogNull *result = 0 ;
14125
14126 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14127 {
14128 PyThreadState* __tstate = wxPyBeginAllowThreads();
14129 result = (wxLogNull *)new wxLogNull();
14130 wxPyEndAllowThreads(__tstate);
14131 if (PyErr_Occurred()) SWIG_fail;
14132 }
14133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14134 return resultobj;
14135 fail:
14136 return NULL;
14137 }
14138
14139
14140 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14141 PyObject *resultobj = 0;
14142 wxLogNull *arg1 = (wxLogNull *) 0 ;
14143 void *argp1 = 0 ;
14144 int res1 = 0 ;
14145 PyObject *swig_obj[1] ;
14146
14147 if (!args) SWIG_fail;
14148 swig_obj[0] = args;
14149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14150 if (!SWIG_IsOK(res1)) {
14151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14152 }
14153 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14154 {
14155 PyThreadState* __tstate = wxPyBeginAllowThreads();
14156 delete arg1;
14157
14158 wxPyEndAllowThreads(__tstate);
14159 if (PyErr_Occurred()) SWIG_fail;
14160 }
14161 resultobj = SWIG_Py_Void();
14162 return resultobj;
14163 fail:
14164 return NULL;
14165 }
14166
14167
14168 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14169 PyObject *obj;
14170 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14171 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14172 return SWIG_Py_Void();
14173 }
14174
14175 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14176 return SWIG_Python_InitShadowInstance(args);
14177 }
14178
14179 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14180 PyObject *resultobj = 0;
14181 wxPyLog *result = 0 ;
14182
14183 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14184 {
14185 PyThreadState* __tstate = wxPyBeginAllowThreads();
14186 result = (wxPyLog *)new wxPyLog();
14187 wxPyEndAllowThreads(__tstate);
14188 if (PyErr_Occurred()) SWIG_fail;
14189 }
14190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14191 return resultobj;
14192 fail:
14193 return NULL;
14194 }
14195
14196
14197 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14198 PyObject *resultobj = 0;
14199 wxPyLog *arg1 = (wxPyLog *) 0 ;
14200 PyObject *arg2 = (PyObject *) 0 ;
14201 PyObject *arg3 = (PyObject *) 0 ;
14202 void *argp1 = 0 ;
14203 int res1 = 0 ;
14204 PyObject * obj0 = 0 ;
14205 PyObject * obj1 = 0 ;
14206 PyObject * obj2 = 0 ;
14207 char * kwnames[] = {
14208 (char *) "self",(char *) "self",(char *) "_class", NULL
14209 };
14210
14211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14213 if (!SWIG_IsOK(res1)) {
14214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14215 }
14216 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14217 arg2 = obj1;
14218 arg3 = obj2;
14219 {
14220 PyThreadState* __tstate = wxPyBeginAllowThreads();
14221 (arg1)->_setCallbackInfo(arg2,arg3);
14222 wxPyEndAllowThreads(__tstate);
14223 if (PyErr_Occurred()) SWIG_fail;
14224 }
14225 resultobj = SWIG_Py_Void();
14226 return resultobj;
14227 fail:
14228 return NULL;
14229 }
14230
14231
14232 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14233 PyObject *obj;
14234 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14235 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14236 return SWIG_Py_Void();
14237 }
14238
14239 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14240 return SWIG_Python_InitShadowInstance(args);
14241 }
14242
14243 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14244 PyObject *resultobj = 0;
14245 int arg1 ;
14246 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14247 int arg3 = (int) wxKILL_NOCHILDREN ;
14248 wxKillError result;
14249 int val1 ;
14250 int ecode1 = 0 ;
14251 int val2 ;
14252 int ecode2 = 0 ;
14253 int val3 ;
14254 int ecode3 = 0 ;
14255 PyObject * obj0 = 0 ;
14256 PyObject * obj1 = 0 ;
14257 PyObject * obj2 = 0 ;
14258 char * kwnames[] = {
14259 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14260 };
14261
14262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14263 ecode1 = SWIG_AsVal_int(obj0, &val1);
14264 if (!SWIG_IsOK(ecode1)) {
14265 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14266 }
14267 arg1 = static_cast< int >(val1);
14268 if (obj1) {
14269 ecode2 = SWIG_AsVal_int(obj1, &val2);
14270 if (!SWIG_IsOK(ecode2)) {
14271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14272 }
14273 arg2 = static_cast< wxSignal >(val2);
14274 }
14275 if (obj2) {
14276 ecode3 = SWIG_AsVal_int(obj2, &val3);
14277 if (!SWIG_IsOK(ecode3)) {
14278 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14279 }
14280 arg3 = static_cast< int >(val3);
14281 }
14282 {
14283 PyThreadState* __tstate = wxPyBeginAllowThreads();
14284 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14285 wxPyEndAllowThreads(__tstate);
14286 if (PyErr_Occurred()) SWIG_fail;
14287 }
14288 resultobj = SWIG_From_int(static_cast< int >(result));
14289 return resultobj;
14290 fail:
14291 return NULL;
14292 }
14293
14294
14295 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14296 PyObject *resultobj = 0;
14297 int arg1 ;
14298 bool result;
14299 int val1 ;
14300 int ecode1 = 0 ;
14301 PyObject * obj0 = 0 ;
14302 char * kwnames[] = {
14303 (char *) "pid", NULL
14304 };
14305
14306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14307 ecode1 = SWIG_AsVal_int(obj0, &val1);
14308 if (!SWIG_IsOK(ecode1)) {
14309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14310 }
14311 arg1 = static_cast< int >(val1);
14312 {
14313 PyThreadState* __tstate = wxPyBeginAllowThreads();
14314 result = (bool)wxPyProcess::Exists(arg1);
14315 wxPyEndAllowThreads(__tstate);
14316 if (PyErr_Occurred()) SWIG_fail;
14317 }
14318 {
14319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14320 }
14321 return resultobj;
14322 fail:
14323 return NULL;
14324 }
14325
14326
14327 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14328 PyObject *resultobj = 0;
14329 wxString *arg1 = 0 ;
14330 int arg2 = (int) wxEXEC_ASYNC ;
14331 wxPyProcess *result = 0 ;
14332 bool temp1 = false ;
14333 int val2 ;
14334 int ecode2 = 0 ;
14335 PyObject * obj0 = 0 ;
14336 PyObject * obj1 = 0 ;
14337 char * kwnames[] = {
14338 (char *) "cmd",(char *) "flags", NULL
14339 };
14340
14341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14342 {
14343 arg1 = wxString_in_helper(obj0);
14344 if (arg1 == NULL) SWIG_fail;
14345 temp1 = true;
14346 }
14347 if (obj1) {
14348 ecode2 = SWIG_AsVal_int(obj1, &val2);
14349 if (!SWIG_IsOK(ecode2)) {
14350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14351 }
14352 arg2 = static_cast< int >(val2);
14353 }
14354 {
14355 PyThreadState* __tstate = wxPyBeginAllowThreads();
14356 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14357 wxPyEndAllowThreads(__tstate);
14358 if (PyErr_Occurred()) SWIG_fail;
14359 }
14360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14361 {
14362 if (temp1)
14363 delete arg1;
14364 }
14365 return resultobj;
14366 fail:
14367 {
14368 if (temp1)
14369 delete arg1;
14370 }
14371 return NULL;
14372 }
14373
14374
14375 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14376 PyObject *resultobj = 0;
14377 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14378 int arg2 = (int) -1 ;
14379 wxPyProcess *result = 0 ;
14380 void *argp1 = 0 ;
14381 int res1 = 0 ;
14382 int val2 ;
14383 int ecode2 = 0 ;
14384 PyObject * obj0 = 0 ;
14385 PyObject * obj1 = 0 ;
14386 char * kwnames[] = {
14387 (char *) "parent",(char *) "id", NULL
14388 };
14389
14390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14391 if (obj0) {
14392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14393 if (!SWIG_IsOK(res1)) {
14394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14395 }
14396 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14397 }
14398 if (obj1) {
14399 ecode2 = SWIG_AsVal_int(obj1, &val2);
14400 if (!SWIG_IsOK(ecode2)) {
14401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14402 }
14403 arg2 = static_cast< int >(val2);
14404 }
14405 {
14406 PyThreadState* __tstate = wxPyBeginAllowThreads();
14407 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14408 wxPyEndAllowThreads(__tstate);
14409 if (PyErr_Occurred()) SWIG_fail;
14410 }
14411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14412 return resultobj;
14413 fail:
14414 return NULL;
14415 }
14416
14417
14418 SWIGINTERN PyObject *_wrap_delete_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14419 PyObject *resultobj = 0;
14420 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14421 void *argp1 = 0 ;
14422 int res1 = 0 ;
14423 PyObject *swig_obj[1] ;
14424
14425 if (!args) SWIG_fail;
14426 swig_obj[0] = args;
14427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, SWIG_POINTER_DISOWN | 0 );
14428 if (!SWIG_IsOK(res1)) {
14429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Process" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14430 }
14431 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14432 {
14433 PyThreadState* __tstate = wxPyBeginAllowThreads();
14434 delete arg1;
14435
14436 wxPyEndAllowThreads(__tstate);
14437 if (PyErr_Occurred()) SWIG_fail;
14438 }
14439 resultobj = SWIG_Py_Void();
14440 return resultobj;
14441 fail:
14442 return NULL;
14443 }
14444
14445
14446 SWIGINTERN PyObject *_wrap_Process_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14447 PyObject *resultobj = 0;
14448 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14449 long result;
14450 void *argp1 = 0 ;
14451 int res1 = 0 ;
14452 PyObject *swig_obj[1] ;
14453
14454 if (!args) SWIG_fail;
14455 swig_obj[0] = args;
14456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14457 if (!SWIG_IsOK(res1)) {
14458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetPid" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14459 }
14460 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14461 {
14462 PyThreadState* __tstate = wxPyBeginAllowThreads();
14463 result = (long)((wxPyProcess const *)arg1)->GetPid();
14464 wxPyEndAllowThreads(__tstate);
14465 if (PyErr_Occurred()) SWIG_fail;
14466 }
14467 resultobj = SWIG_From_long(static_cast< long >(result));
14468 return resultobj;
14469 fail:
14470 return NULL;
14471 }
14472
14473
14474 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14475 PyObject *resultobj = 0;
14476 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14477 PyObject *arg2 = (PyObject *) 0 ;
14478 PyObject *arg3 = (PyObject *) 0 ;
14479 void *argp1 = 0 ;
14480 int res1 = 0 ;
14481 PyObject * obj0 = 0 ;
14482 PyObject * obj1 = 0 ;
14483 PyObject * obj2 = 0 ;
14484 char * kwnames[] = {
14485 (char *) "self",(char *) "self",(char *) "_class", NULL
14486 };
14487
14488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14490 if (!SWIG_IsOK(res1)) {
14491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14492 }
14493 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14494 arg2 = obj1;
14495 arg3 = obj2;
14496 {
14497 PyThreadState* __tstate = wxPyBeginAllowThreads();
14498 (arg1)->_setCallbackInfo(arg2,arg3);
14499 wxPyEndAllowThreads(__tstate);
14500 if (PyErr_Occurred()) SWIG_fail;
14501 }
14502 resultobj = SWIG_Py_Void();
14503 return resultobj;
14504 fail:
14505 return NULL;
14506 }
14507
14508
14509 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14510 PyObject *resultobj = 0;
14511 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14512 int arg2 ;
14513 int arg3 ;
14514 void *argp1 = 0 ;
14515 int res1 = 0 ;
14516 int val2 ;
14517 int ecode2 = 0 ;
14518 int val3 ;
14519 int ecode3 = 0 ;
14520 PyObject * obj0 = 0 ;
14521 PyObject * obj1 = 0 ;
14522 PyObject * obj2 = 0 ;
14523 char * kwnames[] = {
14524 (char *) "self",(char *) "pid",(char *) "status", NULL
14525 };
14526
14527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14529 if (!SWIG_IsOK(res1)) {
14530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14531 }
14532 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14533 ecode2 = SWIG_AsVal_int(obj1, &val2);
14534 if (!SWIG_IsOK(ecode2)) {
14535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14536 }
14537 arg2 = static_cast< int >(val2);
14538 ecode3 = SWIG_AsVal_int(obj2, &val3);
14539 if (!SWIG_IsOK(ecode3)) {
14540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14541 }
14542 arg3 = static_cast< int >(val3);
14543 {
14544 PyThreadState* __tstate = wxPyBeginAllowThreads();
14545 (arg1)->OnTerminate(arg2,arg3);
14546 wxPyEndAllowThreads(__tstate);
14547 if (PyErr_Occurred()) SWIG_fail;
14548 }
14549 resultobj = SWIG_Py_Void();
14550 return resultobj;
14551 fail:
14552 return NULL;
14553 }
14554
14555
14556 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14557 PyObject *resultobj = 0;
14558 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14559 void *argp1 = 0 ;
14560 int res1 = 0 ;
14561 PyObject *swig_obj[1] ;
14562
14563 if (!args) SWIG_fail;
14564 swig_obj[0] = args;
14565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14566 if (!SWIG_IsOK(res1)) {
14567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14568 }
14569 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14570 {
14571 PyThreadState* __tstate = wxPyBeginAllowThreads();
14572 (arg1)->Redirect();
14573 wxPyEndAllowThreads(__tstate);
14574 if (PyErr_Occurred()) SWIG_fail;
14575 }
14576 resultobj = SWIG_Py_Void();
14577 return resultobj;
14578 fail:
14579 return NULL;
14580 }
14581
14582
14583 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14584 PyObject *resultobj = 0;
14585 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14586 bool result;
14587 void *argp1 = 0 ;
14588 int res1 = 0 ;
14589 PyObject *swig_obj[1] ;
14590
14591 if (!args) SWIG_fail;
14592 swig_obj[0] = args;
14593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14594 if (!SWIG_IsOK(res1)) {
14595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14596 }
14597 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14598 {
14599 PyThreadState* __tstate = wxPyBeginAllowThreads();
14600 result = (bool)(arg1)->IsRedirected();
14601 wxPyEndAllowThreads(__tstate);
14602 if (PyErr_Occurred()) SWIG_fail;
14603 }
14604 {
14605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14606 }
14607 return resultobj;
14608 fail:
14609 return NULL;
14610 }
14611
14612
14613 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14614 PyObject *resultobj = 0;
14615 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14616 void *argp1 = 0 ;
14617 int res1 = 0 ;
14618 PyObject *swig_obj[1] ;
14619
14620 if (!args) SWIG_fail;
14621 swig_obj[0] = args;
14622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14623 if (!SWIG_IsOK(res1)) {
14624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14625 }
14626 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14627 {
14628 PyThreadState* __tstate = wxPyBeginAllowThreads();
14629 (arg1)->Detach();
14630 wxPyEndAllowThreads(__tstate);
14631 if (PyErr_Occurred()) SWIG_fail;
14632 }
14633 resultobj = SWIG_Py_Void();
14634 return resultobj;
14635 fail:
14636 return NULL;
14637 }
14638
14639
14640 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14641 PyObject *resultobj = 0;
14642 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14643 wxInputStream *result = 0 ;
14644 void *argp1 = 0 ;
14645 int res1 = 0 ;
14646 PyObject *swig_obj[1] ;
14647
14648 if (!args) SWIG_fail;
14649 swig_obj[0] = args;
14650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14651 if (!SWIG_IsOK(res1)) {
14652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14653 }
14654 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14655 {
14656 PyThreadState* __tstate = wxPyBeginAllowThreads();
14657 result = (wxInputStream *)(arg1)->GetInputStream();
14658 wxPyEndAllowThreads(__tstate);
14659 if (PyErr_Occurred()) SWIG_fail;
14660 }
14661 {
14662 wxPyInputStream * _ptr = NULL;
14663
14664 if (result) {
14665 _ptr = new wxPyInputStream(result);
14666 }
14667 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14668 }
14669 return resultobj;
14670 fail:
14671 return NULL;
14672 }
14673
14674
14675 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14676 PyObject *resultobj = 0;
14677 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14678 wxInputStream *result = 0 ;
14679 void *argp1 = 0 ;
14680 int res1 = 0 ;
14681 PyObject *swig_obj[1] ;
14682
14683 if (!args) SWIG_fail;
14684 swig_obj[0] = args;
14685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14686 if (!SWIG_IsOK(res1)) {
14687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14688 }
14689 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14690 {
14691 PyThreadState* __tstate = wxPyBeginAllowThreads();
14692 result = (wxInputStream *)(arg1)->GetErrorStream();
14693 wxPyEndAllowThreads(__tstate);
14694 if (PyErr_Occurred()) SWIG_fail;
14695 }
14696 {
14697 wxPyInputStream * _ptr = NULL;
14698
14699 if (result) {
14700 _ptr = new wxPyInputStream(result);
14701 }
14702 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14703 }
14704 return resultobj;
14705 fail:
14706 return NULL;
14707 }
14708
14709
14710 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14711 PyObject *resultobj = 0;
14712 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14713 wxOutputStream *result = 0 ;
14714 void *argp1 = 0 ;
14715 int res1 = 0 ;
14716 PyObject *swig_obj[1] ;
14717
14718 if (!args) SWIG_fail;
14719 swig_obj[0] = args;
14720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14721 if (!SWIG_IsOK(res1)) {
14722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14723 }
14724 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14725 {
14726 PyThreadState* __tstate = wxPyBeginAllowThreads();
14727 result = (wxOutputStream *)(arg1)->GetOutputStream();
14728 wxPyEndAllowThreads(__tstate);
14729 if (PyErr_Occurred()) SWIG_fail;
14730 }
14731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14732 return resultobj;
14733 fail:
14734 return NULL;
14735 }
14736
14737
14738 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14739 PyObject *resultobj = 0;
14740 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14741 void *argp1 = 0 ;
14742 int res1 = 0 ;
14743 PyObject *swig_obj[1] ;
14744
14745 if (!args) SWIG_fail;
14746 swig_obj[0] = args;
14747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14748 if (!SWIG_IsOK(res1)) {
14749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14750 }
14751 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14752 {
14753 PyThreadState* __tstate = wxPyBeginAllowThreads();
14754 (arg1)->CloseOutput();
14755 wxPyEndAllowThreads(__tstate);
14756 if (PyErr_Occurred()) SWIG_fail;
14757 }
14758 resultobj = SWIG_Py_Void();
14759 return resultobj;
14760 fail:
14761 return NULL;
14762 }
14763
14764
14765 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14766 PyObject *resultobj = 0;
14767 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14768 bool result;
14769 void *argp1 = 0 ;
14770 int res1 = 0 ;
14771 PyObject *swig_obj[1] ;
14772
14773 if (!args) SWIG_fail;
14774 swig_obj[0] = args;
14775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14776 if (!SWIG_IsOK(res1)) {
14777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14778 }
14779 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14780 {
14781 PyThreadState* __tstate = wxPyBeginAllowThreads();
14782 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14783 wxPyEndAllowThreads(__tstate);
14784 if (PyErr_Occurred()) SWIG_fail;
14785 }
14786 {
14787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14788 }
14789 return resultobj;
14790 fail:
14791 return NULL;
14792 }
14793
14794
14795 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14796 PyObject *resultobj = 0;
14797 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14798 bool result;
14799 void *argp1 = 0 ;
14800 int res1 = 0 ;
14801 PyObject *swig_obj[1] ;
14802
14803 if (!args) SWIG_fail;
14804 swig_obj[0] = args;
14805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14806 if (!SWIG_IsOK(res1)) {
14807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14808 }
14809 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14810 {
14811 PyThreadState* __tstate = wxPyBeginAllowThreads();
14812 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14813 wxPyEndAllowThreads(__tstate);
14814 if (PyErr_Occurred()) SWIG_fail;
14815 }
14816 {
14817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14818 }
14819 return resultobj;
14820 fail:
14821 return NULL;
14822 }
14823
14824
14825 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14826 PyObject *resultobj = 0;
14827 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14828 bool result;
14829 void *argp1 = 0 ;
14830 int res1 = 0 ;
14831 PyObject *swig_obj[1] ;
14832
14833 if (!args) SWIG_fail;
14834 swig_obj[0] = args;
14835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14836 if (!SWIG_IsOK(res1)) {
14837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14838 }
14839 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14840 {
14841 PyThreadState* __tstate = wxPyBeginAllowThreads();
14842 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14843 wxPyEndAllowThreads(__tstate);
14844 if (PyErr_Occurred()) SWIG_fail;
14845 }
14846 {
14847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14848 }
14849 return resultobj;
14850 fail:
14851 return NULL;
14852 }
14853
14854
14855 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14856 PyObject *obj;
14857 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14858 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14859 return SWIG_Py_Void();
14860 }
14861
14862 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14863 return SWIG_Python_InitShadowInstance(args);
14864 }
14865
14866 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14867 PyObject *resultobj = 0;
14868 int arg1 = (int) 0 ;
14869 int arg2 = (int) 0 ;
14870 int arg3 = (int) 0 ;
14871 wxProcessEvent *result = 0 ;
14872 int val1 ;
14873 int ecode1 = 0 ;
14874 int val2 ;
14875 int ecode2 = 0 ;
14876 int val3 ;
14877 int ecode3 = 0 ;
14878 PyObject * obj0 = 0 ;
14879 PyObject * obj1 = 0 ;
14880 PyObject * obj2 = 0 ;
14881 char * kwnames[] = {
14882 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14883 };
14884
14885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14886 if (obj0) {
14887 ecode1 = SWIG_AsVal_int(obj0, &val1);
14888 if (!SWIG_IsOK(ecode1)) {
14889 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14890 }
14891 arg1 = static_cast< int >(val1);
14892 }
14893 if (obj1) {
14894 ecode2 = SWIG_AsVal_int(obj1, &val2);
14895 if (!SWIG_IsOK(ecode2)) {
14896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14897 }
14898 arg2 = static_cast< int >(val2);
14899 }
14900 if (obj2) {
14901 ecode3 = SWIG_AsVal_int(obj2, &val3);
14902 if (!SWIG_IsOK(ecode3)) {
14903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14904 }
14905 arg3 = static_cast< int >(val3);
14906 }
14907 {
14908 PyThreadState* __tstate = wxPyBeginAllowThreads();
14909 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14910 wxPyEndAllowThreads(__tstate);
14911 if (PyErr_Occurred()) SWIG_fail;
14912 }
14913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14914 return resultobj;
14915 fail:
14916 return NULL;
14917 }
14918
14919
14920 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14921 PyObject *resultobj = 0;
14922 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14923 int result;
14924 void *argp1 = 0 ;
14925 int res1 = 0 ;
14926 PyObject *swig_obj[1] ;
14927
14928 if (!args) SWIG_fail;
14929 swig_obj[0] = args;
14930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14931 if (!SWIG_IsOK(res1)) {
14932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14933 }
14934 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14935 {
14936 PyThreadState* __tstate = wxPyBeginAllowThreads();
14937 result = (int)(arg1)->GetPid();
14938 wxPyEndAllowThreads(__tstate);
14939 if (PyErr_Occurred()) SWIG_fail;
14940 }
14941 resultobj = SWIG_From_int(static_cast< int >(result));
14942 return resultobj;
14943 fail:
14944 return NULL;
14945 }
14946
14947
14948 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14949 PyObject *resultobj = 0;
14950 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14951 int result;
14952 void *argp1 = 0 ;
14953 int res1 = 0 ;
14954 PyObject *swig_obj[1] ;
14955
14956 if (!args) SWIG_fail;
14957 swig_obj[0] = args;
14958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14959 if (!SWIG_IsOK(res1)) {
14960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14961 }
14962 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14963 {
14964 PyThreadState* __tstate = wxPyBeginAllowThreads();
14965 result = (int)(arg1)->GetExitCode();
14966 wxPyEndAllowThreads(__tstate);
14967 if (PyErr_Occurred()) SWIG_fail;
14968 }
14969 resultobj = SWIG_From_int(static_cast< int >(result));
14970 return resultobj;
14971 fail:
14972 return NULL;
14973 }
14974
14975
14976 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14977 PyObject *resultobj = 0;
14978 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14979 int arg2 ;
14980 void *argp1 = 0 ;
14981 int res1 = 0 ;
14982 int val2 ;
14983 int ecode2 = 0 ;
14984 PyObject *swig_obj[2] ;
14985
14986 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14988 if (!SWIG_IsOK(res1)) {
14989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14990 }
14991 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14992 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14993 if (!SWIG_IsOK(ecode2)) {
14994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
14995 }
14996 arg2 = static_cast< int >(val2);
14997 if (arg1) (arg1)->m_pid = arg2;
14998
14999 resultobj = SWIG_Py_Void();
15000 return resultobj;
15001 fail:
15002 return NULL;
15003 }
15004
15005
15006 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15007 PyObject *resultobj = 0;
15008 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15009 int result;
15010 void *argp1 = 0 ;
15011 int res1 = 0 ;
15012 PyObject *swig_obj[1] ;
15013
15014 if (!args) SWIG_fail;
15015 swig_obj[0] = args;
15016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15017 if (!SWIG_IsOK(res1)) {
15018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15019 }
15020 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15021 result = (int) ((arg1)->m_pid);
15022 resultobj = SWIG_From_int(static_cast< int >(result));
15023 return resultobj;
15024 fail:
15025 return NULL;
15026 }
15027
15028
15029 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15030 PyObject *resultobj = 0;
15031 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15032 int arg2 ;
15033 void *argp1 = 0 ;
15034 int res1 = 0 ;
15035 int val2 ;
15036 int ecode2 = 0 ;
15037 PyObject *swig_obj[2] ;
15038
15039 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
15040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15041 if (!SWIG_IsOK(res1)) {
15042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15043 }
15044 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15045 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15046 if (!SWIG_IsOK(ecode2)) {
15047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
15048 }
15049 arg2 = static_cast< int >(val2);
15050 if (arg1) (arg1)->m_exitcode = arg2;
15051
15052 resultobj = SWIG_Py_Void();
15053 return resultobj;
15054 fail:
15055 return NULL;
15056 }
15057
15058
15059 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15060 PyObject *resultobj = 0;
15061 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15062 int result;
15063 void *argp1 = 0 ;
15064 int res1 = 0 ;
15065 PyObject *swig_obj[1] ;
15066
15067 if (!args) SWIG_fail;
15068 swig_obj[0] = args;
15069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15070 if (!SWIG_IsOK(res1)) {
15071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15072 }
15073 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15074 result = (int) ((arg1)->m_exitcode);
15075 resultobj = SWIG_From_int(static_cast< int >(result));
15076 return resultobj;
15077 fail:
15078 return NULL;
15079 }
15080
15081
15082 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15083 PyObject *obj;
15084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15085 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
15086 return SWIG_Py_Void();
15087 }
15088
15089 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15090 return SWIG_Python_InitShadowInstance(args);
15091 }
15092
15093 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15094 PyObject *resultobj = 0;
15095 wxString *arg1 = 0 ;
15096 int arg2 = (int) wxEXEC_ASYNC ;
15097 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15098 long result;
15099 bool temp1 = false ;
15100 int val2 ;
15101 int ecode2 = 0 ;
15102 void *argp3 = 0 ;
15103 int res3 = 0 ;
15104 PyObject * obj0 = 0 ;
15105 PyObject * obj1 = 0 ;
15106 PyObject * obj2 = 0 ;
15107 char * kwnames[] = {
15108 (char *) "command",(char *) "flags",(char *) "process", NULL
15109 };
15110
15111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15112 {
15113 arg1 = wxString_in_helper(obj0);
15114 if (arg1 == NULL) SWIG_fail;
15115 temp1 = true;
15116 }
15117 if (obj1) {
15118 ecode2 = SWIG_AsVal_int(obj1, &val2);
15119 if (!SWIG_IsOK(ecode2)) {
15120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15121 }
15122 arg2 = static_cast< int >(val2);
15123 }
15124 if (obj2) {
15125 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15126 if (!SWIG_IsOK(res3)) {
15127 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15128 }
15129 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15130 }
15131 {
15132 if (!wxPyCheckForApp()) SWIG_fail;
15133 PyThreadState* __tstate = wxPyBeginAllowThreads();
15134 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15135 wxPyEndAllowThreads(__tstate);
15136 if (PyErr_Occurred()) SWIG_fail;
15137 }
15138 resultobj = SWIG_From_long(static_cast< long >(result));
15139 {
15140 if (temp1)
15141 delete arg1;
15142 }
15143 return resultobj;
15144 fail:
15145 {
15146 if (temp1)
15147 delete arg1;
15148 }
15149 return NULL;
15150 }
15151
15152
15153 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15154 PyObject *resultobj = 0;
15155 long arg1 ;
15156 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15157 wxKillError *arg3 = (wxKillError *) 0 ;
15158 int arg4 = (int) wxKILL_NOCHILDREN ;
15159 int result;
15160 long val1 ;
15161 int ecode1 = 0 ;
15162 int val2 ;
15163 int ecode2 = 0 ;
15164 wxKillError temp3 ;
15165 int val4 ;
15166 int ecode4 = 0 ;
15167 PyObject * obj0 = 0 ;
15168 PyObject * obj1 = 0 ;
15169 PyObject * obj2 = 0 ;
15170 char * kwnames[] = {
15171 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15172 };
15173
15174 {
15175 arg3 = &temp3;
15176 }
15177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15178 ecode1 = SWIG_AsVal_long(obj0, &val1);
15179 if (!SWIG_IsOK(ecode1)) {
15180 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15181 }
15182 arg1 = static_cast< long >(val1);
15183 if (obj1) {
15184 ecode2 = SWIG_AsVal_int(obj1, &val2);
15185 if (!SWIG_IsOK(ecode2)) {
15186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15187 }
15188 arg2 = static_cast< wxSignal >(val2);
15189 }
15190 if (obj2) {
15191 ecode4 = SWIG_AsVal_int(obj2, &val4);
15192 if (!SWIG_IsOK(ecode4)) {
15193 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15194 }
15195 arg4 = static_cast< int >(val4);
15196 }
15197 {
15198 PyThreadState* __tstate = wxPyBeginAllowThreads();
15199 result = (int)wxKill(arg1,arg2,arg3,arg4);
15200 wxPyEndAllowThreads(__tstate);
15201 if (PyErr_Occurred()) SWIG_fail;
15202 }
15203 resultobj = SWIG_From_int(static_cast< int >(result));
15204 {
15205 PyObject* o;
15206 o = PyInt_FromLong((long) (*arg3));
15207
15208
15209
15210 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15211
15212 }
15213 return resultobj;
15214 fail:
15215 return NULL;
15216 }
15217
15218
15219 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15220 PyObject *resultobj = 0;
15221 int arg1 = (int) wxJOYSTICK1 ;
15222 wxJoystick *result = 0 ;
15223 int val1 ;
15224 int ecode1 = 0 ;
15225 PyObject * obj0 = 0 ;
15226 char * kwnames[] = {
15227 (char *) "joystick", NULL
15228 };
15229
15230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15231 if (obj0) {
15232 ecode1 = SWIG_AsVal_int(obj0, &val1);
15233 if (!SWIG_IsOK(ecode1)) {
15234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15235 }
15236 arg1 = static_cast< int >(val1);
15237 }
15238 {
15239 if (!wxPyCheckForApp()) SWIG_fail;
15240 PyThreadState* __tstate = wxPyBeginAllowThreads();
15241 result = (wxJoystick *)new wxJoystick(arg1);
15242 wxPyEndAllowThreads(__tstate);
15243 if (PyErr_Occurred()) SWIG_fail;
15244 }
15245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15246 return resultobj;
15247 fail:
15248 return NULL;
15249 }
15250
15251
15252 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15253 PyObject *resultobj = 0;
15254 wxJoystick *arg1 = (wxJoystick *) 0 ;
15255 void *argp1 = 0 ;
15256 int res1 = 0 ;
15257 PyObject *swig_obj[1] ;
15258
15259 if (!args) SWIG_fail;
15260 swig_obj[0] = args;
15261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15262 if (!SWIG_IsOK(res1)) {
15263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15264 }
15265 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15266 {
15267 PyThreadState* __tstate = wxPyBeginAllowThreads();
15268 delete arg1;
15269
15270 wxPyEndAllowThreads(__tstate);
15271 if (PyErr_Occurred()) SWIG_fail;
15272 }
15273 resultobj = SWIG_Py_Void();
15274 return resultobj;
15275 fail:
15276 return NULL;
15277 }
15278
15279
15280 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15281 PyObject *resultobj = 0;
15282 wxJoystick *arg1 = (wxJoystick *) 0 ;
15283 wxPoint result;
15284 void *argp1 = 0 ;
15285 int res1 = 0 ;
15286 PyObject *swig_obj[1] ;
15287
15288 if (!args) SWIG_fail;
15289 swig_obj[0] = args;
15290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15291 if (!SWIG_IsOK(res1)) {
15292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15293 }
15294 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15295 {
15296 PyThreadState* __tstate = wxPyBeginAllowThreads();
15297 result = (arg1)->GetPosition();
15298 wxPyEndAllowThreads(__tstate);
15299 if (PyErr_Occurred()) SWIG_fail;
15300 }
15301 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15302 return resultobj;
15303 fail:
15304 return NULL;
15305 }
15306
15307
15308 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15309 PyObject *resultobj = 0;
15310 wxJoystick *arg1 = (wxJoystick *) 0 ;
15311 int result;
15312 void *argp1 = 0 ;
15313 int res1 = 0 ;
15314 PyObject *swig_obj[1] ;
15315
15316 if (!args) SWIG_fail;
15317 swig_obj[0] = args;
15318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15319 if (!SWIG_IsOK(res1)) {
15320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15321 }
15322 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15323 {
15324 PyThreadState* __tstate = wxPyBeginAllowThreads();
15325 result = (int)(arg1)->GetZPosition();
15326 wxPyEndAllowThreads(__tstate);
15327 if (PyErr_Occurred()) SWIG_fail;
15328 }
15329 resultobj = SWIG_From_int(static_cast< int >(result));
15330 return resultobj;
15331 fail:
15332 return NULL;
15333 }
15334
15335
15336 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15337 PyObject *resultobj = 0;
15338 wxJoystick *arg1 = (wxJoystick *) 0 ;
15339 int result;
15340 void *argp1 = 0 ;
15341 int res1 = 0 ;
15342 PyObject *swig_obj[1] ;
15343
15344 if (!args) SWIG_fail;
15345 swig_obj[0] = args;
15346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15347 if (!SWIG_IsOK(res1)) {
15348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15349 }
15350 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15351 {
15352 PyThreadState* __tstate = wxPyBeginAllowThreads();
15353 result = (int)(arg1)->GetButtonState();
15354 wxPyEndAllowThreads(__tstate);
15355 if (PyErr_Occurred()) SWIG_fail;
15356 }
15357 resultobj = SWIG_From_int(static_cast< int >(result));
15358 return resultobj;
15359 fail:
15360 return NULL;
15361 }
15362
15363
15364 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15365 PyObject *resultobj = 0;
15366 wxJoystick *arg1 = (wxJoystick *) 0 ;
15367 int result;
15368 void *argp1 = 0 ;
15369 int res1 = 0 ;
15370 PyObject *swig_obj[1] ;
15371
15372 if (!args) SWIG_fail;
15373 swig_obj[0] = args;
15374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15375 if (!SWIG_IsOK(res1)) {
15376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15377 }
15378 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15379 {
15380 PyThreadState* __tstate = wxPyBeginAllowThreads();
15381 result = (int)(arg1)->GetPOVPosition();
15382 wxPyEndAllowThreads(__tstate);
15383 if (PyErr_Occurred()) SWIG_fail;
15384 }
15385 resultobj = SWIG_From_int(static_cast< int >(result));
15386 return resultobj;
15387 fail:
15388 return NULL;
15389 }
15390
15391
15392 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15393 PyObject *resultobj = 0;
15394 wxJoystick *arg1 = (wxJoystick *) 0 ;
15395 int result;
15396 void *argp1 = 0 ;
15397 int res1 = 0 ;
15398 PyObject *swig_obj[1] ;
15399
15400 if (!args) SWIG_fail;
15401 swig_obj[0] = args;
15402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15403 if (!SWIG_IsOK(res1)) {
15404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15405 }
15406 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15407 {
15408 PyThreadState* __tstate = wxPyBeginAllowThreads();
15409 result = (int)(arg1)->GetPOVCTSPosition();
15410 wxPyEndAllowThreads(__tstate);
15411 if (PyErr_Occurred()) SWIG_fail;
15412 }
15413 resultobj = SWIG_From_int(static_cast< int >(result));
15414 return resultobj;
15415 fail:
15416 return NULL;
15417 }
15418
15419
15420 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15421 PyObject *resultobj = 0;
15422 wxJoystick *arg1 = (wxJoystick *) 0 ;
15423 int result;
15424 void *argp1 = 0 ;
15425 int res1 = 0 ;
15426 PyObject *swig_obj[1] ;
15427
15428 if (!args) SWIG_fail;
15429 swig_obj[0] = args;
15430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15431 if (!SWIG_IsOK(res1)) {
15432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15433 }
15434 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15435 {
15436 PyThreadState* __tstate = wxPyBeginAllowThreads();
15437 result = (int)(arg1)->GetRudderPosition();
15438 wxPyEndAllowThreads(__tstate);
15439 if (PyErr_Occurred()) SWIG_fail;
15440 }
15441 resultobj = SWIG_From_int(static_cast< int >(result));
15442 return resultobj;
15443 fail:
15444 return NULL;
15445 }
15446
15447
15448 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15449 PyObject *resultobj = 0;
15450 wxJoystick *arg1 = (wxJoystick *) 0 ;
15451 int result;
15452 void *argp1 = 0 ;
15453 int res1 = 0 ;
15454 PyObject *swig_obj[1] ;
15455
15456 if (!args) SWIG_fail;
15457 swig_obj[0] = args;
15458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15459 if (!SWIG_IsOK(res1)) {
15460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15461 }
15462 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15463 {
15464 PyThreadState* __tstate = wxPyBeginAllowThreads();
15465 result = (int)(arg1)->GetUPosition();
15466 wxPyEndAllowThreads(__tstate);
15467 if (PyErr_Occurred()) SWIG_fail;
15468 }
15469 resultobj = SWIG_From_int(static_cast< int >(result));
15470 return resultobj;
15471 fail:
15472 return NULL;
15473 }
15474
15475
15476 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15477 PyObject *resultobj = 0;
15478 wxJoystick *arg1 = (wxJoystick *) 0 ;
15479 int result;
15480 void *argp1 = 0 ;
15481 int res1 = 0 ;
15482 PyObject *swig_obj[1] ;
15483
15484 if (!args) SWIG_fail;
15485 swig_obj[0] = args;
15486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15487 if (!SWIG_IsOK(res1)) {
15488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15489 }
15490 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15491 {
15492 PyThreadState* __tstate = wxPyBeginAllowThreads();
15493 result = (int)(arg1)->GetVPosition();
15494 wxPyEndAllowThreads(__tstate);
15495 if (PyErr_Occurred()) SWIG_fail;
15496 }
15497 resultobj = SWIG_From_int(static_cast< int >(result));
15498 return resultobj;
15499 fail:
15500 return NULL;
15501 }
15502
15503
15504 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15505 PyObject *resultobj = 0;
15506 wxJoystick *arg1 = (wxJoystick *) 0 ;
15507 int result;
15508 void *argp1 = 0 ;
15509 int res1 = 0 ;
15510 PyObject *swig_obj[1] ;
15511
15512 if (!args) SWIG_fail;
15513 swig_obj[0] = args;
15514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15515 if (!SWIG_IsOK(res1)) {
15516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15517 }
15518 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15519 {
15520 PyThreadState* __tstate = wxPyBeginAllowThreads();
15521 result = (int)(arg1)->GetMovementThreshold();
15522 wxPyEndAllowThreads(__tstate);
15523 if (PyErr_Occurred()) SWIG_fail;
15524 }
15525 resultobj = SWIG_From_int(static_cast< int >(result));
15526 return resultobj;
15527 fail:
15528 return NULL;
15529 }
15530
15531
15532 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15533 PyObject *resultobj = 0;
15534 wxJoystick *arg1 = (wxJoystick *) 0 ;
15535 int arg2 ;
15536 void *argp1 = 0 ;
15537 int res1 = 0 ;
15538 int val2 ;
15539 int ecode2 = 0 ;
15540 PyObject * obj0 = 0 ;
15541 PyObject * obj1 = 0 ;
15542 char * kwnames[] = {
15543 (char *) "self",(char *) "threshold", NULL
15544 };
15545
15546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15548 if (!SWIG_IsOK(res1)) {
15549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15550 }
15551 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15552 ecode2 = SWIG_AsVal_int(obj1, &val2);
15553 if (!SWIG_IsOK(ecode2)) {
15554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15555 }
15556 arg2 = static_cast< int >(val2);
15557 {
15558 PyThreadState* __tstate = wxPyBeginAllowThreads();
15559 (arg1)->SetMovementThreshold(arg2);
15560 wxPyEndAllowThreads(__tstate);
15561 if (PyErr_Occurred()) SWIG_fail;
15562 }
15563 resultobj = SWIG_Py_Void();
15564 return resultobj;
15565 fail:
15566 return NULL;
15567 }
15568
15569
15570 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15571 PyObject *resultobj = 0;
15572 wxJoystick *arg1 = (wxJoystick *) 0 ;
15573 bool result;
15574 void *argp1 = 0 ;
15575 int res1 = 0 ;
15576 PyObject *swig_obj[1] ;
15577
15578 if (!args) SWIG_fail;
15579 swig_obj[0] = args;
15580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15581 if (!SWIG_IsOK(res1)) {
15582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15583 }
15584 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15585 {
15586 PyThreadState* __tstate = wxPyBeginAllowThreads();
15587 result = (bool)(arg1)->IsOk();
15588 wxPyEndAllowThreads(__tstate);
15589 if (PyErr_Occurred()) SWIG_fail;
15590 }
15591 {
15592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15593 }
15594 return resultobj;
15595 fail:
15596 return NULL;
15597 }
15598
15599
15600 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15601 PyObject *resultobj = 0;
15602 wxJoystick *arg1 = (wxJoystick *) 0 ;
15603 int result;
15604 void *argp1 = 0 ;
15605 int res1 = 0 ;
15606 PyObject *swig_obj[1] ;
15607
15608 if (!args) SWIG_fail;
15609 swig_obj[0] = args;
15610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15611 if (!SWIG_IsOK(res1)) {
15612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15613 }
15614 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15615 {
15616 PyThreadState* __tstate = wxPyBeginAllowThreads();
15617 result = (int)(arg1)->GetNumberJoysticks();
15618 wxPyEndAllowThreads(__tstate);
15619 if (PyErr_Occurred()) SWIG_fail;
15620 }
15621 resultobj = SWIG_From_int(static_cast< int >(result));
15622 return resultobj;
15623 fail:
15624 return NULL;
15625 }
15626
15627
15628 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15629 PyObject *resultobj = 0;
15630 wxJoystick *arg1 = (wxJoystick *) 0 ;
15631 int result;
15632 void *argp1 = 0 ;
15633 int res1 = 0 ;
15634 PyObject *swig_obj[1] ;
15635
15636 if (!args) SWIG_fail;
15637 swig_obj[0] = args;
15638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15639 if (!SWIG_IsOK(res1)) {
15640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15641 }
15642 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15643 {
15644 PyThreadState* __tstate = wxPyBeginAllowThreads();
15645 result = (int)(arg1)->GetManufacturerId();
15646 wxPyEndAllowThreads(__tstate);
15647 if (PyErr_Occurred()) SWIG_fail;
15648 }
15649 resultobj = SWIG_From_int(static_cast< int >(result));
15650 return resultobj;
15651 fail:
15652 return NULL;
15653 }
15654
15655
15656 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15657 PyObject *resultobj = 0;
15658 wxJoystick *arg1 = (wxJoystick *) 0 ;
15659 int result;
15660 void *argp1 = 0 ;
15661 int res1 = 0 ;
15662 PyObject *swig_obj[1] ;
15663
15664 if (!args) SWIG_fail;
15665 swig_obj[0] = args;
15666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15667 if (!SWIG_IsOK(res1)) {
15668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15669 }
15670 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15671 {
15672 PyThreadState* __tstate = wxPyBeginAllowThreads();
15673 result = (int)(arg1)->GetProductId();
15674 wxPyEndAllowThreads(__tstate);
15675 if (PyErr_Occurred()) SWIG_fail;
15676 }
15677 resultobj = SWIG_From_int(static_cast< int >(result));
15678 return resultobj;
15679 fail:
15680 return NULL;
15681 }
15682
15683
15684 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15685 PyObject *resultobj = 0;
15686 wxJoystick *arg1 = (wxJoystick *) 0 ;
15687 wxString result;
15688 void *argp1 = 0 ;
15689 int res1 = 0 ;
15690 PyObject *swig_obj[1] ;
15691
15692 if (!args) SWIG_fail;
15693 swig_obj[0] = args;
15694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15695 if (!SWIG_IsOK(res1)) {
15696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15697 }
15698 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15699 {
15700 PyThreadState* __tstate = wxPyBeginAllowThreads();
15701 result = (arg1)->GetProductName();
15702 wxPyEndAllowThreads(__tstate);
15703 if (PyErr_Occurred()) SWIG_fail;
15704 }
15705 {
15706 #if wxUSE_UNICODE
15707 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15708 #else
15709 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15710 #endif
15711 }
15712 return resultobj;
15713 fail:
15714 return NULL;
15715 }
15716
15717
15718 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15719 PyObject *resultobj = 0;
15720 wxJoystick *arg1 = (wxJoystick *) 0 ;
15721 int result;
15722 void *argp1 = 0 ;
15723 int res1 = 0 ;
15724 PyObject *swig_obj[1] ;
15725
15726 if (!args) SWIG_fail;
15727 swig_obj[0] = args;
15728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15729 if (!SWIG_IsOK(res1)) {
15730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15731 }
15732 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15733 {
15734 PyThreadState* __tstate = wxPyBeginAllowThreads();
15735 result = (int)(arg1)->GetXMin();
15736 wxPyEndAllowThreads(__tstate);
15737 if (PyErr_Occurred()) SWIG_fail;
15738 }
15739 resultobj = SWIG_From_int(static_cast< int >(result));
15740 return resultobj;
15741 fail:
15742 return NULL;
15743 }
15744
15745
15746 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15747 PyObject *resultobj = 0;
15748 wxJoystick *arg1 = (wxJoystick *) 0 ;
15749 int result;
15750 void *argp1 = 0 ;
15751 int res1 = 0 ;
15752 PyObject *swig_obj[1] ;
15753
15754 if (!args) SWIG_fail;
15755 swig_obj[0] = args;
15756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15757 if (!SWIG_IsOK(res1)) {
15758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15759 }
15760 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15761 {
15762 PyThreadState* __tstate = wxPyBeginAllowThreads();
15763 result = (int)(arg1)->GetYMin();
15764 wxPyEndAllowThreads(__tstate);
15765 if (PyErr_Occurred()) SWIG_fail;
15766 }
15767 resultobj = SWIG_From_int(static_cast< int >(result));
15768 return resultobj;
15769 fail:
15770 return NULL;
15771 }
15772
15773
15774 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15775 PyObject *resultobj = 0;
15776 wxJoystick *arg1 = (wxJoystick *) 0 ;
15777 int result;
15778 void *argp1 = 0 ;
15779 int res1 = 0 ;
15780 PyObject *swig_obj[1] ;
15781
15782 if (!args) SWIG_fail;
15783 swig_obj[0] = args;
15784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15785 if (!SWIG_IsOK(res1)) {
15786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15787 }
15788 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15789 {
15790 PyThreadState* __tstate = wxPyBeginAllowThreads();
15791 result = (int)(arg1)->GetZMin();
15792 wxPyEndAllowThreads(__tstate);
15793 if (PyErr_Occurred()) SWIG_fail;
15794 }
15795 resultobj = SWIG_From_int(static_cast< int >(result));
15796 return resultobj;
15797 fail:
15798 return NULL;
15799 }
15800
15801
15802 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15803 PyObject *resultobj = 0;
15804 wxJoystick *arg1 = (wxJoystick *) 0 ;
15805 int result;
15806 void *argp1 = 0 ;
15807 int res1 = 0 ;
15808 PyObject *swig_obj[1] ;
15809
15810 if (!args) SWIG_fail;
15811 swig_obj[0] = args;
15812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15813 if (!SWIG_IsOK(res1)) {
15814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15815 }
15816 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15817 {
15818 PyThreadState* __tstate = wxPyBeginAllowThreads();
15819 result = (int)(arg1)->GetXMax();
15820 wxPyEndAllowThreads(__tstate);
15821 if (PyErr_Occurred()) SWIG_fail;
15822 }
15823 resultobj = SWIG_From_int(static_cast< int >(result));
15824 return resultobj;
15825 fail:
15826 return NULL;
15827 }
15828
15829
15830 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15831 PyObject *resultobj = 0;
15832 wxJoystick *arg1 = (wxJoystick *) 0 ;
15833 int result;
15834 void *argp1 = 0 ;
15835 int res1 = 0 ;
15836 PyObject *swig_obj[1] ;
15837
15838 if (!args) SWIG_fail;
15839 swig_obj[0] = args;
15840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15841 if (!SWIG_IsOK(res1)) {
15842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15843 }
15844 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15845 {
15846 PyThreadState* __tstate = wxPyBeginAllowThreads();
15847 result = (int)(arg1)->GetYMax();
15848 wxPyEndAllowThreads(__tstate);
15849 if (PyErr_Occurred()) SWIG_fail;
15850 }
15851 resultobj = SWIG_From_int(static_cast< int >(result));
15852 return resultobj;
15853 fail:
15854 return NULL;
15855 }
15856
15857
15858 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15859 PyObject *resultobj = 0;
15860 wxJoystick *arg1 = (wxJoystick *) 0 ;
15861 int result;
15862 void *argp1 = 0 ;
15863 int res1 = 0 ;
15864 PyObject *swig_obj[1] ;
15865
15866 if (!args) SWIG_fail;
15867 swig_obj[0] = args;
15868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15869 if (!SWIG_IsOK(res1)) {
15870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15871 }
15872 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15873 {
15874 PyThreadState* __tstate = wxPyBeginAllowThreads();
15875 result = (int)(arg1)->GetZMax();
15876 wxPyEndAllowThreads(__tstate);
15877 if (PyErr_Occurred()) SWIG_fail;
15878 }
15879 resultobj = SWIG_From_int(static_cast< int >(result));
15880 return resultobj;
15881 fail:
15882 return NULL;
15883 }
15884
15885
15886 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15887 PyObject *resultobj = 0;
15888 wxJoystick *arg1 = (wxJoystick *) 0 ;
15889 int result;
15890 void *argp1 = 0 ;
15891 int res1 = 0 ;
15892 PyObject *swig_obj[1] ;
15893
15894 if (!args) SWIG_fail;
15895 swig_obj[0] = args;
15896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15897 if (!SWIG_IsOK(res1)) {
15898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15899 }
15900 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15901 {
15902 PyThreadState* __tstate = wxPyBeginAllowThreads();
15903 result = (int)(arg1)->GetNumberButtons();
15904 wxPyEndAllowThreads(__tstate);
15905 if (PyErr_Occurred()) SWIG_fail;
15906 }
15907 resultobj = SWIG_From_int(static_cast< int >(result));
15908 return resultobj;
15909 fail:
15910 return NULL;
15911 }
15912
15913
15914 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15915 PyObject *resultobj = 0;
15916 wxJoystick *arg1 = (wxJoystick *) 0 ;
15917 int result;
15918 void *argp1 = 0 ;
15919 int res1 = 0 ;
15920 PyObject *swig_obj[1] ;
15921
15922 if (!args) SWIG_fail;
15923 swig_obj[0] = args;
15924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15925 if (!SWIG_IsOK(res1)) {
15926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15927 }
15928 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15929 {
15930 PyThreadState* __tstate = wxPyBeginAllowThreads();
15931 result = (int)(arg1)->GetNumberAxes();
15932 wxPyEndAllowThreads(__tstate);
15933 if (PyErr_Occurred()) SWIG_fail;
15934 }
15935 resultobj = SWIG_From_int(static_cast< int >(result));
15936 return resultobj;
15937 fail:
15938 return NULL;
15939 }
15940
15941
15942 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15943 PyObject *resultobj = 0;
15944 wxJoystick *arg1 = (wxJoystick *) 0 ;
15945 int result;
15946 void *argp1 = 0 ;
15947 int res1 = 0 ;
15948 PyObject *swig_obj[1] ;
15949
15950 if (!args) SWIG_fail;
15951 swig_obj[0] = args;
15952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15953 if (!SWIG_IsOK(res1)) {
15954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15955 }
15956 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15957 {
15958 PyThreadState* __tstate = wxPyBeginAllowThreads();
15959 result = (int)(arg1)->GetMaxButtons();
15960 wxPyEndAllowThreads(__tstate);
15961 if (PyErr_Occurred()) SWIG_fail;
15962 }
15963 resultobj = SWIG_From_int(static_cast< int >(result));
15964 return resultobj;
15965 fail:
15966 return NULL;
15967 }
15968
15969
15970 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15971 PyObject *resultobj = 0;
15972 wxJoystick *arg1 = (wxJoystick *) 0 ;
15973 int result;
15974 void *argp1 = 0 ;
15975 int res1 = 0 ;
15976 PyObject *swig_obj[1] ;
15977
15978 if (!args) SWIG_fail;
15979 swig_obj[0] = args;
15980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15981 if (!SWIG_IsOK(res1)) {
15982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15983 }
15984 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15985 {
15986 PyThreadState* __tstate = wxPyBeginAllowThreads();
15987 result = (int)(arg1)->GetMaxAxes();
15988 wxPyEndAllowThreads(__tstate);
15989 if (PyErr_Occurred()) SWIG_fail;
15990 }
15991 resultobj = SWIG_From_int(static_cast< int >(result));
15992 return resultobj;
15993 fail:
15994 return NULL;
15995 }
15996
15997
15998 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15999 PyObject *resultobj = 0;
16000 wxJoystick *arg1 = (wxJoystick *) 0 ;
16001 int result;
16002 void *argp1 = 0 ;
16003 int res1 = 0 ;
16004 PyObject *swig_obj[1] ;
16005
16006 if (!args) SWIG_fail;
16007 swig_obj[0] = args;
16008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16009 if (!SWIG_IsOK(res1)) {
16010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16011 }
16012 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16013 {
16014 PyThreadState* __tstate = wxPyBeginAllowThreads();
16015 result = (int)(arg1)->GetPollingMin();
16016 wxPyEndAllowThreads(__tstate);
16017 if (PyErr_Occurred()) SWIG_fail;
16018 }
16019 resultobj = SWIG_From_int(static_cast< int >(result));
16020 return resultobj;
16021 fail:
16022 return NULL;
16023 }
16024
16025
16026 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16027 PyObject *resultobj = 0;
16028 wxJoystick *arg1 = (wxJoystick *) 0 ;
16029 int result;
16030 void *argp1 = 0 ;
16031 int res1 = 0 ;
16032 PyObject *swig_obj[1] ;
16033
16034 if (!args) SWIG_fail;
16035 swig_obj[0] = args;
16036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16037 if (!SWIG_IsOK(res1)) {
16038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16039 }
16040 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16041 {
16042 PyThreadState* __tstate = wxPyBeginAllowThreads();
16043 result = (int)(arg1)->GetPollingMax();
16044 wxPyEndAllowThreads(__tstate);
16045 if (PyErr_Occurred()) SWIG_fail;
16046 }
16047 resultobj = SWIG_From_int(static_cast< int >(result));
16048 return resultobj;
16049 fail:
16050 return NULL;
16051 }
16052
16053
16054 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16055 PyObject *resultobj = 0;
16056 wxJoystick *arg1 = (wxJoystick *) 0 ;
16057 int result;
16058 void *argp1 = 0 ;
16059 int res1 = 0 ;
16060 PyObject *swig_obj[1] ;
16061
16062 if (!args) SWIG_fail;
16063 swig_obj[0] = args;
16064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16065 if (!SWIG_IsOK(res1)) {
16066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16067 }
16068 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16069 {
16070 PyThreadState* __tstate = wxPyBeginAllowThreads();
16071 result = (int)(arg1)->GetRudderMin();
16072 wxPyEndAllowThreads(__tstate);
16073 if (PyErr_Occurred()) SWIG_fail;
16074 }
16075 resultobj = SWIG_From_int(static_cast< int >(result));
16076 return resultobj;
16077 fail:
16078 return NULL;
16079 }
16080
16081
16082 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16083 PyObject *resultobj = 0;
16084 wxJoystick *arg1 = (wxJoystick *) 0 ;
16085 int result;
16086 void *argp1 = 0 ;
16087 int res1 = 0 ;
16088 PyObject *swig_obj[1] ;
16089
16090 if (!args) SWIG_fail;
16091 swig_obj[0] = args;
16092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16093 if (!SWIG_IsOK(res1)) {
16094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16095 }
16096 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16097 {
16098 PyThreadState* __tstate = wxPyBeginAllowThreads();
16099 result = (int)(arg1)->GetRudderMax();
16100 wxPyEndAllowThreads(__tstate);
16101 if (PyErr_Occurred()) SWIG_fail;
16102 }
16103 resultobj = SWIG_From_int(static_cast< int >(result));
16104 return resultobj;
16105 fail:
16106 return NULL;
16107 }
16108
16109
16110 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16111 PyObject *resultobj = 0;
16112 wxJoystick *arg1 = (wxJoystick *) 0 ;
16113 int result;
16114 void *argp1 = 0 ;
16115 int res1 = 0 ;
16116 PyObject *swig_obj[1] ;
16117
16118 if (!args) SWIG_fail;
16119 swig_obj[0] = args;
16120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16121 if (!SWIG_IsOK(res1)) {
16122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16123 }
16124 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16125 {
16126 PyThreadState* __tstate = wxPyBeginAllowThreads();
16127 result = (int)(arg1)->GetUMin();
16128 wxPyEndAllowThreads(__tstate);
16129 if (PyErr_Occurred()) SWIG_fail;
16130 }
16131 resultobj = SWIG_From_int(static_cast< int >(result));
16132 return resultobj;
16133 fail:
16134 return NULL;
16135 }
16136
16137
16138 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16139 PyObject *resultobj = 0;
16140 wxJoystick *arg1 = (wxJoystick *) 0 ;
16141 int result;
16142 void *argp1 = 0 ;
16143 int res1 = 0 ;
16144 PyObject *swig_obj[1] ;
16145
16146 if (!args) SWIG_fail;
16147 swig_obj[0] = args;
16148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16149 if (!SWIG_IsOK(res1)) {
16150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16151 }
16152 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16153 {
16154 PyThreadState* __tstate = wxPyBeginAllowThreads();
16155 result = (int)(arg1)->GetUMax();
16156 wxPyEndAllowThreads(__tstate);
16157 if (PyErr_Occurred()) SWIG_fail;
16158 }
16159 resultobj = SWIG_From_int(static_cast< int >(result));
16160 return resultobj;
16161 fail:
16162 return NULL;
16163 }
16164
16165
16166 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16167 PyObject *resultobj = 0;
16168 wxJoystick *arg1 = (wxJoystick *) 0 ;
16169 int result;
16170 void *argp1 = 0 ;
16171 int res1 = 0 ;
16172 PyObject *swig_obj[1] ;
16173
16174 if (!args) SWIG_fail;
16175 swig_obj[0] = args;
16176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16177 if (!SWIG_IsOK(res1)) {
16178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16179 }
16180 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16181 {
16182 PyThreadState* __tstate = wxPyBeginAllowThreads();
16183 result = (int)(arg1)->GetVMin();
16184 wxPyEndAllowThreads(__tstate);
16185 if (PyErr_Occurred()) SWIG_fail;
16186 }
16187 resultobj = SWIG_From_int(static_cast< int >(result));
16188 return resultobj;
16189 fail:
16190 return NULL;
16191 }
16192
16193
16194 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16195 PyObject *resultobj = 0;
16196 wxJoystick *arg1 = (wxJoystick *) 0 ;
16197 int result;
16198 void *argp1 = 0 ;
16199 int res1 = 0 ;
16200 PyObject *swig_obj[1] ;
16201
16202 if (!args) SWIG_fail;
16203 swig_obj[0] = args;
16204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16205 if (!SWIG_IsOK(res1)) {
16206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16207 }
16208 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16209 {
16210 PyThreadState* __tstate = wxPyBeginAllowThreads();
16211 result = (int)(arg1)->GetVMax();
16212 wxPyEndAllowThreads(__tstate);
16213 if (PyErr_Occurred()) SWIG_fail;
16214 }
16215 resultobj = SWIG_From_int(static_cast< int >(result));
16216 return resultobj;
16217 fail:
16218 return NULL;
16219 }
16220
16221
16222 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16223 PyObject *resultobj = 0;
16224 wxJoystick *arg1 = (wxJoystick *) 0 ;
16225 bool result;
16226 void *argp1 = 0 ;
16227 int res1 = 0 ;
16228 PyObject *swig_obj[1] ;
16229
16230 if (!args) SWIG_fail;
16231 swig_obj[0] = args;
16232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16233 if (!SWIG_IsOK(res1)) {
16234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16235 }
16236 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16237 {
16238 PyThreadState* __tstate = wxPyBeginAllowThreads();
16239 result = (bool)(arg1)->HasRudder();
16240 wxPyEndAllowThreads(__tstate);
16241 if (PyErr_Occurred()) SWIG_fail;
16242 }
16243 {
16244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16245 }
16246 return resultobj;
16247 fail:
16248 return NULL;
16249 }
16250
16251
16252 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16253 PyObject *resultobj = 0;
16254 wxJoystick *arg1 = (wxJoystick *) 0 ;
16255 bool result;
16256 void *argp1 = 0 ;
16257 int res1 = 0 ;
16258 PyObject *swig_obj[1] ;
16259
16260 if (!args) SWIG_fail;
16261 swig_obj[0] = args;
16262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16263 if (!SWIG_IsOK(res1)) {
16264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16265 }
16266 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16267 {
16268 PyThreadState* __tstate = wxPyBeginAllowThreads();
16269 result = (bool)(arg1)->HasZ();
16270 wxPyEndAllowThreads(__tstate);
16271 if (PyErr_Occurred()) SWIG_fail;
16272 }
16273 {
16274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16275 }
16276 return resultobj;
16277 fail:
16278 return NULL;
16279 }
16280
16281
16282 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16283 PyObject *resultobj = 0;
16284 wxJoystick *arg1 = (wxJoystick *) 0 ;
16285 bool result;
16286 void *argp1 = 0 ;
16287 int res1 = 0 ;
16288 PyObject *swig_obj[1] ;
16289
16290 if (!args) SWIG_fail;
16291 swig_obj[0] = args;
16292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16293 if (!SWIG_IsOK(res1)) {
16294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16295 }
16296 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16297 {
16298 PyThreadState* __tstate = wxPyBeginAllowThreads();
16299 result = (bool)(arg1)->HasU();
16300 wxPyEndAllowThreads(__tstate);
16301 if (PyErr_Occurred()) SWIG_fail;
16302 }
16303 {
16304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16305 }
16306 return resultobj;
16307 fail:
16308 return NULL;
16309 }
16310
16311
16312 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16313 PyObject *resultobj = 0;
16314 wxJoystick *arg1 = (wxJoystick *) 0 ;
16315 bool result;
16316 void *argp1 = 0 ;
16317 int res1 = 0 ;
16318 PyObject *swig_obj[1] ;
16319
16320 if (!args) SWIG_fail;
16321 swig_obj[0] = args;
16322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16323 if (!SWIG_IsOK(res1)) {
16324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16325 }
16326 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16327 {
16328 PyThreadState* __tstate = wxPyBeginAllowThreads();
16329 result = (bool)(arg1)->HasV();
16330 wxPyEndAllowThreads(__tstate);
16331 if (PyErr_Occurred()) SWIG_fail;
16332 }
16333 {
16334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16335 }
16336 return resultobj;
16337 fail:
16338 return NULL;
16339 }
16340
16341
16342 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16343 PyObject *resultobj = 0;
16344 wxJoystick *arg1 = (wxJoystick *) 0 ;
16345 bool result;
16346 void *argp1 = 0 ;
16347 int res1 = 0 ;
16348 PyObject *swig_obj[1] ;
16349
16350 if (!args) SWIG_fail;
16351 swig_obj[0] = args;
16352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16353 if (!SWIG_IsOK(res1)) {
16354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16355 }
16356 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16357 {
16358 PyThreadState* __tstate = wxPyBeginAllowThreads();
16359 result = (bool)(arg1)->HasPOV();
16360 wxPyEndAllowThreads(__tstate);
16361 if (PyErr_Occurred()) SWIG_fail;
16362 }
16363 {
16364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16365 }
16366 return resultobj;
16367 fail:
16368 return NULL;
16369 }
16370
16371
16372 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16373 PyObject *resultobj = 0;
16374 wxJoystick *arg1 = (wxJoystick *) 0 ;
16375 bool result;
16376 void *argp1 = 0 ;
16377 int res1 = 0 ;
16378 PyObject *swig_obj[1] ;
16379
16380 if (!args) SWIG_fail;
16381 swig_obj[0] = args;
16382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16383 if (!SWIG_IsOK(res1)) {
16384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16385 }
16386 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16387 {
16388 PyThreadState* __tstate = wxPyBeginAllowThreads();
16389 result = (bool)(arg1)->HasPOV4Dir();
16390 wxPyEndAllowThreads(__tstate);
16391 if (PyErr_Occurred()) SWIG_fail;
16392 }
16393 {
16394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16395 }
16396 return resultobj;
16397 fail:
16398 return NULL;
16399 }
16400
16401
16402 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16403 PyObject *resultobj = 0;
16404 wxJoystick *arg1 = (wxJoystick *) 0 ;
16405 bool result;
16406 void *argp1 = 0 ;
16407 int res1 = 0 ;
16408 PyObject *swig_obj[1] ;
16409
16410 if (!args) SWIG_fail;
16411 swig_obj[0] = args;
16412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16413 if (!SWIG_IsOK(res1)) {
16414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16415 }
16416 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16417 {
16418 PyThreadState* __tstate = wxPyBeginAllowThreads();
16419 result = (bool)(arg1)->HasPOVCTS();
16420 wxPyEndAllowThreads(__tstate);
16421 if (PyErr_Occurred()) SWIG_fail;
16422 }
16423 {
16424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16425 }
16426 return resultobj;
16427 fail:
16428 return NULL;
16429 }
16430
16431
16432 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16433 PyObject *resultobj = 0;
16434 wxJoystick *arg1 = (wxJoystick *) 0 ;
16435 wxWindow *arg2 = (wxWindow *) 0 ;
16436 int arg3 = (int) 0 ;
16437 bool result;
16438 void *argp1 = 0 ;
16439 int res1 = 0 ;
16440 void *argp2 = 0 ;
16441 int res2 = 0 ;
16442 int val3 ;
16443 int ecode3 = 0 ;
16444 PyObject * obj0 = 0 ;
16445 PyObject * obj1 = 0 ;
16446 PyObject * obj2 = 0 ;
16447 char * kwnames[] = {
16448 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16449 };
16450
16451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16453 if (!SWIG_IsOK(res1)) {
16454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16455 }
16456 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16457 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16458 if (!SWIG_IsOK(res2)) {
16459 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16460 }
16461 arg2 = reinterpret_cast< wxWindow * >(argp2);
16462 if (obj2) {
16463 ecode3 = SWIG_AsVal_int(obj2, &val3);
16464 if (!SWIG_IsOK(ecode3)) {
16465 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16466 }
16467 arg3 = static_cast< int >(val3);
16468 }
16469 {
16470 PyThreadState* __tstate = wxPyBeginAllowThreads();
16471 result = (bool)(arg1)->SetCapture(arg2,arg3);
16472 wxPyEndAllowThreads(__tstate);
16473 if (PyErr_Occurred()) SWIG_fail;
16474 }
16475 {
16476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16477 }
16478 return resultobj;
16479 fail:
16480 return NULL;
16481 }
16482
16483
16484 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16485 PyObject *resultobj = 0;
16486 wxJoystick *arg1 = (wxJoystick *) 0 ;
16487 bool result;
16488 void *argp1 = 0 ;
16489 int res1 = 0 ;
16490 PyObject *swig_obj[1] ;
16491
16492 if (!args) SWIG_fail;
16493 swig_obj[0] = args;
16494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16495 if (!SWIG_IsOK(res1)) {
16496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16497 }
16498 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16499 {
16500 PyThreadState* __tstate = wxPyBeginAllowThreads();
16501 result = (bool)(arg1)->ReleaseCapture();
16502 wxPyEndAllowThreads(__tstate);
16503 if (PyErr_Occurred()) SWIG_fail;
16504 }
16505 {
16506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16507 }
16508 return resultobj;
16509 fail:
16510 return NULL;
16511 }
16512
16513
16514 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16515 PyObject *obj;
16516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16517 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16518 return SWIG_Py_Void();
16519 }
16520
16521 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16522 return SWIG_Python_InitShadowInstance(args);
16523 }
16524
16525 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16526 PyObject *resultobj = 0;
16527 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16528 int arg2 = (int) 0 ;
16529 int arg3 = (int) wxJOYSTICK1 ;
16530 int arg4 = (int) 0 ;
16531 wxJoystickEvent *result = 0 ;
16532 int val1 ;
16533 int ecode1 = 0 ;
16534 int val2 ;
16535 int ecode2 = 0 ;
16536 int val3 ;
16537 int ecode3 = 0 ;
16538 int val4 ;
16539 int ecode4 = 0 ;
16540 PyObject * obj0 = 0 ;
16541 PyObject * obj1 = 0 ;
16542 PyObject * obj2 = 0 ;
16543 PyObject * obj3 = 0 ;
16544 char * kwnames[] = {
16545 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16546 };
16547
16548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16549 if (obj0) {
16550 ecode1 = SWIG_AsVal_int(obj0, &val1);
16551 if (!SWIG_IsOK(ecode1)) {
16552 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16553 }
16554 arg1 = static_cast< wxEventType >(val1);
16555 }
16556 if (obj1) {
16557 ecode2 = SWIG_AsVal_int(obj1, &val2);
16558 if (!SWIG_IsOK(ecode2)) {
16559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16560 }
16561 arg2 = static_cast< int >(val2);
16562 }
16563 if (obj2) {
16564 ecode3 = SWIG_AsVal_int(obj2, &val3);
16565 if (!SWIG_IsOK(ecode3)) {
16566 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16567 }
16568 arg3 = static_cast< int >(val3);
16569 }
16570 if (obj3) {
16571 ecode4 = SWIG_AsVal_int(obj3, &val4);
16572 if (!SWIG_IsOK(ecode4)) {
16573 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16574 }
16575 arg4 = static_cast< int >(val4);
16576 }
16577 {
16578 PyThreadState* __tstate = wxPyBeginAllowThreads();
16579 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16580 wxPyEndAllowThreads(__tstate);
16581 if (PyErr_Occurred()) SWIG_fail;
16582 }
16583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16584 return resultobj;
16585 fail:
16586 return NULL;
16587 }
16588
16589
16590 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16591 PyObject *resultobj = 0;
16592 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16593 wxPoint result;
16594 void *argp1 = 0 ;
16595 int res1 = 0 ;
16596 PyObject *swig_obj[1] ;
16597
16598 if (!args) SWIG_fail;
16599 swig_obj[0] = args;
16600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16601 if (!SWIG_IsOK(res1)) {
16602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16603 }
16604 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16605 {
16606 PyThreadState* __tstate = wxPyBeginAllowThreads();
16607 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16608 wxPyEndAllowThreads(__tstate);
16609 if (PyErr_Occurred()) SWIG_fail;
16610 }
16611 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16612 return resultobj;
16613 fail:
16614 return NULL;
16615 }
16616
16617
16618 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16619 PyObject *resultobj = 0;
16620 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16621 int result;
16622 void *argp1 = 0 ;
16623 int res1 = 0 ;
16624 PyObject *swig_obj[1] ;
16625
16626 if (!args) SWIG_fail;
16627 swig_obj[0] = args;
16628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16629 if (!SWIG_IsOK(res1)) {
16630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16631 }
16632 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16633 {
16634 PyThreadState* __tstate = wxPyBeginAllowThreads();
16635 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16636 wxPyEndAllowThreads(__tstate);
16637 if (PyErr_Occurred()) SWIG_fail;
16638 }
16639 resultobj = SWIG_From_int(static_cast< int >(result));
16640 return resultobj;
16641 fail:
16642 return NULL;
16643 }
16644
16645
16646 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16647 PyObject *resultobj = 0;
16648 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16649 int result;
16650 void *argp1 = 0 ;
16651 int res1 = 0 ;
16652 PyObject *swig_obj[1] ;
16653
16654 if (!args) SWIG_fail;
16655 swig_obj[0] = args;
16656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16657 if (!SWIG_IsOK(res1)) {
16658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16659 }
16660 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16661 {
16662 PyThreadState* __tstate = wxPyBeginAllowThreads();
16663 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16664 wxPyEndAllowThreads(__tstate);
16665 if (PyErr_Occurred()) SWIG_fail;
16666 }
16667 resultobj = SWIG_From_int(static_cast< int >(result));
16668 return resultobj;
16669 fail:
16670 return NULL;
16671 }
16672
16673
16674 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16675 PyObject *resultobj = 0;
16676 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16677 int result;
16678 void *argp1 = 0 ;
16679 int res1 = 0 ;
16680 PyObject *swig_obj[1] ;
16681
16682 if (!args) SWIG_fail;
16683 swig_obj[0] = args;
16684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16685 if (!SWIG_IsOK(res1)) {
16686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16687 }
16688 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16689 {
16690 PyThreadState* __tstate = wxPyBeginAllowThreads();
16691 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16692 wxPyEndAllowThreads(__tstate);
16693 if (PyErr_Occurred()) SWIG_fail;
16694 }
16695 resultobj = SWIG_From_int(static_cast< int >(result));
16696 return resultobj;
16697 fail:
16698 return NULL;
16699 }
16700
16701
16702 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16703 PyObject *resultobj = 0;
16704 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16705 int result;
16706 void *argp1 = 0 ;
16707 int res1 = 0 ;
16708 PyObject *swig_obj[1] ;
16709
16710 if (!args) SWIG_fail;
16711 swig_obj[0] = args;
16712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16713 if (!SWIG_IsOK(res1)) {
16714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16715 }
16716 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16717 {
16718 PyThreadState* __tstate = wxPyBeginAllowThreads();
16719 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16720 wxPyEndAllowThreads(__tstate);
16721 if (PyErr_Occurred()) SWIG_fail;
16722 }
16723 resultobj = SWIG_From_int(static_cast< int >(result));
16724 return resultobj;
16725 fail:
16726 return NULL;
16727 }
16728
16729
16730 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16731 PyObject *resultobj = 0;
16732 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16733 int arg2 ;
16734 void *argp1 = 0 ;
16735 int res1 = 0 ;
16736 int val2 ;
16737 int ecode2 = 0 ;
16738 PyObject * obj0 = 0 ;
16739 PyObject * obj1 = 0 ;
16740 char * kwnames[] = {
16741 (char *) "self",(char *) "stick", NULL
16742 };
16743
16744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16746 if (!SWIG_IsOK(res1)) {
16747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16748 }
16749 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16750 ecode2 = SWIG_AsVal_int(obj1, &val2);
16751 if (!SWIG_IsOK(ecode2)) {
16752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16753 }
16754 arg2 = static_cast< int >(val2);
16755 {
16756 PyThreadState* __tstate = wxPyBeginAllowThreads();
16757 (arg1)->SetJoystick(arg2);
16758 wxPyEndAllowThreads(__tstate);
16759 if (PyErr_Occurred()) SWIG_fail;
16760 }
16761 resultobj = SWIG_Py_Void();
16762 return resultobj;
16763 fail:
16764 return NULL;
16765 }
16766
16767
16768 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16769 PyObject *resultobj = 0;
16770 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16771 int arg2 ;
16772 void *argp1 = 0 ;
16773 int res1 = 0 ;
16774 int val2 ;
16775 int ecode2 = 0 ;
16776 PyObject * obj0 = 0 ;
16777 PyObject * obj1 = 0 ;
16778 char * kwnames[] = {
16779 (char *) "self",(char *) "state", NULL
16780 };
16781
16782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16784 if (!SWIG_IsOK(res1)) {
16785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16786 }
16787 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16788 ecode2 = SWIG_AsVal_int(obj1, &val2);
16789 if (!SWIG_IsOK(ecode2)) {
16790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16791 }
16792 arg2 = static_cast< int >(val2);
16793 {
16794 PyThreadState* __tstate = wxPyBeginAllowThreads();
16795 (arg1)->SetButtonState(arg2);
16796 wxPyEndAllowThreads(__tstate);
16797 if (PyErr_Occurred()) SWIG_fail;
16798 }
16799 resultobj = SWIG_Py_Void();
16800 return resultobj;
16801 fail:
16802 return NULL;
16803 }
16804
16805
16806 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16807 PyObject *resultobj = 0;
16808 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16809 int arg2 ;
16810 void *argp1 = 0 ;
16811 int res1 = 0 ;
16812 int val2 ;
16813 int ecode2 = 0 ;
16814 PyObject * obj0 = 0 ;
16815 PyObject * obj1 = 0 ;
16816 char * kwnames[] = {
16817 (char *) "self",(char *) "change", NULL
16818 };
16819
16820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16822 if (!SWIG_IsOK(res1)) {
16823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16824 }
16825 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16826 ecode2 = SWIG_AsVal_int(obj1, &val2);
16827 if (!SWIG_IsOK(ecode2)) {
16828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16829 }
16830 arg2 = static_cast< int >(val2);
16831 {
16832 PyThreadState* __tstate = wxPyBeginAllowThreads();
16833 (arg1)->SetButtonChange(arg2);
16834 wxPyEndAllowThreads(__tstate);
16835 if (PyErr_Occurred()) SWIG_fail;
16836 }
16837 resultobj = SWIG_Py_Void();
16838 return resultobj;
16839 fail:
16840 return NULL;
16841 }
16842
16843
16844 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16845 PyObject *resultobj = 0;
16846 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16847 wxPoint *arg2 = 0 ;
16848 void *argp1 = 0 ;
16849 int res1 = 0 ;
16850 wxPoint temp2 ;
16851 PyObject * obj0 = 0 ;
16852 PyObject * obj1 = 0 ;
16853 char * kwnames[] = {
16854 (char *) "self",(char *) "pos", NULL
16855 };
16856
16857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16859 if (!SWIG_IsOK(res1)) {
16860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16861 }
16862 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16863 {
16864 arg2 = &temp2;
16865 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16866 }
16867 {
16868 PyThreadState* __tstate = wxPyBeginAllowThreads();
16869 (arg1)->SetPosition((wxPoint const &)*arg2);
16870 wxPyEndAllowThreads(__tstate);
16871 if (PyErr_Occurred()) SWIG_fail;
16872 }
16873 resultobj = SWIG_Py_Void();
16874 return resultobj;
16875 fail:
16876 return NULL;
16877 }
16878
16879
16880 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16881 PyObject *resultobj = 0;
16882 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16883 int arg2 ;
16884 void *argp1 = 0 ;
16885 int res1 = 0 ;
16886 int val2 ;
16887 int ecode2 = 0 ;
16888 PyObject * obj0 = 0 ;
16889 PyObject * obj1 = 0 ;
16890 char * kwnames[] = {
16891 (char *) "self",(char *) "zPos", NULL
16892 };
16893
16894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16896 if (!SWIG_IsOK(res1)) {
16897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16898 }
16899 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16900 ecode2 = SWIG_AsVal_int(obj1, &val2);
16901 if (!SWIG_IsOK(ecode2)) {
16902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16903 }
16904 arg2 = static_cast< int >(val2);
16905 {
16906 PyThreadState* __tstate = wxPyBeginAllowThreads();
16907 (arg1)->SetZPosition(arg2);
16908 wxPyEndAllowThreads(__tstate);
16909 if (PyErr_Occurred()) SWIG_fail;
16910 }
16911 resultobj = SWIG_Py_Void();
16912 return resultobj;
16913 fail:
16914 return NULL;
16915 }
16916
16917
16918 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16919 PyObject *resultobj = 0;
16920 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16921 bool result;
16922 void *argp1 = 0 ;
16923 int res1 = 0 ;
16924 PyObject *swig_obj[1] ;
16925
16926 if (!args) SWIG_fail;
16927 swig_obj[0] = args;
16928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16929 if (!SWIG_IsOK(res1)) {
16930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16931 }
16932 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16933 {
16934 PyThreadState* __tstate = wxPyBeginAllowThreads();
16935 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16936 wxPyEndAllowThreads(__tstate);
16937 if (PyErr_Occurred()) SWIG_fail;
16938 }
16939 {
16940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16941 }
16942 return resultobj;
16943 fail:
16944 return NULL;
16945 }
16946
16947
16948 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16949 PyObject *resultobj = 0;
16950 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16951 bool result;
16952 void *argp1 = 0 ;
16953 int res1 = 0 ;
16954 PyObject *swig_obj[1] ;
16955
16956 if (!args) SWIG_fail;
16957 swig_obj[0] = args;
16958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16959 if (!SWIG_IsOK(res1)) {
16960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16961 }
16962 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16963 {
16964 PyThreadState* __tstate = wxPyBeginAllowThreads();
16965 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16966 wxPyEndAllowThreads(__tstate);
16967 if (PyErr_Occurred()) SWIG_fail;
16968 }
16969 {
16970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16971 }
16972 return resultobj;
16973 fail:
16974 return NULL;
16975 }
16976
16977
16978 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16979 PyObject *resultobj = 0;
16980 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16981 bool result;
16982 void *argp1 = 0 ;
16983 int res1 = 0 ;
16984 PyObject *swig_obj[1] ;
16985
16986 if (!args) SWIG_fail;
16987 swig_obj[0] = args;
16988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16989 if (!SWIG_IsOK(res1)) {
16990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16991 }
16992 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16993 {
16994 PyThreadState* __tstate = wxPyBeginAllowThreads();
16995 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
16996 wxPyEndAllowThreads(__tstate);
16997 if (PyErr_Occurred()) SWIG_fail;
16998 }
16999 {
17000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17001 }
17002 return resultobj;
17003 fail:
17004 return NULL;
17005 }
17006
17007
17008 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17009 PyObject *resultobj = 0;
17010 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17011 int arg2 = (int) wxJOY_BUTTON_ANY ;
17012 bool result;
17013 void *argp1 = 0 ;
17014 int res1 = 0 ;
17015 int val2 ;
17016 int ecode2 = 0 ;
17017 PyObject * obj0 = 0 ;
17018 PyObject * obj1 = 0 ;
17019 char * kwnames[] = {
17020 (char *) "self",(char *) "but", NULL
17021 };
17022
17023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
17024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17025 if (!SWIG_IsOK(res1)) {
17026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17027 }
17028 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17029 if (obj1) {
17030 ecode2 = SWIG_AsVal_int(obj1, &val2);
17031 if (!SWIG_IsOK(ecode2)) {
17032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
17033 }
17034 arg2 = static_cast< int >(val2);
17035 }
17036 {
17037 PyThreadState* __tstate = wxPyBeginAllowThreads();
17038 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
17039 wxPyEndAllowThreads(__tstate);
17040 if (PyErr_Occurred()) SWIG_fail;
17041 }
17042 {
17043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17044 }
17045 return resultobj;
17046 fail:
17047 return NULL;
17048 }
17049
17050
17051 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17052 PyObject *resultobj = 0;
17053 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17054 int arg2 = (int) wxJOY_BUTTON_ANY ;
17055 bool result;
17056 void *argp1 = 0 ;
17057 int res1 = 0 ;
17058 int val2 ;
17059 int ecode2 = 0 ;
17060 PyObject * obj0 = 0 ;
17061 PyObject * obj1 = 0 ;
17062 char * kwnames[] = {
17063 (char *) "self",(char *) "but", NULL
17064 };
17065
17066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
17067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17068 if (!SWIG_IsOK(res1)) {
17069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17070 }
17071 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17072 if (obj1) {
17073 ecode2 = SWIG_AsVal_int(obj1, &val2);
17074 if (!SWIG_IsOK(ecode2)) {
17075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
17076 }
17077 arg2 = static_cast< int >(val2);
17078 }
17079 {
17080 PyThreadState* __tstate = wxPyBeginAllowThreads();
17081 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
17082 wxPyEndAllowThreads(__tstate);
17083 if (PyErr_Occurred()) SWIG_fail;
17084 }
17085 {
17086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17087 }
17088 return resultobj;
17089 fail:
17090 return NULL;
17091 }
17092
17093
17094 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17095 PyObject *resultobj = 0;
17096 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17097 int arg2 = (int) wxJOY_BUTTON_ANY ;
17098 bool result;
17099 void *argp1 = 0 ;
17100 int res1 = 0 ;
17101 int val2 ;
17102 int ecode2 = 0 ;
17103 PyObject * obj0 = 0 ;
17104 PyObject * obj1 = 0 ;
17105 char * kwnames[] = {
17106 (char *) "self",(char *) "but", NULL
17107 };
17108
17109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17111 if (!SWIG_IsOK(res1)) {
17112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17113 }
17114 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17115 if (obj1) {
17116 ecode2 = SWIG_AsVal_int(obj1, &val2);
17117 if (!SWIG_IsOK(ecode2)) {
17118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17119 }
17120 arg2 = static_cast< int >(val2);
17121 }
17122 {
17123 PyThreadState* __tstate = wxPyBeginAllowThreads();
17124 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17125 wxPyEndAllowThreads(__tstate);
17126 if (PyErr_Occurred()) SWIG_fail;
17127 }
17128 {
17129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17130 }
17131 return resultobj;
17132 fail:
17133 return NULL;
17134 }
17135
17136
17137 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17138 PyObject *obj;
17139 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17140 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17141 return SWIG_Py_Void();
17142 }
17143
17144 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17145 return SWIG_Python_InitShadowInstance(args);
17146 }
17147
17148 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17149 PyObject *resultobj = 0;
17150 wxString const &arg1_defvalue = wxPyEmptyString ;
17151 wxString *arg1 = (wxString *) &arg1_defvalue ;
17152 wxSound *result = 0 ;
17153 bool temp1 = false ;
17154 PyObject * obj0 = 0 ;
17155 char * kwnames[] = {
17156 (char *) "fileName", NULL
17157 };
17158
17159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17160 if (obj0) {
17161 {
17162 arg1 = wxString_in_helper(obj0);
17163 if (arg1 == NULL) SWIG_fail;
17164 temp1 = true;
17165 }
17166 }
17167 {
17168 if (!wxPyCheckForApp()) SWIG_fail;
17169 PyThreadState* __tstate = wxPyBeginAllowThreads();
17170 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17171 wxPyEndAllowThreads(__tstate);
17172 if (PyErr_Occurred()) SWIG_fail;
17173 }
17174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17175 {
17176 if (temp1)
17177 delete arg1;
17178 }
17179 return resultobj;
17180 fail:
17181 {
17182 if (temp1)
17183 delete arg1;
17184 }
17185 return NULL;
17186 }
17187
17188
17189 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17190 PyObject *resultobj = 0;
17191 PyObject *arg1 = (PyObject *) 0 ;
17192 wxSound *result = 0 ;
17193 PyObject * obj0 = 0 ;
17194 char * kwnames[] = {
17195 (char *) "data", NULL
17196 };
17197
17198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17199 arg1 = obj0;
17200 {
17201 if (!wxPyCheckForApp()) SWIG_fail;
17202 PyThreadState* __tstate = wxPyBeginAllowThreads();
17203 result = (wxSound *)new_wxSound(arg1);
17204 wxPyEndAllowThreads(__tstate);
17205 if (PyErr_Occurred()) SWIG_fail;
17206 }
17207 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17208 return resultobj;
17209 fail:
17210 return NULL;
17211 }
17212
17213
17214 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17215 PyObject *resultobj = 0;
17216 wxSound *arg1 = (wxSound *) 0 ;
17217 void *argp1 = 0 ;
17218 int res1 = 0 ;
17219 PyObject *swig_obj[1] ;
17220
17221 if (!args) SWIG_fail;
17222 swig_obj[0] = args;
17223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17224 if (!SWIG_IsOK(res1)) {
17225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17226 }
17227 arg1 = reinterpret_cast< wxSound * >(argp1);
17228 {
17229 PyThreadState* __tstate = wxPyBeginAllowThreads();
17230 delete arg1;
17231
17232 wxPyEndAllowThreads(__tstate);
17233 if (PyErr_Occurred()) SWIG_fail;
17234 }
17235 resultobj = SWIG_Py_Void();
17236 return resultobj;
17237 fail:
17238 return NULL;
17239 }
17240
17241
17242 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17243 PyObject *resultobj = 0;
17244 wxSound *arg1 = (wxSound *) 0 ;
17245 wxString *arg2 = 0 ;
17246 bool result;
17247 void *argp1 = 0 ;
17248 int res1 = 0 ;
17249 bool temp2 = false ;
17250 PyObject * obj0 = 0 ;
17251 PyObject * obj1 = 0 ;
17252 char * kwnames[] = {
17253 (char *) "self",(char *) "fileName", NULL
17254 };
17255
17256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17258 if (!SWIG_IsOK(res1)) {
17259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17260 }
17261 arg1 = reinterpret_cast< wxSound * >(argp1);
17262 {
17263 arg2 = wxString_in_helper(obj1);
17264 if (arg2 == NULL) SWIG_fail;
17265 temp2 = true;
17266 }
17267 {
17268 PyThreadState* __tstate = wxPyBeginAllowThreads();
17269 result = (bool)(arg1)->Create((wxString const &)*arg2);
17270 wxPyEndAllowThreads(__tstate);
17271 if (PyErr_Occurred()) SWIG_fail;
17272 }
17273 {
17274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17275 }
17276 {
17277 if (temp2)
17278 delete arg2;
17279 }
17280 return resultobj;
17281 fail:
17282 {
17283 if (temp2)
17284 delete arg2;
17285 }
17286 return NULL;
17287 }
17288
17289
17290 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17291 PyObject *resultobj = 0;
17292 wxSound *arg1 = (wxSound *) 0 ;
17293 PyObject *arg2 = (PyObject *) 0 ;
17294 bool result;
17295 void *argp1 = 0 ;
17296 int res1 = 0 ;
17297 PyObject * obj0 = 0 ;
17298 PyObject * obj1 = 0 ;
17299 char * kwnames[] = {
17300 (char *) "self",(char *) "data", NULL
17301 };
17302
17303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17305 if (!SWIG_IsOK(res1)) {
17306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17307 }
17308 arg1 = reinterpret_cast< wxSound * >(argp1);
17309 arg2 = obj1;
17310 {
17311 PyThreadState* __tstate = wxPyBeginAllowThreads();
17312 result = (bool)wxSound_CreateFromData(arg1,arg2);
17313 wxPyEndAllowThreads(__tstate);
17314 if (PyErr_Occurred()) SWIG_fail;
17315 }
17316 {
17317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17318 }
17319 return resultobj;
17320 fail:
17321 return NULL;
17322 }
17323
17324
17325 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17326 PyObject *resultobj = 0;
17327 wxSound *arg1 = (wxSound *) 0 ;
17328 bool result;
17329 void *argp1 = 0 ;
17330 int res1 = 0 ;
17331 PyObject *swig_obj[1] ;
17332
17333 if (!args) SWIG_fail;
17334 swig_obj[0] = args;
17335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17336 if (!SWIG_IsOK(res1)) {
17337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17338 }
17339 arg1 = reinterpret_cast< wxSound * >(argp1);
17340 {
17341 PyThreadState* __tstate = wxPyBeginAllowThreads();
17342 result = (bool)(arg1)->IsOk();
17343 wxPyEndAllowThreads(__tstate);
17344 if (PyErr_Occurred()) SWIG_fail;
17345 }
17346 {
17347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17348 }
17349 return resultobj;
17350 fail:
17351 return NULL;
17352 }
17353
17354
17355 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17356 PyObject *resultobj = 0;
17357 wxSound *arg1 = (wxSound *) 0 ;
17358 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17359 bool result;
17360 void *argp1 = 0 ;
17361 int res1 = 0 ;
17362 unsigned int val2 ;
17363 int ecode2 = 0 ;
17364 PyObject * obj0 = 0 ;
17365 PyObject * obj1 = 0 ;
17366 char * kwnames[] = {
17367 (char *) "self",(char *) "flags", NULL
17368 };
17369
17370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17372 if (!SWIG_IsOK(res1)) {
17373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17374 }
17375 arg1 = reinterpret_cast< wxSound * >(argp1);
17376 if (obj1) {
17377 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17378 if (!SWIG_IsOK(ecode2)) {
17379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17380 }
17381 arg2 = static_cast< unsigned int >(val2);
17382 }
17383 {
17384 if (!wxPyCheckForApp()) SWIG_fail;
17385 PyThreadState* __tstate = wxPyBeginAllowThreads();
17386 result = (bool)((wxSound const *)arg1)->Play(arg2);
17387 wxPyEndAllowThreads(__tstate);
17388 if (PyErr_Occurred()) SWIG_fail;
17389 }
17390 {
17391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17392 }
17393 return resultobj;
17394 fail:
17395 return NULL;
17396 }
17397
17398
17399 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17400 PyObject *resultobj = 0;
17401 wxString *arg1 = 0 ;
17402 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17403 bool result;
17404 bool temp1 = false ;
17405 unsigned int val2 ;
17406 int ecode2 = 0 ;
17407 PyObject * obj0 = 0 ;
17408 PyObject * obj1 = 0 ;
17409 char * kwnames[] = {
17410 (char *) "filename",(char *) "flags", NULL
17411 };
17412
17413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17414 {
17415 arg1 = wxString_in_helper(obj0);
17416 if (arg1 == NULL) SWIG_fail;
17417 temp1 = true;
17418 }
17419 if (obj1) {
17420 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17421 if (!SWIG_IsOK(ecode2)) {
17422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17423 }
17424 arg2 = static_cast< unsigned int >(val2);
17425 }
17426 {
17427 if (!wxPyCheckForApp()) SWIG_fail;
17428 PyThreadState* __tstate = wxPyBeginAllowThreads();
17429 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17430 wxPyEndAllowThreads(__tstate);
17431 if (PyErr_Occurred()) SWIG_fail;
17432 }
17433 {
17434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17435 }
17436 {
17437 if (temp1)
17438 delete arg1;
17439 }
17440 return resultobj;
17441 fail:
17442 {
17443 if (temp1)
17444 delete arg1;
17445 }
17446 return NULL;
17447 }
17448
17449
17450 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17451 PyObject *resultobj = 0;
17452
17453 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17454 {
17455 if (!wxPyCheckForApp()) SWIG_fail;
17456 PyThreadState* __tstate = wxPyBeginAllowThreads();
17457 wxSound::Stop();
17458 wxPyEndAllowThreads(__tstate);
17459 if (PyErr_Occurred()) SWIG_fail;
17460 }
17461 resultobj = SWIG_Py_Void();
17462 return resultobj;
17463 fail:
17464 return NULL;
17465 }
17466
17467
17468 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17469 PyObject *obj;
17470 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17471 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17472 return SWIG_Py_Void();
17473 }
17474
17475 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17476 return SWIG_Python_InitShadowInstance(args);
17477 }
17478
17479 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17480 PyObject *resultobj = 0;
17481 wxString *arg1 = 0 ;
17482 wxString *arg2 = 0 ;
17483 wxString *arg3 = 0 ;
17484 wxString *arg4 = 0 ;
17485 wxFileTypeInfo *result = 0 ;
17486 bool temp1 = false ;
17487 bool temp2 = false ;
17488 bool temp3 = false ;
17489 bool temp4 = false ;
17490 PyObject * obj0 = 0 ;
17491 PyObject * obj1 = 0 ;
17492 PyObject * obj2 = 0 ;
17493 PyObject * obj3 = 0 ;
17494 char * kwnames[] = {
17495 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17496 };
17497
17498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17499 {
17500 arg1 = wxString_in_helper(obj0);
17501 if (arg1 == NULL) SWIG_fail;
17502 temp1 = true;
17503 }
17504 {
17505 arg2 = wxString_in_helper(obj1);
17506 if (arg2 == NULL) SWIG_fail;
17507 temp2 = true;
17508 }
17509 {
17510 arg3 = wxString_in_helper(obj2);
17511 if (arg3 == NULL) SWIG_fail;
17512 temp3 = true;
17513 }
17514 {
17515 arg4 = wxString_in_helper(obj3);
17516 if (arg4 == NULL) SWIG_fail;
17517 temp4 = true;
17518 }
17519 {
17520 PyThreadState* __tstate = wxPyBeginAllowThreads();
17521 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17522 wxPyEndAllowThreads(__tstate);
17523 if (PyErr_Occurred()) SWIG_fail;
17524 }
17525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17526 {
17527 if (temp1)
17528 delete arg1;
17529 }
17530 {
17531 if (temp2)
17532 delete arg2;
17533 }
17534 {
17535 if (temp3)
17536 delete arg3;
17537 }
17538 {
17539 if (temp4)
17540 delete arg4;
17541 }
17542 return resultobj;
17543 fail:
17544 {
17545 if (temp1)
17546 delete arg1;
17547 }
17548 {
17549 if (temp2)
17550 delete arg2;
17551 }
17552 {
17553 if (temp3)
17554 delete arg3;
17555 }
17556 {
17557 if (temp4)
17558 delete arg4;
17559 }
17560 return NULL;
17561 }
17562
17563
17564 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17565 PyObject *resultobj = 0;
17566 wxArrayString *arg1 = 0 ;
17567 wxFileTypeInfo *result = 0 ;
17568 bool temp1 = false ;
17569 PyObject * obj0 = 0 ;
17570 char * kwnames[] = {
17571 (char *) "sArray", NULL
17572 };
17573
17574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17575 {
17576 if (! PySequence_Check(obj0)) {
17577 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17578 SWIG_fail;
17579 }
17580 arg1 = new wxArrayString;
17581 temp1 = true;
17582 int i, len=PySequence_Length(obj0);
17583 for (i=0; i<len; i++) {
17584 PyObject* item = PySequence_GetItem(obj0, i);
17585 wxString* s = wxString_in_helper(item);
17586 if (PyErr_Occurred()) SWIG_fail;
17587 arg1->Add(*s);
17588 delete s;
17589 Py_DECREF(item);
17590 }
17591 }
17592 {
17593 PyThreadState* __tstate = wxPyBeginAllowThreads();
17594 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17595 wxPyEndAllowThreads(__tstate);
17596 if (PyErr_Occurred()) SWIG_fail;
17597 }
17598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17599 {
17600 if (temp1) delete arg1;
17601 }
17602 return resultobj;
17603 fail:
17604 {
17605 if (temp1) delete arg1;
17606 }
17607 return NULL;
17608 }
17609
17610
17611 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17612 PyObject *resultobj = 0;
17613 wxFileTypeInfo *result = 0 ;
17614
17615 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17616 {
17617 PyThreadState* __tstate = wxPyBeginAllowThreads();
17618 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17619 wxPyEndAllowThreads(__tstate);
17620 if (PyErr_Occurred()) SWIG_fail;
17621 }
17622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17623 return resultobj;
17624 fail:
17625 return NULL;
17626 }
17627
17628
17629 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17630 PyObject *resultobj = 0;
17631 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17632 bool result;
17633 void *argp1 = 0 ;
17634 int res1 = 0 ;
17635 PyObject *swig_obj[1] ;
17636
17637 if (!args) SWIG_fail;
17638 swig_obj[0] = args;
17639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17640 if (!SWIG_IsOK(res1)) {
17641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17642 }
17643 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17644 {
17645 PyThreadState* __tstate = wxPyBeginAllowThreads();
17646 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17647 wxPyEndAllowThreads(__tstate);
17648 if (PyErr_Occurred()) SWIG_fail;
17649 }
17650 {
17651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17652 }
17653 return resultobj;
17654 fail:
17655 return NULL;
17656 }
17657
17658
17659 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17660 PyObject *resultobj = 0;
17661 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17662 wxString *arg2 = 0 ;
17663 int arg3 = (int) 0 ;
17664 void *argp1 = 0 ;
17665 int res1 = 0 ;
17666 bool temp2 = false ;
17667 int val3 ;
17668 int ecode3 = 0 ;
17669 PyObject * obj0 = 0 ;
17670 PyObject * obj1 = 0 ;
17671 PyObject * obj2 = 0 ;
17672 char * kwnames[] = {
17673 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17674 };
17675
17676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17678 if (!SWIG_IsOK(res1)) {
17679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17680 }
17681 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17682 {
17683 arg2 = wxString_in_helper(obj1);
17684 if (arg2 == NULL) SWIG_fail;
17685 temp2 = true;
17686 }
17687 if (obj2) {
17688 ecode3 = SWIG_AsVal_int(obj2, &val3);
17689 if (!SWIG_IsOK(ecode3)) {
17690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17691 }
17692 arg3 = static_cast< int >(val3);
17693 }
17694 {
17695 PyThreadState* __tstate = wxPyBeginAllowThreads();
17696 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17697 wxPyEndAllowThreads(__tstate);
17698 if (PyErr_Occurred()) SWIG_fail;
17699 }
17700 resultobj = SWIG_Py_Void();
17701 {
17702 if (temp2)
17703 delete arg2;
17704 }
17705 return resultobj;
17706 fail:
17707 {
17708 if (temp2)
17709 delete arg2;
17710 }
17711 return NULL;
17712 }
17713
17714
17715 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17716 PyObject *resultobj = 0;
17717 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17718 wxString *arg2 = 0 ;
17719 void *argp1 = 0 ;
17720 int res1 = 0 ;
17721 bool temp2 = false ;
17722 PyObject * obj0 = 0 ;
17723 PyObject * obj1 = 0 ;
17724 char * kwnames[] = {
17725 (char *) "self",(char *) "shortDesc", NULL
17726 };
17727
17728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17730 if (!SWIG_IsOK(res1)) {
17731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17732 }
17733 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17734 {
17735 arg2 = wxString_in_helper(obj1);
17736 if (arg2 == NULL) SWIG_fail;
17737 temp2 = true;
17738 }
17739 {
17740 PyThreadState* __tstate = wxPyBeginAllowThreads();
17741 (arg1)->SetShortDesc((wxString const &)*arg2);
17742 wxPyEndAllowThreads(__tstate);
17743 if (PyErr_Occurred()) SWIG_fail;
17744 }
17745 resultobj = SWIG_Py_Void();
17746 {
17747 if (temp2)
17748 delete arg2;
17749 }
17750 return resultobj;
17751 fail:
17752 {
17753 if (temp2)
17754 delete arg2;
17755 }
17756 return NULL;
17757 }
17758
17759
17760 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17761 PyObject *resultobj = 0;
17762 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17763 wxString *result = 0 ;
17764 void *argp1 = 0 ;
17765 int res1 = 0 ;
17766 PyObject *swig_obj[1] ;
17767
17768 if (!args) SWIG_fail;
17769 swig_obj[0] = args;
17770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17771 if (!SWIG_IsOK(res1)) {
17772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17773 }
17774 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17775 {
17776 PyThreadState* __tstate = wxPyBeginAllowThreads();
17777 {
17778 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17779 result = (wxString *) &_result_ref;
17780 }
17781 wxPyEndAllowThreads(__tstate);
17782 if (PyErr_Occurred()) SWIG_fail;
17783 }
17784 {
17785 #if wxUSE_UNICODE
17786 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17787 #else
17788 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17789 #endif
17790 }
17791 return resultobj;
17792 fail:
17793 return NULL;
17794 }
17795
17796
17797 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17798 PyObject *resultobj = 0;
17799 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17800 wxString *result = 0 ;
17801 void *argp1 = 0 ;
17802 int res1 = 0 ;
17803 PyObject *swig_obj[1] ;
17804
17805 if (!args) SWIG_fail;
17806 swig_obj[0] = args;
17807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17808 if (!SWIG_IsOK(res1)) {
17809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17810 }
17811 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17812 {
17813 PyThreadState* __tstate = wxPyBeginAllowThreads();
17814 {
17815 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17816 result = (wxString *) &_result_ref;
17817 }
17818 wxPyEndAllowThreads(__tstate);
17819 if (PyErr_Occurred()) SWIG_fail;
17820 }
17821 {
17822 #if wxUSE_UNICODE
17823 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17824 #else
17825 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17826 #endif
17827 }
17828 return resultobj;
17829 fail:
17830 return NULL;
17831 }
17832
17833
17834 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17835 PyObject *resultobj = 0;
17836 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17837 wxString *result = 0 ;
17838 void *argp1 = 0 ;
17839 int res1 = 0 ;
17840 PyObject *swig_obj[1] ;
17841
17842 if (!args) SWIG_fail;
17843 swig_obj[0] = args;
17844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17845 if (!SWIG_IsOK(res1)) {
17846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17847 }
17848 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17849 {
17850 PyThreadState* __tstate = wxPyBeginAllowThreads();
17851 {
17852 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17853 result = (wxString *) &_result_ref;
17854 }
17855 wxPyEndAllowThreads(__tstate);
17856 if (PyErr_Occurred()) SWIG_fail;
17857 }
17858 {
17859 #if wxUSE_UNICODE
17860 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17861 #else
17862 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17863 #endif
17864 }
17865 return resultobj;
17866 fail:
17867 return NULL;
17868 }
17869
17870
17871 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17872 PyObject *resultobj = 0;
17873 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17874 wxString *result = 0 ;
17875 void *argp1 = 0 ;
17876 int res1 = 0 ;
17877 PyObject *swig_obj[1] ;
17878
17879 if (!args) SWIG_fail;
17880 swig_obj[0] = args;
17881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17882 if (!SWIG_IsOK(res1)) {
17883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17884 }
17885 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17886 {
17887 PyThreadState* __tstate = wxPyBeginAllowThreads();
17888 {
17889 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17890 result = (wxString *) &_result_ref;
17891 }
17892 wxPyEndAllowThreads(__tstate);
17893 if (PyErr_Occurred()) SWIG_fail;
17894 }
17895 {
17896 #if wxUSE_UNICODE
17897 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17898 #else
17899 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17900 #endif
17901 }
17902 return resultobj;
17903 fail:
17904 return NULL;
17905 }
17906
17907
17908 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17909 PyObject *resultobj = 0;
17910 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17911 wxString *result = 0 ;
17912 void *argp1 = 0 ;
17913 int res1 = 0 ;
17914 PyObject *swig_obj[1] ;
17915
17916 if (!args) SWIG_fail;
17917 swig_obj[0] = args;
17918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17919 if (!SWIG_IsOK(res1)) {
17920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17921 }
17922 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17923 {
17924 PyThreadState* __tstate = wxPyBeginAllowThreads();
17925 {
17926 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17927 result = (wxString *) &_result_ref;
17928 }
17929 wxPyEndAllowThreads(__tstate);
17930 if (PyErr_Occurred()) SWIG_fail;
17931 }
17932 {
17933 #if wxUSE_UNICODE
17934 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17935 #else
17936 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17937 #endif
17938 }
17939 return resultobj;
17940 fail:
17941 return NULL;
17942 }
17943
17944
17945 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17946 PyObject *resultobj = 0;
17947 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17948 wxArrayString *result = 0 ;
17949 void *argp1 = 0 ;
17950 int res1 = 0 ;
17951 PyObject *swig_obj[1] ;
17952
17953 if (!args) SWIG_fail;
17954 swig_obj[0] = args;
17955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17956 if (!SWIG_IsOK(res1)) {
17957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17958 }
17959 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17960 {
17961 PyThreadState* __tstate = wxPyBeginAllowThreads();
17962 {
17963 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17964 result = (wxArrayString *) &_result_ref;
17965 }
17966 wxPyEndAllowThreads(__tstate);
17967 if (PyErr_Occurred()) SWIG_fail;
17968 }
17969 {
17970 resultobj = wxArrayString2PyList_helper(*result);
17971 }
17972 return resultobj;
17973 fail:
17974 return NULL;
17975 }
17976
17977
17978 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17979 PyObject *resultobj = 0;
17980 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17981 size_t result;
17982 void *argp1 = 0 ;
17983 int res1 = 0 ;
17984 PyObject *swig_obj[1] ;
17985
17986 if (!args) SWIG_fail;
17987 swig_obj[0] = args;
17988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17989 if (!SWIG_IsOK(res1)) {
17990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17991 }
17992 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17993 {
17994 PyThreadState* __tstate = wxPyBeginAllowThreads();
17995 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
17996 wxPyEndAllowThreads(__tstate);
17997 if (PyErr_Occurred()) SWIG_fail;
17998 }
17999 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
18000 return resultobj;
18001 fail:
18002 return NULL;
18003 }
18004
18005
18006 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18007 PyObject *resultobj = 0;
18008 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18009 wxString *result = 0 ;
18010 void *argp1 = 0 ;
18011 int res1 = 0 ;
18012 PyObject *swig_obj[1] ;
18013
18014 if (!args) SWIG_fail;
18015 swig_obj[0] = args;
18016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18017 if (!SWIG_IsOK(res1)) {
18018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18019 }
18020 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18021 {
18022 PyThreadState* __tstate = wxPyBeginAllowThreads();
18023 {
18024 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
18025 result = (wxString *) &_result_ref;
18026 }
18027 wxPyEndAllowThreads(__tstate);
18028 if (PyErr_Occurred()) SWIG_fail;
18029 }
18030 {
18031 #if wxUSE_UNICODE
18032 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18033 #else
18034 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18035 #endif
18036 }
18037 return resultobj;
18038 fail:
18039 return NULL;
18040 }
18041
18042
18043 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18044 PyObject *resultobj = 0;
18045 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18046 int result;
18047 void *argp1 = 0 ;
18048 int res1 = 0 ;
18049 PyObject *swig_obj[1] ;
18050
18051 if (!args) SWIG_fail;
18052 swig_obj[0] = args;
18053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18054 if (!SWIG_IsOK(res1)) {
18055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18056 }
18057 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18058 {
18059 PyThreadState* __tstate = wxPyBeginAllowThreads();
18060 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
18061 wxPyEndAllowThreads(__tstate);
18062 if (PyErr_Occurred()) SWIG_fail;
18063 }
18064 resultobj = SWIG_From_int(static_cast< int >(result));
18065 return resultobj;
18066 fail:
18067 return NULL;
18068 }
18069
18070
18071 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18072 PyObject *obj;
18073 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18074 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
18075 return SWIG_Py_Void();
18076 }
18077
18078 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18079 return SWIG_Python_InitShadowInstance(args);
18080 }
18081
18082 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18083 PyObject *resultobj = 0;
18084 wxFileTypeInfo *arg1 = 0 ;
18085 wxFileType *result = 0 ;
18086 void *argp1 = 0 ;
18087 int res1 = 0 ;
18088 PyObject * obj0 = 0 ;
18089 char * kwnames[] = {
18090 (char *) "ftInfo", NULL
18091 };
18092
18093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18094 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18095 if (!SWIG_IsOK(res1)) {
18096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18097 }
18098 if (!argp1) {
18099 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18100 }
18101 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18102 {
18103 PyThreadState* __tstate = wxPyBeginAllowThreads();
18104 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18105 wxPyEndAllowThreads(__tstate);
18106 if (PyErr_Occurred()) SWIG_fail;
18107 }
18108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18109 return resultobj;
18110 fail:
18111 return NULL;
18112 }
18113
18114
18115 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18116 PyObject *resultobj = 0;
18117 wxFileType *arg1 = (wxFileType *) 0 ;
18118 void *argp1 = 0 ;
18119 int res1 = 0 ;
18120 PyObject *swig_obj[1] ;
18121
18122 if (!args) SWIG_fail;
18123 swig_obj[0] = args;
18124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18125 if (!SWIG_IsOK(res1)) {
18126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18127 }
18128 arg1 = reinterpret_cast< wxFileType * >(argp1);
18129 {
18130 PyThreadState* __tstate = wxPyBeginAllowThreads();
18131 delete arg1;
18132
18133 wxPyEndAllowThreads(__tstate);
18134 if (PyErr_Occurred()) SWIG_fail;
18135 }
18136 resultobj = SWIG_Py_Void();
18137 return resultobj;
18138 fail:
18139 return NULL;
18140 }
18141
18142
18143 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18144 PyObject *resultobj = 0;
18145 wxFileType *arg1 = (wxFileType *) 0 ;
18146 PyObject *result = 0 ;
18147 void *argp1 = 0 ;
18148 int res1 = 0 ;
18149 PyObject *swig_obj[1] ;
18150
18151 if (!args) SWIG_fail;
18152 swig_obj[0] = args;
18153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18154 if (!SWIG_IsOK(res1)) {
18155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18156 }
18157 arg1 = reinterpret_cast< wxFileType * >(argp1);
18158 {
18159 PyThreadState* __tstate = wxPyBeginAllowThreads();
18160 result = (PyObject *)wxFileType_GetMimeType(arg1);
18161 wxPyEndAllowThreads(__tstate);
18162 if (PyErr_Occurred()) SWIG_fail;
18163 }
18164 resultobj = result;
18165 return resultobj;
18166 fail:
18167 return NULL;
18168 }
18169
18170
18171 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18172 PyObject *resultobj = 0;
18173 wxFileType *arg1 = (wxFileType *) 0 ;
18174 PyObject *result = 0 ;
18175 void *argp1 = 0 ;
18176 int res1 = 0 ;
18177 PyObject *swig_obj[1] ;
18178
18179 if (!args) SWIG_fail;
18180 swig_obj[0] = args;
18181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18182 if (!SWIG_IsOK(res1)) {
18183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18184 }
18185 arg1 = reinterpret_cast< wxFileType * >(argp1);
18186 {
18187 PyThreadState* __tstate = wxPyBeginAllowThreads();
18188 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18189 wxPyEndAllowThreads(__tstate);
18190 if (PyErr_Occurred()) SWIG_fail;
18191 }
18192 resultobj = result;
18193 return resultobj;
18194 fail:
18195 return NULL;
18196 }
18197
18198
18199 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18200 PyObject *resultobj = 0;
18201 wxFileType *arg1 = (wxFileType *) 0 ;
18202 PyObject *result = 0 ;
18203 void *argp1 = 0 ;
18204 int res1 = 0 ;
18205 PyObject *swig_obj[1] ;
18206
18207 if (!args) SWIG_fail;
18208 swig_obj[0] = args;
18209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18210 if (!SWIG_IsOK(res1)) {
18211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18212 }
18213 arg1 = reinterpret_cast< wxFileType * >(argp1);
18214 {
18215 PyThreadState* __tstate = wxPyBeginAllowThreads();
18216 result = (PyObject *)wxFileType_GetExtensions(arg1);
18217 wxPyEndAllowThreads(__tstate);
18218 if (PyErr_Occurred()) SWIG_fail;
18219 }
18220 resultobj = result;
18221 return resultobj;
18222 fail:
18223 return NULL;
18224 }
18225
18226
18227 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18228 PyObject *resultobj = 0;
18229 wxFileType *arg1 = (wxFileType *) 0 ;
18230 wxIcon *result = 0 ;
18231 void *argp1 = 0 ;
18232 int res1 = 0 ;
18233 PyObject *swig_obj[1] ;
18234
18235 if (!args) SWIG_fail;
18236 swig_obj[0] = args;
18237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18238 if (!SWIG_IsOK(res1)) {
18239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18240 }
18241 arg1 = reinterpret_cast< wxFileType * >(argp1);
18242 {
18243 PyThreadState* __tstate = wxPyBeginAllowThreads();
18244 result = (wxIcon *)wxFileType_GetIcon(arg1);
18245 wxPyEndAllowThreads(__tstate);
18246 if (PyErr_Occurred()) SWIG_fail;
18247 }
18248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18249 return resultobj;
18250 fail:
18251 return NULL;
18252 }
18253
18254
18255 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18256 PyObject *resultobj = 0;
18257 wxFileType *arg1 = (wxFileType *) 0 ;
18258 PyObject *result = 0 ;
18259 void *argp1 = 0 ;
18260 int res1 = 0 ;
18261 PyObject *swig_obj[1] ;
18262
18263 if (!args) SWIG_fail;
18264 swig_obj[0] = args;
18265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18266 if (!SWIG_IsOK(res1)) {
18267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18268 }
18269 arg1 = reinterpret_cast< wxFileType * >(argp1);
18270 {
18271 PyThreadState* __tstate = wxPyBeginAllowThreads();
18272 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18273 wxPyEndAllowThreads(__tstate);
18274 if (PyErr_Occurred()) SWIG_fail;
18275 }
18276 resultobj = result;
18277 return resultobj;
18278 fail:
18279 return NULL;
18280 }
18281
18282
18283 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18284 PyObject *resultobj = 0;
18285 wxFileType *arg1 = (wxFileType *) 0 ;
18286 PyObject *result = 0 ;
18287 void *argp1 = 0 ;
18288 int res1 = 0 ;
18289 PyObject *swig_obj[1] ;
18290
18291 if (!args) SWIG_fail;
18292 swig_obj[0] = args;
18293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18294 if (!SWIG_IsOK(res1)) {
18295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18296 }
18297 arg1 = reinterpret_cast< wxFileType * >(argp1);
18298 {
18299 PyThreadState* __tstate = wxPyBeginAllowThreads();
18300 result = (PyObject *)wxFileType_GetDescription(arg1);
18301 wxPyEndAllowThreads(__tstate);
18302 if (PyErr_Occurred()) SWIG_fail;
18303 }
18304 resultobj = result;
18305 return resultobj;
18306 fail:
18307 return NULL;
18308 }
18309
18310
18311 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18312 PyObject *resultobj = 0;
18313 wxFileType *arg1 = (wxFileType *) 0 ;
18314 wxString *arg2 = 0 ;
18315 wxString const &arg3_defvalue = wxPyEmptyString ;
18316 wxString *arg3 = (wxString *) &arg3_defvalue ;
18317 PyObject *result = 0 ;
18318 void *argp1 = 0 ;
18319 int res1 = 0 ;
18320 bool temp2 = false ;
18321 bool temp3 = false ;
18322 PyObject * obj0 = 0 ;
18323 PyObject * obj1 = 0 ;
18324 PyObject * obj2 = 0 ;
18325 char * kwnames[] = {
18326 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18327 };
18328
18329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18331 if (!SWIG_IsOK(res1)) {
18332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18333 }
18334 arg1 = reinterpret_cast< wxFileType * >(argp1);
18335 {
18336 arg2 = wxString_in_helper(obj1);
18337 if (arg2 == NULL) SWIG_fail;
18338 temp2 = true;
18339 }
18340 if (obj2) {
18341 {
18342 arg3 = wxString_in_helper(obj2);
18343 if (arg3 == NULL) SWIG_fail;
18344 temp3 = true;
18345 }
18346 }
18347 {
18348 PyThreadState* __tstate = wxPyBeginAllowThreads();
18349 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18350 wxPyEndAllowThreads(__tstate);
18351 if (PyErr_Occurred()) SWIG_fail;
18352 }
18353 resultobj = result;
18354 {
18355 if (temp2)
18356 delete arg2;
18357 }
18358 {
18359 if (temp3)
18360 delete arg3;
18361 }
18362 return resultobj;
18363 fail:
18364 {
18365 if (temp2)
18366 delete arg2;
18367 }
18368 {
18369 if (temp3)
18370 delete arg3;
18371 }
18372 return NULL;
18373 }
18374
18375
18376 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18377 PyObject *resultobj = 0;
18378 wxFileType *arg1 = (wxFileType *) 0 ;
18379 wxString *arg2 = 0 ;
18380 wxString const &arg3_defvalue = wxPyEmptyString ;
18381 wxString *arg3 = (wxString *) &arg3_defvalue ;
18382 PyObject *result = 0 ;
18383 void *argp1 = 0 ;
18384 int res1 = 0 ;
18385 bool temp2 = false ;
18386 bool temp3 = false ;
18387 PyObject * obj0 = 0 ;
18388 PyObject * obj1 = 0 ;
18389 PyObject * obj2 = 0 ;
18390 char * kwnames[] = {
18391 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18392 };
18393
18394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18396 if (!SWIG_IsOK(res1)) {
18397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18398 }
18399 arg1 = reinterpret_cast< wxFileType * >(argp1);
18400 {
18401 arg2 = wxString_in_helper(obj1);
18402 if (arg2 == NULL) SWIG_fail;
18403 temp2 = true;
18404 }
18405 if (obj2) {
18406 {
18407 arg3 = wxString_in_helper(obj2);
18408 if (arg3 == NULL) SWIG_fail;
18409 temp3 = true;
18410 }
18411 }
18412 {
18413 PyThreadState* __tstate = wxPyBeginAllowThreads();
18414 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18415 wxPyEndAllowThreads(__tstate);
18416 if (PyErr_Occurred()) SWIG_fail;
18417 }
18418 resultobj = result;
18419 {
18420 if (temp2)
18421 delete arg2;
18422 }
18423 {
18424 if (temp3)
18425 delete arg3;
18426 }
18427 return resultobj;
18428 fail:
18429 {
18430 if (temp2)
18431 delete arg2;
18432 }
18433 {
18434 if (temp3)
18435 delete arg3;
18436 }
18437 return NULL;
18438 }
18439
18440
18441 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18442 PyObject *resultobj = 0;
18443 wxFileType *arg1 = (wxFileType *) 0 ;
18444 wxString *arg2 = 0 ;
18445 wxString const &arg3_defvalue = wxPyEmptyString ;
18446 wxString *arg3 = (wxString *) &arg3_defvalue ;
18447 PyObject *result = 0 ;
18448 void *argp1 = 0 ;
18449 int res1 = 0 ;
18450 bool temp2 = false ;
18451 bool temp3 = false ;
18452 PyObject * obj0 = 0 ;
18453 PyObject * obj1 = 0 ;
18454 PyObject * obj2 = 0 ;
18455 char * kwnames[] = {
18456 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18457 };
18458
18459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18461 if (!SWIG_IsOK(res1)) {
18462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18463 }
18464 arg1 = reinterpret_cast< wxFileType * >(argp1);
18465 {
18466 arg2 = wxString_in_helper(obj1);
18467 if (arg2 == NULL) SWIG_fail;
18468 temp2 = true;
18469 }
18470 if (obj2) {
18471 {
18472 arg3 = wxString_in_helper(obj2);
18473 if (arg3 == NULL) SWIG_fail;
18474 temp3 = true;
18475 }
18476 }
18477 {
18478 PyThreadState* __tstate = wxPyBeginAllowThreads();
18479 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18480 wxPyEndAllowThreads(__tstate);
18481 if (PyErr_Occurred()) SWIG_fail;
18482 }
18483 resultobj = result;
18484 {
18485 if (temp2)
18486 delete arg2;
18487 }
18488 {
18489 if (temp3)
18490 delete arg3;
18491 }
18492 return resultobj;
18493 fail:
18494 {
18495 if (temp2)
18496 delete arg2;
18497 }
18498 {
18499 if (temp3)
18500 delete arg3;
18501 }
18502 return NULL;
18503 }
18504
18505
18506 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18507 PyObject *resultobj = 0;
18508 wxFileType *arg1 = (wxFileType *) 0 ;
18509 wxString *arg2 = 0 ;
18510 wxString *arg3 = 0 ;
18511 bool arg4 = (bool) true ;
18512 bool result;
18513 void *argp1 = 0 ;
18514 int res1 = 0 ;
18515 bool temp2 = false ;
18516 bool temp3 = false ;
18517 bool val4 ;
18518 int ecode4 = 0 ;
18519 PyObject * obj0 = 0 ;
18520 PyObject * obj1 = 0 ;
18521 PyObject * obj2 = 0 ;
18522 PyObject * obj3 = 0 ;
18523 char * kwnames[] = {
18524 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18525 };
18526
18527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18529 if (!SWIG_IsOK(res1)) {
18530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18531 }
18532 arg1 = reinterpret_cast< wxFileType * >(argp1);
18533 {
18534 arg2 = wxString_in_helper(obj1);
18535 if (arg2 == NULL) SWIG_fail;
18536 temp2 = true;
18537 }
18538 {
18539 arg3 = wxString_in_helper(obj2);
18540 if (arg3 == NULL) SWIG_fail;
18541 temp3 = true;
18542 }
18543 if (obj3) {
18544 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18545 if (!SWIG_IsOK(ecode4)) {
18546 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18547 }
18548 arg4 = static_cast< bool >(val4);
18549 }
18550 {
18551 PyThreadState* __tstate = wxPyBeginAllowThreads();
18552 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18553 wxPyEndAllowThreads(__tstate);
18554 if (PyErr_Occurred()) SWIG_fail;
18555 }
18556 {
18557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18558 }
18559 {
18560 if (temp2)
18561 delete arg2;
18562 }
18563 {
18564 if (temp3)
18565 delete arg3;
18566 }
18567 return resultobj;
18568 fail:
18569 {
18570 if (temp2)
18571 delete arg2;
18572 }
18573 {
18574 if (temp3)
18575 delete arg3;
18576 }
18577 return NULL;
18578 }
18579
18580
18581 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18582 PyObject *resultobj = 0;
18583 wxFileType *arg1 = (wxFileType *) 0 ;
18584 wxString const &arg2_defvalue = wxPyEmptyString ;
18585 wxString *arg2 = (wxString *) &arg2_defvalue ;
18586 int arg3 = (int) 0 ;
18587 bool result;
18588 void *argp1 = 0 ;
18589 int res1 = 0 ;
18590 bool temp2 = false ;
18591 int val3 ;
18592 int ecode3 = 0 ;
18593 PyObject * obj0 = 0 ;
18594 PyObject * obj1 = 0 ;
18595 PyObject * obj2 = 0 ;
18596 char * kwnames[] = {
18597 (char *) "self",(char *) "cmd",(char *) "index", NULL
18598 };
18599
18600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18602 if (!SWIG_IsOK(res1)) {
18603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18604 }
18605 arg1 = reinterpret_cast< wxFileType * >(argp1);
18606 if (obj1) {
18607 {
18608 arg2 = wxString_in_helper(obj1);
18609 if (arg2 == NULL) SWIG_fail;
18610 temp2 = true;
18611 }
18612 }
18613 if (obj2) {
18614 ecode3 = SWIG_AsVal_int(obj2, &val3);
18615 if (!SWIG_IsOK(ecode3)) {
18616 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18617 }
18618 arg3 = static_cast< int >(val3);
18619 }
18620 {
18621 PyThreadState* __tstate = wxPyBeginAllowThreads();
18622 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18623 wxPyEndAllowThreads(__tstate);
18624 if (PyErr_Occurred()) SWIG_fail;
18625 }
18626 {
18627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18628 }
18629 {
18630 if (temp2)
18631 delete arg2;
18632 }
18633 return resultobj;
18634 fail:
18635 {
18636 if (temp2)
18637 delete arg2;
18638 }
18639 return NULL;
18640 }
18641
18642
18643 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18644 PyObject *resultobj = 0;
18645 wxFileType *arg1 = (wxFileType *) 0 ;
18646 bool result;
18647 void *argp1 = 0 ;
18648 int res1 = 0 ;
18649 PyObject *swig_obj[1] ;
18650
18651 if (!args) SWIG_fail;
18652 swig_obj[0] = args;
18653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18654 if (!SWIG_IsOK(res1)) {
18655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18656 }
18657 arg1 = reinterpret_cast< wxFileType * >(argp1);
18658 {
18659 PyThreadState* __tstate = wxPyBeginAllowThreads();
18660 result = (bool)(arg1)->Unassociate();
18661 wxPyEndAllowThreads(__tstate);
18662 if (PyErr_Occurred()) SWIG_fail;
18663 }
18664 {
18665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18666 }
18667 return resultobj;
18668 fail:
18669 return NULL;
18670 }
18671
18672
18673 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18674 PyObject *resultobj = 0;
18675 wxString *arg1 = 0 ;
18676 wxString *arg2 = 0 ;
18677 wxString const &arg3_defvalue = wxPyEmptyString ;
18678 wxString *arg3 = (wxString *) &arg3_defvalue ;
18679 wxString result;
18680 bool temp1 = false ;
18681 bool temp2 = false ;
18682 bool temp3 = false ;
18683 PyObject * obj0 = 0 ;
18684 PyObject * obj1 = 0 ;
18685 PyObject * obj2 = 0 ;
18686 char * kwnames[] = {
18687 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18688 };
18689
18690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18691 {
18692 arg1 = wxString_in_helper(obj0);
18693 if (arg1 == NULL) SWIG_fail;
18694 temp1 = true;
18695 }
18696 {
18697 arg2 = wxString_in_helper(obj1);
18698 if (arg2 == NULL) SWIG_fail;
18699 temp2 = true;
18700 }
18701 if (obj2) {
18702 {
18703 arg3 = wxString_in_helper(obj2);
18704 if (arg3 == NULL) SWIG_fail;
18705 temp3 = true;
18706 }
18707 }
18708 {
18709 PyThreadState* __tstate = wxPyBeginAllowThreads();
18710 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18711 wxPyEndAllowThreads(__tstate);
18712 if (PyErr_Occurred()) SWIG_fail;
18713 }
18714 {
18715 #if wxUSE_UNICODE
18716 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18717 #else
18718 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18719 #endif
18720 }
18721 {
18722 if (temp1)
18723 delete arg1;
18724 }
18725 {
18726 if (temp2)
18727 delete arg2;
18728 }
18729 {
18730 if (temp3)
18731 delete arg3;
18732 }
18733 return resultobj;
18734 fail:
18735 {
18736 if (temp1)
18737 delete arg1;
18738 }
18739 {
18740 if (temp2)
18741 delete arg2;
18742 }
18743 {
18744 if (temp3)
18745 delete arg3;
18746 }
18747 return NULL;
18748 }
18749
18750
18751 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18752 PyObject *obj;
18753 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18754 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18755 return SWIG_Py_Void();
18756 }
18757
18758 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18759 return SWIG_Python_InitShadowInstance(args);
18760 }
18761
18762 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18763 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18764 return 1;
18765 }
18766
18767
18768 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18769 PyObject *pyobj = 0;
18770
18771 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18772 return pyobj;
18773 }
18774
18775
18776 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18777 PyObject *resultobj = 0;
18778 wxString *arg1 = 0 ;
18779 wxString *arg2 = 0 ;
18780 bool result;
18781 bool temp1 = false ;
18782 bool temp2 = false ;
18783 PyObject * obj0 = 0 ;
18784 PyObject * obj1 = 0 ;
18785 char * kwnames[] = {
18786 (char *) "mimeType",(char *) "wildcard", NULL
18787 };
18788
18789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18790 {
18791 arg1 = wxString_in_helper(obj0);
18792 if (arg1 == NULL) SWIG_fail;
18793 temp1 = true;
18794 }
18795 {
18796 arg2 = wxString_in_helper(obj1);
18797 if (arg2 == NULL) SWIG_fail;
18798 temp2 = true;
18799 }
18800 {
18801 PyThreadState* __tstate = wxPyBeginAllowThreads();
18802 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18803 wxPyEndAllowThreads(__tstate);
18804 if (PyErr_Occurred()) SWIG_fail;
18805 }
18806 {
18807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18808 }
18809 {
18810 if (temp1)
18811 delete arg1;
18812 }
18813 {
18814 if (temp2)
18815 delete arg2;
18816 }
18817 return resultobj;
18818 fail:
18819 {
18820 if (temp1)
18821 delete arg1;
18822 }
18823 {
18824 if (temp2)
18825 delete arg2;
18826 }
18827 return NULL;
18828 }
18829
18830
18831 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18832 PyObject *resultobj = 0;
18833 wxMimeTypesManager *result = 0 ;
18834
18835 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18836 {
18837 PyThreadState* __tstate = wxPyBeginAllowThreads();
18838 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18839 wxPyEndAllowThreads(__tstate);
18840 if (PyErr_Occurred()) SWIG_fail;
18841 }
18842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18843 return resultobj;
18844 fail:
18845 return NULL;
18846 }
18847
18848
18849 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18850 PyObject *resultobj = 0;
18851 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18852 int arg2 = (int) wxMAILCAP_ALL ;
18853 wxString const &arg3_defvalue = wxPyEmptyString ;
18854 wxString *arg3 = (wxString *) &arg3_defvalue ;
18855 void *argp1 = 0 ;
18856 int res1 = 0 ;
18857 int val2 ;
18858 int ecode2 = 0 ;
18859 bool temp3 = false ;
18860 PyObject * obj0 = 0 ;
18861 PyObject * obj1 = 0 ;
18862 PyObject * obj2 = 0 ;
18863 char * kwnames[] = {
18864 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18865 };
18866
18867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) 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_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18871 }
18872 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18873 if (obj1) {
18874 ecode2 = SWIG_AsVal_int(obj1, &val2);
18875 if (!SWIG_IsOK(ecode2)) {
18876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18877 }
18878 arg2 = static_cast< int >(val2);
18879 }
18880 if (obj2) {
18881 {
18882 arg3 = wxString_in_helper(obj2);
18883 if (arg3 == NULL) SWIG_fail;
18884 temp3 = true;
18885 }
18886 }
18887 {
18888 PyThreadState* __tstate = wxPyBeginAllowThreads();
18889 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18890 wxPyEndAllowThreads(__tstate);
18891 if (PyErr_Occurred()) SWIG_fail;
18892 }
18893 resultobj = SWIG_Py_Void();
18894 {
18895 if (temp3)
18896 delete arg3;
18897 }
18898 return resultobj;
18899 fail:
18900 {
18901 if (temp3)
18902 delete arg3;
18903 }
18904 return NULL;
18905 }
18906
18907
18908 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18909 PyObject *resultobj = 0;
18910 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18911 void *argp1 = 0 ;
18912 int res1 = 0 ;
18913 PyObject *swig_obj[1] ;
18914
18915 if (!args) SWIG_fail;
18916 swig_obj[0] = args;
18917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18918 if (!SWIG_IsOK(res1)) {
18919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18920 }
18921 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18922 {
18923 PyThreadState* __tstate = wxPyBeginAllowThreads();
18924 (arg1)->ClearData();
18925 wxPyEndAllowThreads(__tstate);
18926 if (PyErr_Occurred()) SWIG_fail;
18927 }
18928 resultobj = SWIG_Py_Void();
18929 return resultobj;
18930 fail:
18931 return NULL;
18932 }
18933
18934
18935 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18936 PyObject *resultobj = 0;
18937 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18938 wxString *arg2 = 0 ;
18939 wxFileType *result = 0 ;
18940 void *argp1 = 0 ;
18941 int res1 = 0 ;
18942 bool temp2 = false ;
18943 PyObject * obj0 = 0 ;
18944 PyObject * obj1 = 0 ;
18945 char * kwnames[] = {
18946 (char *) "self",(char *) "ext", NULL
18947 };
18948
18949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18951 if (!SWIG_IsOK(res1)) {
18952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18953 }
18954 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18955 {
18956 arg2 = wxString_in_helper(obj1);
18957 if (arg2 == NULL) SWIG_fail;
18958 temp2 = true;
18959 }
18960 {
18961 PyThreadState* __tstate = wxPyBeginAllowThreads();
18962 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18963 wxPyEndAllowThreads(__tstate);
18964 if (PyErr_Occurred()) SWIG_fail;
18965 }
18966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18967 {
18968 if (temp2)
18969 delete arg2;
18970 }
18971 return resultobj;
18972 fail:
18973 {
18974 if (temp2)
18975 delete arg2;
18976 }
18977 return NULL;
18978 }
18979
18980
18981 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18982 PyObject *resultobj = 0;
18983 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18984 wxString *arg2 = 0 ;
18985 wxFileType *result = 0 ;
18986 void *argp1 = 0 ;
18987 int res1 = 0 ;
18988 bool temp2 = false ;
18989 PyObject * obj0 = 0 ;
18990 PyObject * obj1 = 0 ;
18991 char * kwnames[] = {
18992 (char *) "self",(char *) "mimeType", NULL
18993 };
18994
18995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
18996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18997 if (!SWIG_IsOK(res1)) {
18998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18999 }
19000 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19001 {
19002 arg2 = wxString_in_helper(obj1);
19003 if (arg2 == NULL) SWIG_fail;
19004 temp2 = true;
19005 }
19006 {
19007 PyThreadState* __tstate = wxPyBeginAllowThreads();
19008 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
19009 wxPyEndAllowThreads(__tstate);
19010 if (PyErr_Occurred()) SWIG_fail;
19011 }
19012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19013 {
19014 if (temp2)
19015 delete arg2;
19016 }
19017 return resultobj;
19018 fail:
19019 {
19020 if (temp2)
19021 delete arg2;
19022 }
19023 return NULL;
19024 }
19025
19026
19027 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19028 PyObject *resultobj = 0;
19029 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19030 wxString *arg2 = 0 ;
19031 bool arg3 = (bool) false ;
19032 bool result;
19033 void *argp1 = 0 ;
19034 int res1 = 0 ;
19035 bool temp2 = false ;
19036 bool val3 ;
19037 int ecode3 = 0 ;
19038 PyObject * obj0 = 0 ;
19039 PyObject * obj1 = 0 ;
19040 PyObject * obj2 = 0 ;
19041 char * kwnames[] = {
19042 (char *) "self",(char *) "filename",(char *) "fallback", NULL
19043 };
19044
19045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19047 if (!SWIG_IsOK(res1)) {
19048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19049 }
19050 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19051 {
19052 arg2 = wxString_in_helper(obj1);
19053 if (arg2 == NULL) SWIG_fail;
19054 temp2 = true;
19055 }
19056 if (obj2) {
19057 ecode3 = SWIG_AsVal_bool(obj2, &val3);
19058 if (!SWIG_IsOK(ecode3)) {
19059 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
19060 }
19061 arg3 = static_cast< bool >(val3);
19062 }
19063 {
19064 PyThreadState* __tstate = wxPyBeginAllowThreads();
19065 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
19066 wxPyEndAllowThreads(__tstate);
19067 if (PyErr_Occurred()) SWIG_fail;
19068 }
19069 {
19070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19071 }
19072 {
19073 if (temp2)
19074 delete arg2;
19075 }
19076 return resultobj;
19077 fail:
19078 {
19079 if (temp2)
19080 delete arg2;
19081 }
19082 return NULL;
19083 }
19084
19085
19086 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19087 PyObject *resultobj = 0;
19088 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19089 wxString *arg2 = 0 ;
19090 bool result;
19091 void *argp1 = 0 ;
19092 int res1 = 0 ;
19093 bool temp2 = false ;
19094 PyObject * obj0 = 0 ;
19095 PyObject * obj1 = 0 ;
19096 char * kwnames[] = {
19097 (char *) "self",(char *) "filename", NULL
19098 };
19099
19100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19102 if (!SWIG_IsOK(res1)) {
19103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19104 }
19105 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19106 {
19107 arg2 = wxString_in_helper(obj1);
19108 if (arg2 == NULL) SWIG_fail;
19109 temp2 = true;
19110 }
19111 {
19112 PyThreadState* __tstate = wxPyBeginAllowThreads();
19113 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19114 wxPyEndAllowThreads(__tstate);
19115 if (PyErr_Occurred()) SWIG_fail;
19116 }
19117 {
19118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19119 }
19120 {
19121 if (temp2)
19122 delete arg2;
19123 }
19124 return resultobj;
19125 fail:
19126 {
19127 if (temp2)
19128 delete arg2;
19129 }
19130 return NULL;
19131 }
19132
19133
19134 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19135 PyObject *resultobj = 0;
19136 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19137 PyObject *result = 0 ;
19138 void *argp1 = 0 ;
19139 int res1 = 0 ;
19140 PyObject *swig_obj[1] ;
19141
19142 if (!args) SWIG_fail;
19143 swig_obj[0] = args;
19144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19145 if (!SWIG_IsOK(res1)) {
19146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19147 }
19148 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19149 {
19150 PyThreadState* __tstate = wxPyBeginAllowThreads();
19151 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19152 wxPyEndAllowThreads(__tstate);
19153 if (PyErr_Occurred()) SWIG_fail;
19154 }
19155 resultobj = result;
19156 return resultobj;
19157 fail:
19158 return NULL;
19159 }
19160
19161
19162 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19163 PyObject *resultobj = 0;
19164 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19165 wxFileTypeInfo *arg2 = 0 ;
19166 void *argp1 = 0 ;
19167 int res1 = 0 ;
19168 void *argp2 = 0 ;
19169 int res2 = 0 ;
19170 PyObject * obj0 = 0 ;
19171 PyObject * obj1 = 0 ;
19172 char * kwnames[] = {
19173 (char *) "self",(char *) "ft", NULL
19174 };
19175
19176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19178 if (!SWIG_IsOK(res1)) {
19179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19180 }
19181 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19182 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19183 if (!SWIG_IsOK(res2)) {
19184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19185 }
19186 if (!argp2) {
19187 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19188 }
19189 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19190 {
19191 PyThreadState* __tstate = wxPyBeginAllowThreads();
19192 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19193 wxPyEndAllowThreads(__tstate);
19194 if (PyErr_Occurred()) SWIG_fail;
19195 }
19196 resultobj = SWIG_Py_Void();
19197 return resultobj;
19198 fail:
19199 return NULL;
19200 }
19201
19202
19203 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19204 PyObject *resultobj = 0;
19205 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19206 wxFileTypeInfo *arg2 = 0 ;
19207 wxFileType *result = 0 ;
19208 void *argp1 = 0 ;
19209 int res1 = 0 ;
19210 void *argp2 = 0 ;
19211 int res2 = 0 ;
19212 PyObject * obj0 = 0 ;
19213 PyObject * obj1 = 0 ;
19214 char * kwnames[] = {
19215 (char *) "self",(char *) "ftInfo", NULL
19216 };
19217
19218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19220 if (!SWIG_IsOK(res1)) {
19221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19222 }
19223 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19224 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19225 if (!SWIG_IsOK(res2)) {
19226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19227 }
19228 if (!argp2) {
19229 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19230 }
19231 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19232 {
19233 PyThreadState* __tstate = wxPyBeginAllowThreads();
19234 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19235 wxPyEndAllowThreads(__tstate);
19236 if (PyErr_Occurred()) SWIG_fail;
19237 }
19238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19239 return resultobj;
19240 fail:
19241 return NULL;
19242 }
19243
19244
19245 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19246 PyObject *resultobj = 0;
19247 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19248 wxFileType *arg2 = (wxFileType *) 0 ;
19249 bool result;
19250 void *argp1 = 0 ;
19251 int res1 = 0 ;
19252 void *argp2 = 0 ;
19253 int res2 = 0 ;
19254 PyObject * obj0 = 0 ;
19255 PyObject * obj1 = 0 ;
19256 char * kwnames[] = {
19257 (char *) "self",(char *) "ft", NULL
19258 };
19259
19260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19262 if (!SWIG_IsOK(res1)) {
19263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19264 }
19265 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19266 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19267 if (!SWIG_IsOK(res2)) {
19268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19269 }
19270 arg2 = reinterpret_cast< wxFileType * >(argp2);
19271 {
19272 PyThreadState* __tstate = wxPyBeginAllowThreads();
19273 result = (bool)(arg1)->Unassociate(arg2);
19274 wxPyEndAllowThreads(__tstate);
19275 if (PyErr_Occurred()) SWIG_fail;
19276 }
19277 {
19278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19279 }
19280 return resultobj;
19281 fail:
19282 return NULL;
19283 }
19284
19285
19286 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19287 PyObject *resultobj = 0;
19288 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19289 void *argp1 = 0 ;
19290 int res1 = 0 ;
19291 PyObject *swig_obj[1] ;
19292
19293 if (!args) SWIG_fail;
19294 swig_obj[0] = args;
19295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19296 if (!SWIG_IsOK(res1)) {
19297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19298 }
19299 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19300 {
19301 PyThreadState* __tstate = wxPyBeginAllowThreads();
19302 delete arg1;
19303
19304 wxPyEndAllowThreads(__tstate);
19305 if (PyErr_Occurred()) SWIG_fail;
19306 }
19307 resultobj = SWIG_Py_Void();
19308 return resultobj;
19309 fail:
19310 return NULL;
19311 }
19312
19313
19314 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19315 PyObject *obj;
19316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19317 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19318 return SWIG_Py_Void();
19319 }
19320
19321 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19322 return SWIG_Python_InitShadowInstance(args);
19323 }
19324
19325 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19326 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19327 return 1;
19328 }
19329
19330
19331 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19332 PyObject *pyobj = 0;
19333
19334 {
19335 #if wxUSE_UNICODE
19336 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19337 #else
19338 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19339 #endif
19340 }
19341 return pyobj;
19342 }
19343
19344
19345 SWIGINTERN int ART_MENU_set(PyObject *) {
19346 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19347 return 1;
19348 }
19349
19350
19351 SWIGINTERN PyObject *ART_MENU_get(void) {
19352 PyObject *pyobj = 0;
19353
19354 {
19355 #if wxUSE_UNICODE
19356 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19357 #else
19358 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19359 #endif
19360 }
19361 return pyobj;
19362 }
19363
19364
19365 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19366 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19367 return 1;
19368 }
19369
19370
19371 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19372 PyObject *pyobj = 0;
19373
19374 {
19375 #if wxUSE_UNICODE
19376 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19377 #else
19378 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19379 #endif
19380 }
19381 return pyobj;
19382 }
19383
19384
19385 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19386 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19387 return 1;
19388 }
19389
19390
19391 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19392 PyObject *pyobj = 0;
19393
19394 {
19395 #if wxUSE_UNICODE
19396 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19397 #else
19398 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19399 #endif
19400 }
19401 return pyobj;
19402 }
19403
19404
19405 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19406 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19407 return 1;
19408 }
19409
19410
19411 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19412 PyObject *pyobj = 0;
19413
19414 {
19415 #if wxUSE_UNICODE
19416 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19417 #else
19418 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19419 #endif
19420 }
19421 return pyobj;
19422 }
19423
19424
19425 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19426 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19427 return 1;
19428 }
19429
19430
19431 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19432 PyObject *pyobj = 0;
19433
19434 {
19435 #if wxUSE_UNICODE
19436 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19437 #else
19438 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19439 #endif
19440 }
19441 return pyobj;
19442 }
19443
19444
19445 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19446 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19447 return 1;
19448 }
19449
19450
19451 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19452 PyObject *pyobj = 0;
19453
19454 {
19455 #if wxUSE_UNICODE
19456 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19457 #else
19458 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19459 #endif
19460 }
19461 return pyobj;
19462 }
19463
19464
19465 SWIGINTERN int ART_OTHER_set(PyObject *) {
19466 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19467 return 1;
19468 }
19469
19470
19471 SWIGINTERN PyObject *ART_OTHER_get(void) {
19472 PyObject *pyobj = 0;
19473
19474 {
19475 #if wxUSE_UNICODE
19476 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19477 #else
19478 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19479 #endif
19480 }
19481 return pyobj;
19482 }
19483
19484
19485 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19486 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19487 return 1;
19488 }
19489
19490
19491 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19492 PyObject *pyobj = 0;
19493
19494 {
19495 #if wxUSE_UNICODE
19496 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19497 #else
19498 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19499 #endif
19500 }
19501 return pyobj;
19502 }
19503
19504
19505 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19506 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19507 return 1;
19508 }
19509
19510
19511 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19512 PyObject *pyobj = 0;
19513
19514 {
19515 #if wxUSE_UNICODE
19516 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19517 #else
19518 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19519 #endif
19520 }
19521 return pyobj;
19522 }
19523
19524
19525 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19526 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19527 return 1;
19528 }
19529
19530
19531 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19532 PyObject *pyobj = 0;
19533
19534 {
19535 #if wxUSE_UNICODE
19536 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19537 #else
19538 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19539 #endif
19540 }
19541 return pyobj;
19542 }
19543
19544
19545 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19546 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19547 return 1;
19548 }
19549
19550
19551 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19552 PyObject *pyobj = 0;
19553
19554 {
19555 #if wxUSE_UNICODE
19556 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19557 #else
19558 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19559 #endif
19560 }
19561 return pyobj;
19562 }
19563
19564
19565 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19566 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19567 return 1;
19568 }
19569
19570
19571 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19572 PyObject *pyobj = 0;
19573
19574 {
19575 #if wxUSE_UNICODE
19576 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19577 #else
19578 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19579 #endif
19580 }
19581 return pyobj;
19582 }
19583
19584
19585 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19586 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19587 return 1;
19588 }
19589
19590
19591 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19592 PyObject *pyobj = 0;
19593
19594 {
19595 #if wxUSE_UNICODE
19596 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19597 #else
19598 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19599 #endif
19600 }
19601 return pyobj;
19602 }
19603
19604
19605 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19606 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19607 return 1;
19608 }
19609
19610
19611 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19612 PyObject *pyobj = 0;
19613
19614 {
19615 #if wxUSE_UNICODE
19616 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19617 #else
19618 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19619 #endif
19620 }
19621 return pyobj;
19622 }
19623
19624
19625 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19626 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19627 return 1;
19628 }
19629
19630
19631 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19632 PyObject *pyobj = 0;
19633
19634 {
19635 #if wxUSE_UNICODE
19636 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19637 #else
19638 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19639 #endif
19640 }
19641 return pyobj;
19642 }
19643
19644
19645 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19646 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19647 return 1;
19648 }
19649
19650
19651 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19652 PyObject *pyobj = 0;
19653
19654 {
19655 #if wxUSE_UNICODE
19656 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19657 #else
19658 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19659 #endif
19660 }
19661 return pyobj;
19662 }
19663
19664
19665 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19666 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19667 return 1;
19668 }
19669
19670
19671 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19672 PyObject *pyobj = 0;
19673
19674 {
19675 #if wxUSE_UNICODE
19676 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19677 #else
19678 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19679 #endif
19680 }
19681 return pyobj;
19682 }
19683
19684
19685 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19686 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19687 return 1;
19688 }
19689
19690
19691 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19692 PyObject *pyobj = 0;
19693
19694 {
19695 #if wxUSE_UNICODE
19696 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19697 #else
19698 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19699 #endif
19700 }
19701 return pyobj;
19702 }
19703
19704
19705 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19706 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19707 return 1;
19708 }
19709
19710
19711 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19712 PyObject *pyobj = 0;
19713
19714 {
19715 #if wxUSE_UNICODE
19716 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19717 #else
19718 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19719 #endif
19720 }
19721 return pyobj;
19722 }
19723
19724
19725 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19726 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19727 return 1;
19728 }
19729
19730
19731 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19732 PyObject *pyobj = 0;
19733
19734 {
19735 #if wxUSE_UNICODE
19736 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19737 #else
19738 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19739 #endif
19740 }
19741 return pyobj;
19742 }
19743
19744
19745 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19746 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19747 return 1;
19748 }
19749
19750
19751 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19752 PyObject *pyobj = 0;
19753
19754 {
19755 #if wxUSE_UNICODE
19756 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19757 #else
19758 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19759 #endif
19760 }
19761 return pyobj;
19762 }
19763
19764
19765 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19766 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19767 return 1;
19768 }
19769
19770
19771 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19772 PyObject *pyobj = 0;
19773
19774 {
19775 #if wxUSE_UNICODE
19776 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19777 #else
19778 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19779 #endif
19780 }
19781 return pyobj;
19782 }
19783
19784
19785 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19786 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19787 return 1;
19788 }
19789
19790
19791 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19792 PyObject *pyobj = 0;
19793
19794 {
19795 #if wxUSE_UNICODE
19796 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19797 #else
19798 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19799 #endif
19800 }
19801 return pyobj;
19802 }
19803
19804
19805 SWIGINTERN int ART_PRINT_set(PyObject *) {
19806 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19807 return 1;
19808 }
19809
19810
19811 SWIGINTERN PyObject *ART_PRINT_get(void) {
19812 PyObject *pyobj = 0;
19813
19814 {
19815 #if wxUSE_UNICODE
19816 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19817 #else
19818 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19819 #endif
19820 }
19821 return pyobj;
19822 }
19823
19824
19825 SWIGINTERN int ART_HELP_set(PyObject *) {
19826 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19827 return 1;
19828 }
19829
19830
19831 SWIGINTERN PyObject *ART_HELP_get(void) {
19832 PyObject *pyobj = 0;
19833
19834 {
19835 #if wxUSE_UNICODE
19836 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19837 #else
19838 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19839 #endif
19840 }
19841 return pyobj;
19842 }
19843
19844
19845 SWIGINTERN int ART_TIP_set(PyObject *) {
19846 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19847 return 1;
19848 }
19849
19850
19851 SWIGINTERN PyObject *ART_TIP_get(void) {
19852 PyObject *pyobj = 0;
19853
19854 {
19855 #if wxUSE_UNICODE
19856 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19857 #else
19858 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19859 #endif
19860 }
19861 return pyobj;
19862 }
19863
19864
19865 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19866 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19867 return 1;
19868 }
19869
19870
19871 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19872 PyObject *pyobj = 0;
19873
19874 {
19875 #if wxUSE_UNICODE
19876 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19877 #else
19878 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19879 #endif
19880 }
19881 return pyobj;
19882 }
19883
19884
19885 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19886 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19887 return 1;
19888 }
19889
19890
19891 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19892 PyObject *pyobj = 0;
19893
19894 {
19895 #if wxUSE_UNICODE
19896 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19897 #else
19898 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19899 #endif
19900 }
19901 return pyobj;
19902 }
19903
19904
19905 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19906 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19907 return 1;
19908 }
19909
19910
19911 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19912 PyObject *pyobj = 0;
19913
19914 {
19915 #if wxUSE_UNICODE
19916 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19917 #else
19918 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19919 #endif
19920 }
19921 return pyobj;
19922 }
19923
19924
19925 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19926 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19927 return 1;
19928 }
19929
19930
19931 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19932 PyObject *pyobj = 0;
19933
19934 {
19935 #if wxUSE_UNICODE
19936 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19937 #else
19938 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19939 #endif
19940 }
19941 return pyobj;
19942 }
19943
19944
19945 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19946 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19947 return 1;
19948 }
19949
19950
19951 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19952 PyObject *pyobj = 0;
19953
19954 {
19955 #if wxUSE_UNICODE
19956 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19957 #else
19958 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19959 #endif
19960 }
19961 return pyobj;
19962 }
19963
19964
19965 SWIGINTERN int ART_CDROM_set(PyObject *) {
19966 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19967 return 1;
19968 }
19969
19970
19971 SWIGINTERN PyObject *ART_CDROM_get(void) {
19972 PyObject *pyobj = 0;
19973
19974 {
19975 #if wxUSE_UNICODE
19976 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19977 #else
19978 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19979 #endif
19980 }
19981 return pyobj;
19982 }
19983
19984
19985 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19986 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19987 return 1;
19988 }
19989
19990
19991 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
19992 PyObject *pyobj = 0;
19993
19994 {
19995 #if wxUSE_UNICODE
19996 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19997 #else
19998 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19999 #endif
20000 }
20001 return pyobj;
20002 }
20003
20004
20005 SWIGINTERN int ART_FOLDER_set(PyObject *) {
20006 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
20007 return 1;
20008 }
20009
20010
20011 SWIGINTERN PyObject *ART_FOLDER_get(void) {
20012 PyObject *pyobj = 0;
20013
20014 {
20015 #if wxUSE_UNICODE
20016 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20017 #else
20018 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20019 #endif
20020 }
20021 return pyobj;
20022 }
20023
20024
20025 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
20026 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
20027 return 1;
20028 }
20029
20030
20031 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
20032 PyObject *pyobj = 0;
20033
20034 {
20035 #if wxUSE_UNICODE
20036 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20037 #else
20038 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20039 #endif
20040 }
20041 return pyobj;
20042 }
20043
20044
20045 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
20046 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
20047 return 1;
20048 }
20049
20050
20051 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
20052 PyObject *pyobj = 0;
20053
20054 {
20055 #if wxUSE_UNICODE
20056 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20057 #else
20058 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20059 #endif
20060 }
20061 return pyobj;
20062 }
20063
20064
20065 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
20066 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
20067 return 1;
20068 }
20069
20070
20071 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
20072 PyObject *pyobj = 0;
20073
20074 {
20075 #if wxUSE_UNICODE
20076 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20077 #else
20078 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20079 #endif
20080 }
20081 return pyobj;
20082 }
20083
20084
20085 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
20086 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
20087 return 1;
20088 }
20089
20090
20091 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20092 PyObject *pyobj = 0;
20093
20094 {
20095 #if wxUSE_UNICODE
20096 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20097 #else
20098 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20099 #endif
20100 }
20101 return pyobj;
20102 }
20103
20104
20105 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20106 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20107 return 1;
20108 }
20109
20110
20111 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20112 PyObject *pyobj = 0;
20113
20114 {
20115 #if wxUSE_UNICODE
20116 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20117 #else
20118 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20119 #endif
20120 }
20121 return pyobj;
20122 }
20123
20124
20125 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20126 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20127 return 1;
20128 }
20129
20130
20131 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20132 PyObject *pyobj = 0;
20133
20134 {
20135 #if wxUSE_UNICODE
20136 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20137 #else
20138 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20139 #endif
20140 }
20141 return pyobj;
20142 }
20143
20144
20145 SWIGINTERN int ART_ERROR_set(PyObject *) {
20146 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20147 return 1;
20148 }
20149
20150
20151 SWIGINTERN PyObject *ART_ERROR_get(void) {
20152 PyObject *pyobj = 0;
20153
20154 {
20155 #if wxUSE_UNICODE
20156 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20157 #else
20158 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20159 #endif
20160 }
20161 return pyobj;
20162 }
20163
20164
20165 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20166 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20167 return 1;
20168 }
20169
20170
20171 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20172 PyObject *pyobj = 0;
20173
20174 {
20175 #if wxUSE_UNICODE
20176 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20177 #else
20178 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20179 #endif
20180 }
20181 return pyobj;
20182 }
20183
20184
20185 SWIGINTERN int ART_WARNING_set(PyObject *) {
20186 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20187 return 1;
20188 }
20189
20190
20191 SWIGINTERN PyObject *ART_WARNING_get(void) {
20192 PyObject *pyobj = 0;
20193
20194 {
20195 #if wxUSE_UNICODE
20196 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20197 #else
20198 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20199 #endif
20200 }
20201 return pyobj;
20202 }
20203
20204
20205 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20206 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20207 return 1;
20208 }
20209
20210
20211 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20212 PyObject *pyobj = 0;
20213
20214 {
20215 #if wxUSE_UNICODE
20216 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20217 #else
20218 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20219 #endif
20220 }
20221 return pyobj;
20222 }
20223
20224
20225 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20226 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20227 return 1;
20228 }
20229
20230
20231 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20232 PyObject *pyobj = 0;
20233
20234 {
20235 #if wxUSE_UNICODE
20236 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20237 #else
20238 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20239 #endif
20240 }
20241 return pyobj;
20242 }
20243
20244
20245 SWIGINTERN int ART_COPY_set(PyObject *) {
20246 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20247 return 1;
20248 }
20249
20250
20251 SWIGINTERN PyObject *ART_COPY_get(void) {
20252 PyObject *pyobj = 0;
20253
20254 {
20255 #if wxUSE_UNICODE
20256 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20257 #else
20258 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20259 #endif
20260 }
20261 return pyobj;
20262 }
20263
20264
20265 SWIGINTERN int ART_CUT_set(PyObject *) {
20266 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20267 return 1;
20268 }
20269
20270
20271 SWIGINTERN PyObject *ART_CUT_get(void) {
20272 PyObject *pyobj = 0;
20273
20274 {
20275 #if wxUSE_UNICODE
20276 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20277 #else
20278 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20279 #endif
20280 }
20281 return pyobj;
20282 }
20283
20284
20285 SWIGINTERN int ART_PASTE_set(PyObject *) {
20286 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20287 return 1;
20288 }
20289
20290
20291 SWIGINTERN PyObject *ART_PASTE_get(void) {
20292 PyObject *pyobj = 0;
20293
20294 {
20295 #if wxUSE_UNICODE
20296 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20297 #else
20298 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20299 #endif
20300 }
20301 return pyobj;
20302 }
20303
20304
20305 SWIGINTERN int ART_DELETE_set(PyObject *) {
20306 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20307 return 1;
20308 }
20309
20310
20311 SWIGINTERN PyObject *ART_DELETE_get(void) {
20312 PyObject *pyobj = 0;
20313
20314 {
20315 #if wxUSE_UNICODE
20316 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20317 #else
20318 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20319 #endif
20320 }
20321 return pyobj;
20322 }
20323
20324
20325 SWIGINTERN int ART_NEW_set(PyObject *) {
20326 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20327 return 1;
20328 }
20329
20330
20331 SWIGINTERN PyObject *ART_NEW_get(void) {
20332 PyObject *pyobj = 0;
20333
20334 {
20335 #if wxUSE_UNICODE
20336 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20337 #else
20338 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20339 #endif
20340 }
20341 return pyobj;
20342 }
20343
20344
20345 SWIGINTERN int ART_UNDO_set(PyObject *) {
20346 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20347 return 1;
20348 }
20349
20350
20351 SWIGINTERN PyObject *ART_UNDO_get(void) {
20352 PyObject *pyobj = 0;
20353
20354 {
20355 #if wxUSE_UNICODE
20356 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20357 #else
20358 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20359 #endif
20360 }
20361 return pyobj;
20362 }
20363
20364
20365 SWIGINTERN int ART_REDO_set(PyObject *) {
20366 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20367 return 1;
20368 }
20369
20370
20371 SWIGINTERN PyObject *ART_REDO_get(void) {
20372 PyObject *pyobj = 0;
20373
20374 {
20375 #if wxUSE_UNICODE
20376 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20377 #else
20378 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20379 #endif
20380 }
20381 return pyobj;
20382 }
20383
20384
20385 SWIGINTERN int ART_QUIT_set(PyObject *) {
20386 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20387 return 1;
20388 }
20389
20390
20391 SWIGINTERN PyObject *ART_QUIT_get(void) {
20392 PyObject *pyobj = 0;
20393
20394 {
20395 #if wxUSE_UNICODE
20396 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20397 #else
20398 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20399 #endif
20400 }
20401 return pyobj;
20402 }
20403
20404
20405 SWIGINTERN int ART_FIND_set(PyObject *) {
20406 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20407 return 1;
20408 }
20409
20410
20411 SWIGINTERN PyObject *ART_FIND_get(void) {
20412 PyObject *pyobj = 0;
20413
20414 {
20415 #if wxUSE_UNICODE
20416 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20417 #else
20418 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20419 #endif
20420 }
20421 return pyobj;
20422 }
20423
20424
20425 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20426 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20427 return 1;
20428 }
20429
20430
20431 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20432 PyObject *pyobj = 0;
20433
20434 {
20435 #if wxUSE_UNICODE
20436 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20437 #else
20438 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20439 #endif
20440 }
20441 return pyobj;
20442 }
20443
20444
20445 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20446 PyObject *resultobj = 0;
20447 wxPyArtProvider *result = 0 ;
20448
20449 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20450 {
20451 if (!wxPyCheckForApp()) SWIG_fail;
20452 PyThreadState* __tstate = wxPyBeginAllowThreads();
20453 result = (wxPyArtProvider *)new wxPyArtProvider();
20454 wxPyEndAllowThreads(__tstate);
20455 if (PyErr_Occurred()) SWIG_fail;
20456 }
20457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20458 return resultobj;
20459 fail:
20460 return NULL;
20461 }
20462
20463
20464 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20465 PyObject *resultobj = 0;
20466 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20467 void *argp1 = 0 ;
20468 int res1 = 0 ;
20469 PyObject *swig_obj[1] ;
20470
20471 if (!args) SWIG_fail;
20472 swig_obj[0] = args;
20473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20474 if (!SWIG_IsOK(res1)) {
20475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20476 }
20477 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20478 {
20479 PyThreadState* __tstate = wxPyBeginAllowThreads();
20480 delete arg1;
20481
20482 wxPyEndAllowThreads(__tstate);
20483 if (PyErr_Occurred()) SWIG_fail;
20484 }
20485 resultobj = SWIG_Py_Void();
20486 return resultobj;
20487 fail:
20488 return NULL;
20489 }
20490
20491
20492 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20493 PyObject *resultobj = 0;
20494 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20495 PyObject *arg2 = (PyObject *) 0 ;
20496 PyObject *arg3 = (PyObject *) 0 ;
20497 void *argp1 = 0 ;
20498 int res1 = 0 ;
20499 PyObject * obj0 = 0 ;
20500 PyObject * obj1 = 0 ;
20501 PyObject * obj2 = 0 ;
20502 char * kwnames[] = {
20503 (char *) "self",(char *) "self",(char *) "_class", NULL
20504 };
20505
20506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20508 if (!SWIG_IsOK(res1)) {
20509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20510 }
20511 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20512 arg2 = obj1;
20513 arg3 = obj2;
20514 {
20515 PyThreadState* __tstate = wxPyBeginAllowThreads();
20516 (arg1)->_setCallbackInfo(arg2,arg3);
20517 wxPyEndAllowThreads(__tstate);
20518 if (PyErr_Occurred()) SWIG_fail;
20519 }
20520 resultobj = SWIG_Py_Void();
20521 return resultobj;
20522 fail:
20523 return NULL;
20524 }
20525
20526
20527 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20528 PyObject *resultobj = 0;
20529 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20530 int res1 = 0 ;
20531 PyObject * obj0 = 0 ;
20532 char * kwnames[] = {
20533 (char *) "provider", NULL
20534 };
20535
20536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20537 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20538 if (!SWIG_IsOK(res1)) {
20539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20540 }
20541 {
20542 PyThreadState* __tstate = wxPyBeginAllowThreads();
20543 wxPyArtProvider::Push(arg1);
20544 wxPyEndAllowThreads(__tstate);
20545 if (PyErr_Occurred()) SWIG_fail;
20546 }
20547 resultobj = SWIG_Py_Void();
20548 return resultobj;
20549 fail:
20550 return NULL;
20551 }
20552
20553
20554 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20555 PyObject *resultobj = 0;
20556 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20557 int res1 = 0 ;
20558 PyObject * obj0 = 0 ;
20559 char * kwnames[] = {
20560 (char *) "provider", NULL
20561 };
20562
20563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20564 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20565 if (!SWIG_IsOK(res1)) {
20566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20567 }
20568 {
20569 PyThreadState* __tstate = wxPyBeginAllowThreads();
20570 wxPyArtProvider::Insert(arg1);
20571 wxPyEndAllowThreads(__tstate);
20572 if (PyErr_Occurred()) SWIG_fail;
20573 }
20574 resultobj = SWIG_Py_Void();
20575 return resultobj;
20576 fail:
20577 return NULL;
20578 }
20579
20580
20581 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20582 PyObject *resultobj = 0;
20583 bool result;
20584
20585 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20586 {
20587 PyThreadState* __tstate = wxPyBeginAllowThreads();
20588 result = (bool)wxPyArtProvider::Pop();
20589 wxPyEndAllowThreads(__tstate);
20590 if (PyErr_Occurred()) SWIG_fail;
20591 }
20592 {
20593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20594 }
20595 return resultobj;
20596 fail:
20597 return NULL;
20598 }
20599
20600
20601 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20602 PyObject *resultobj = 0;
20603 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20604 bool result;
20605 void *argp1 = 0 ;
20606 int res1 = 0 ;
20607 PyObject * obj0 = 0 ;
20608 char * kwnames[] = {
20609 (char *) "provider", NULL
20610 };
20611
20612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20614 if (!SWIG_IsOK(res1)) {
20615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20616 }
20617 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20618 {
20619 PyThreadState* __tstate = wxPyBeginAllowThreads();
20620 result = (bool)wxPyArtProvider::Delete(arg1);
20621 wxPyEndAllowThreads(__tstate);
20622 if (PyErr_Occurred()) SWIG_fail;
20623 }
20624 {
20625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20626 }
20627 return resultobj;
20628 fail:
20629 return NULL;
20630 }
20631
20632
20633 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20634 PyObject *resultobj = 0;
20635 wxString *arg1 = 0 ;
20636 wxString const &arg2_defvalue = wxPyART_OTHER ;
20637 wxString *arg2 = (wxString *) &arg2_defvalue ;
20638 wxSize const &arg3_defvalue = wxDefaultSize ;
20639 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20640 wxBitmap result;
20641 bool temp1 = false ;
20642 bool temp2 = false ;
20643 wxSize temp3 ;
20644 PyObject * obj0 = 0 ;
20645 PyObject * obj1 = 0 ;
20646 PyObject * obj2 = 0 ;
20647 char * kwnames[] = {
20648 (char *) "id",(char *) "client",(char *) "size", NULL
20649 };
20650
20651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20652 {
20653 arg1 = wxString_in_helper(obj0);
20654 if (arg1 == NULL) SWIG_fail;
20655 temp1 = true;
20656 }
20657 if (obj1) {
20658 {
20659 arg2 = wxString_in_helper(obj1);
20660 if (arg2 == NULL) SWIG_fail;
20661 temp2 = true;
20662 }
20663 }
20664 if (obj2) {
20665 {
20666 arg3 = &temp3;
20667 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20668 }
20669 }
20670 {
20671 if (!wxPyCheckForApp()) SWIG_fail;
20672 PyThreadState* __tstate = wxPyBeginAllowThreads();
20673 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20674 wxPyEndAllowThreads(__tstate);
20675 if (PyErr_Occurred()) SWIG_fail;
20676 }
20677 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20678 {
20679 if (temp1)
20680 delete arg1;
20681 }
20682 {
20683 if (temp2)
20684 delete arg2;
20685 }
20686 return resultobj;
20687 fail:
20688 {
20689 if (temp1)
20690 delete arg1;
20691 }
20692 {
20693 if (temp2)
20694 delete arg2;
20695 }
20696 return NULL;
20697 }
20698
20699
20700 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20701 PyObject *resultobj = 0;
20702 wxString *arg1 = 0 ;
20703 wxString const &arg2_defvalue = wxPyART_OTHER ;
20704 wxString *arg2 = (wxString *) &arg2_defvalue ;
20705 wxSize const &arg3_defvalue = wxDefaultSize ;
20706 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20707 wxIcon result;
20708 bool temp1 = false ;
20709 bool temp2 = false ;
20710 wxSize temp3 ;
20711 PyObject * obj0 = 0 ;
20712 PyObject * obj1 = 0 ;
20713 PyObject * obj2 = 0 ;
20714 char * kwnames[] = {
20715 (char *) "id",(char *) "client",(char *) "size", NULL
20716 };
20717
20718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20719 {
20720 arg1 = wxString_in_helper(obj0);
20721 if (arg1 == NULL) SWIG_fail;
20722 temp1 = true;
20723 }
20724 if (obj1) {
20725 {
20726 arg2 = wxString_in_helper(obj1);
20727 if (arg2 == NULL) SWIG_fail;
20728 temp2 = true;
20729 }
20730 }
20731 if (obj2) {
20732 {
20733 arg3 = &temp3;
20734 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20735 }
20736 }
20737 {
20738 if (!wxPyCheckForApp()) SWIG_fail;
20739 PyThreadState* __tstate = wxPyBeginAllowThreads();
20740 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20741 wxPyEndAllowThreads(__tstate);
20742 if (PyErr_Occurred()) SWIG_fail;
20743 }
20744 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20745 {
20746 if (temp1)
20747 delete arg1;
20748 }
20749 {
20750 if (temp2)
20751 delete arg2;
20752 }
20753 return resultobj;
20754 fail:
20755 {
20756 if (temp1)
20757 delete arg1;
20758 }
20759 {
20760 if (temp2)
20761 delete arg2;
20762 }
20763 return NULL;
20764 }
20765
20766
20767 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20768 PyObject *resultobj = 0;
20769 wxString *arg1 = 0 ;
20770 bool arg2 = (bool) false ;
20771 wxSize result;
20772 bool temp1 = false ;
20773 bool val2 ;
20774 int ecode2 = 0 ;
20775 PyObject * obj0 = 0 ;
20776 PyObject * obj1 = 0 ;
20777 char * kwnames[] = {
20778 (char *) "client",(char *) "platform_dependent", NULL
20779 };
20780
20781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20782 {
20783 arg1 = wxString_in_helper(obj0);
20784 if (arg1 == NULL) SWIG_fail;
20785 temp1 = true;
20786 }
20787 if (obj1) {
20788 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20789 if (!SWIG_IsOK(ecode2)) {
20790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20791 }
20792 arg2 = static_cast< bool >(val2);
20793 }
20794 {
20795 PyThreadState* __tstate = wxPyBeginAllowThreads();
20796 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20797 wxPyEndAllowThreads(__tstate);
20798 if (PyErr_Occurred()) SWIG_fail;
20799 }
20800 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20801 {
20802 if (temp1)
20803 delete arg1;
20804 }
20805 return resultobj;
20806 fail:
20807 {
20808 if (temp1)
20809 delete arg1;
20810 }
20811 return NULL;
20812 }
20813
20814
20815 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20816 PyObject *resultobj = 0;
20817 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20818 void *argp1 = 0 ;
20819 int res1 = 0 ;
20820 PyObject *swig_obj[1] ;
20821
20822 if (!args) SWIG_fail;
20823 swig_obj[0] = args;
20824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20825 if (!SWIG_IsOK(res1)) {
20826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20827 }
20828 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20829 {
20830 PyThreadState* __tstate = wxPyBeginAllowThreads();
20831 wxPyArtProvider_Destroy(arg1);
20832 wxPyEndAllowThreads(__tstate);
20833 if (PyErr_Occurred()) SWIG_fail;
20834 }
20835 resultobj = SWIG_Py_Void();
20836 return resultobj;
20837 fail:
20838 return NULL;
20839 }
20840
20841
20842 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20843 PyObject *obj;
20844 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20845 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20846 return SWIG_Py_Void();
20847 }
20848
20849 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20850 return SWIG_Python_InitShadowInstance(args);
20851 }
20852
20853 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20854 PyObject *resultobj = 0;
20855 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20856 void *argp1 = 0 ;
20857 int res1 = 0 ;
20858 PyObject *swig_obj[1] ;
20859
20860 if (!args) SWIG_fail;
20861 swig_obj[0] = args;
20862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20863 if (!SWIG_IsOK(res1)) {
20864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20865 }
20866 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20867 {
20868 PyThreadState* __tstate = wxPyBeginAllowThreads();
20869 delete arg1;
20870
20871 wxPyEndAllowThreads(__tstate);
20872 if (PyErr_Occurred()) SWIG_fail;
20873 }
20874 resultobj = SWIG_Py_Void();
20875 return resultobj;
20876 fail:
20877 return NULL;
20878 }
20879
20880
20881 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20882 PyObject *resultobj = 0;
20883 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20884 wxConfigBase *result = 0 ;
20885 int res1 = 0 ;
20886 PyObject * obj0 = 0 ;
20887 char * kwnames[] = {
20888 (char *) "config", NULL
20889 };
20890
20891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20892 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20893 if (!SWIG_IsOK(res1)) {
20894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20895 }
20896 {
20897 PyThreadState* __tstate = wxPyBeginAllowThreads();
20898 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20899 wxPyEndAllowThreads(__tstate);
20900 if (PyErr_Occurred()) SWIG_fail;
20901 }
20902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20903 return resultobj;
20904 fail:
20905 return NULL;
20906 }
20907
20908
20909 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20910 PyObject *resultobj = 0;
20911 bool arg1 = (bool) true ;
20912 wxConfigBase *result = 0 ;
20913 bool val1 ;
20914 int ecode1 = 0 ;
20915 PyObject * obj0 = 0 ;
20916 char * kwnames[] = {
20917 (char *) "createOnDemand", NULL
20918 };
20919
20920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20921 if (obj0) {
20922 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20923 if (!SWIG_IsOK(ecode1)) {
20924 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20925 }
20926 arg1 = static_cast< bool >(val1);
20927 }
20928 {
20929 PyThreadState* __tstate = wxPyBeginAllowThreads();
20930 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20931 wxPyEndAllowThreads(__tstate);
20932 if (PyErr_Occurred()) SWIG_fail;
20933 }
20934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20935 return resultobj;
20936 fail:
20937 return NULL;
20938 }
20939
20940
20941 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20942 PyObject *resultobj = 0;
20943 wxConfigBase *result = 0 ;
20944
20945 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20946 {
20947 PyThreadState* __tstate = wxPyBeginAllowThreads();
20948 result = (wxConfigBase *)wxConfigBase::Create();
20949 wxPyEndAllowThreads(__tstate);
20950 if (PyErr_Occurred()) SWIG_fail;
20951 }
20952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20953 return resultobj;
20954 fail:
20955 return NULL;
20956 }
20957
20958
20959 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20960 PyObject *resultobj = 0;
20961
20962 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20963 {
20964 PyThreadState* __tstate = wxPyBeginAllowThreads();
20965 wxConfigBase::DontCreateOnDemand();
20966 wxPyEndAllowThreads(__tstate);
20967 if (PyErr_Occurred()) SWIG_fail;
20968 }
20969 resultobj = SWIG_Py_Void();
20970 return resultobj;
20971 fail:
20972 return NULL;
20973 }
20974
20975
20976 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20977 PyObject *resultobj = 0;
20978 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20979 wxString *arg2 = 0 ;
20980 void *argp1 = 0 ;
20981 int res1 = 0 ;
20982 bool temp2 = false ;
20983 PyObject * obj0 = 0 ;
20984 PyObject * obj1 = 0 ;
20985 char * kwnames[] = {
20986 (char *) "self",(char *) "path", NULL
20987 };
20988
20989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
20990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20991 if (!SWIG_IsOK(res1)) {
20992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20993 }
20994 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20995 {
20996 arg2 = wxString_in_helper(obj1);
20997 if (arg2 == NULL) SWIG_fail;
20998 temp2 = true;
20999 }
21000 {
21001 PyThreadState* __tstate = wxPyBeginAllowThreads();
21002 (arg1)->SetPath((wxString const &)*arg2);
21003 wxPyEndAllowThreads(__tstate);
21004 if (PyErr_Occurred()) SWIG_fail;
21005 }
21006 resultobj = SWIG_Py_Void();
21007 {
21008 if (temp2)
21009 delete arg2;
21010 }
21011 return resultobj;
21012 fail:
21013 {
21014 if (temp2)
21015 delete arg2;
21016 }
21017 return NULL;
21018 }
21019
21020
21021 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21022 PyObject *resultobj = 0;
21023 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21024 wxString *result = 0 ;
21025 void *argp1 = 0 ;
21026 int res1 = 0 ;
21027 PyObject *swig_obj[1] ;
21028
21029 if (!args) SWIG_fail;
21030 swig_obj[0] = args;
21031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21032 if (!SWIG_IsOK(res1)) {
21033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21034 }
21035 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21036 {
21037 PyThreadState* __tstate = wxPyBeginAllowThreads();
21038 {
21039 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
21040 result = (wxString *) &_result_ref;
21041 }
21042 wxPyEndAllowThreads(__tstate);
21043 if (PyErr_Occurred()) SWIG_fail;
21044 }
21045 {
21046 #if wxUSE_UNICODE
21047 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21048 #else
21049 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21050 #endif
21051 }
21052 return resultobj;
21053 fail:
21054 return NULL;
21055 }
21056
21057
21058 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21059 PyObject *resultobj = 0;
21060 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21061 PyObject *result = 0 ;
21062 void *argp1 = 0 ;
21063 int res1 = 0 ;
21064 PyObject *swig_obj[1] ;
21065
21066 if (!args) SWIG_fail;
21067 swig_obj[0] = args;
21068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21069 if (!SWIG_IsOK(res1)) {
21070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21071 }
21072 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21073 {
21074 PyThreadState* __tstate = wxPyBeginAllowThreads();
21075 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
21076 wxPyEndAllowThreads(__tstate);
21077 if (PyErr_Occurred()) SWIG_fail;
21078 }
21079 resultobj = result;
21080 return resultobj;
21081 fail:
21082 return NULL;
21083 }
21084
21085
21086 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21087 PyObject *resultobj = 0;
21088 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21089 long arg2 ;
21090 PyObject *result = 0 ;
21091 void *argp1 = 0 ;
21092 int res1 = 0 ;
21093 long val2 ;
21094 int ecode2 = 0 ;
21095 PyObject * obj0 = 0 ;
21096 PyObject * obj1 = 0 ;
21097 char * kwnames[] = {
21098 (char *) "self",(char *) "index", NULL
21099 };
21100
21101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21103 if (!SWIG_IsOK(res1)) {
21104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21105 }
21106 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21107 ecode2 = SWIG_AsVal_long(obj1, &val2);
21108 if (!SWIG_IsOK(ecode2)) {
21109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21110 }
21111 arg2 = static_cast< long >(val2);
21112 {
21113 PyThreadState* __tstate = wxPyBeginAllowThreads();
21114 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21115 wxPyEndAllowThreads(__tstate);
21116 if (PyErr_Occurred()) SWIG_fail;
21117 }
21118 resultobj = result;
21119 return resultobj;
21120 fail:
21121 return NULL;
21122 }
21123
21124
21125 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21126 PyObject *resultobj = 0;
21127 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21128 PyObject *result = 0 ;
21129 void *argp1 = 0 ;
21130 int res1 = 0 ;
21131 PyObject *swig_obj[1] ;
21132
21133 if (!args) SWIG_fail;
21134 swig_obj[0] = args;
21135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21136 if (!SWIG_IsOK(res1)) {
21137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21138 }
21139 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21140 {
21141 PyThreadState* __tstate = wxPyBeginAllowThreads();
21142 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21143 wxPyEndAllowThreads(__tstate);
21144 if (PyErr_Occurred()) SWIG_fail;
21145 }
21146 resultobj = result;
21147 return resultobj;
21148 fail:
21149 return NULL;
21150 }
21151
21152
21153 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21154 PyObject *resultobj = 0;
21155 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21156 long arg2 ;
21157 PyObject *result = 0 ;
21158 void *argp1 = 0 ;
21159 int res1 = 0 ;
21160 long val2 ;
21161 int ecode2 = 0 ;
21162 PyObject * obj0 = 0 ;
21163 PyObject * obj1 = 0 ;
21164 char * kwnames[] = {
21165 (char *) "self",(char *) "index", NULL
21166 };
21167
21168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21170 if (!SWIG_IsOK(res1)) {
21171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21172 }
21173 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21174 ecode2 = SWIG_AsVal_long(obj1, &val2);
21175 if (!SWIG_IsOK(ecode2)) {
21176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21177 }
21178 arg2 = static_cast< long >(val2);
21179 {
21180 PyThreadState* __tstate = wxPyBeginAllowThreads();
21181 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21182 wxPyEndAllowThreads(__tstate);
21183 if (PyErr_Occurred()) SWIG_fail;
21184 }
21185 resultobj = result;
21186 return resultobj;
21187 fail:
21188 return NULL;
21189 }
21190
21191
21192 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21193 PyObject *resultobj = 0;
21194 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21195 bool arg2 = (bool) false ;
21196 size_t result;
21197 void *argp1 = 0 ;
21198 int res1 = 0 ;
21199 bool val2 ;
21200 int ecode2 = 0 ;
21201 PyObject * obj0 = 0 ;
21202 PyObject * obj1 = 0 ;
21203 char * kwnames[] = {
21204 (char *) "self",(char *) "recursive", NULL
21205 };
21206
21207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21209 if (!SWIG_IsOK(res1)) {
21210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21211 }
21212 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21213 if (obj1) {
21214 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21215 if (!SWIG_IsOK(ecode2)) {
21216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21217 }
21218 arg2 = static_cast< bool >(val2);
21219 }
21220 {
21221 PyThreadState* __tstate = wxPyBeginAllowThreads();
21222 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21223 wxPyEndAllowThreads(__tstate);
21224 if (PyErr_Occurred()) SWIG_fail;
21225 }
21226 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21227 return resultobj;
21228 fail:
21229 return NULL;
21230 }
21231
21232
21233 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21234 PyObject *resultobj = 0;
21235 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21236 bool arg2 = (bool) false ;
21237 size_t result;
21238 void *argp1 = 0 ;
21239 int res1 = 0 ;
21240 bool val2 ;
21241 int ecode2 = 0 ;
21242 PyObject * obj0 = 0 ;
21243 PyObject * obj1 = 0 ;
21244 char * kwnames[] = {
21245 (char *) "self",(char *) "recursive", NULL
21246 };
21247
21248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21250 if (!SWIG_IsOK(res1)) {
21251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21252 }
21253 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21254 if (obj1) {
21255 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21256 if (!SWIG_IsOK(ecode2)) {
21257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21258 }
21259 arg2 = static_cast< bool >(val2);
21260 }
21261 {
21262 PyThreadState* __tstate = wxPyBeginAllowThreads();
21263 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21264 wxPyEndAllowThreads(__tstate);
21265 if (PyErr_Occurred()) SWIG_fail;
21266 }
21267 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21268 return resultobj;
21269 fail:
21270 return NULL;
21271 }
21272
21273
21274 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21275 PyObject *resultobj = 0;
21276 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21277 wxString *arg2 = 0 ;
21278 bool result;
21279 void *argp1 = 0 ;
21280 int res1 = 0 ;
21281 bool temp2 = false ;
21282 PyObject * obj0 = 0 ;
21283 PyObject * obj1 = 0 ;
21284 char * kwnames[] = {
21285 (char *) "self",(char *) "name", NULL
21286 };
21287
21288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21290 if (!SWIG_IsOK(res1)) {
21291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21292 }
21293 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21294 {
21295 arg2 = wxString_in_helper(obj1);
21296 if (arg2 == NULL) SWIG_fail;
21297 temp2 = true;
21298 }
21299 {
21300 PyThreadState* __tstate = wxPyBeginAllowThreads();
21301 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21302 wxPyEndAllowThreads(__tstate);
21303 if (PyErr_Occurred()) SWIG_fail;
21304 }
21305 {
21306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21307 }
21308 {
21309 if (temp2)
21310 delete arg2;
21311 }
21312 return resultobj;
21313 fail:
21314 {
21315 if (temp2)
21316 delete arg2;
21317 }
21318 return NULL;
21319 }
21320
21321
21322 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21323 PyObject *resultobj = 0;
21324 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21325 wxString *arg2 = 0 ;
21326 bool result;
21327 void *argp1 = 0 ;
21328 int res1 = 0 ;
21329 bool temp2 = false ;
21330 PyObject * obj0 = 0 ;
21331 PyObject * obj1 = 0 ;
21332 char * kwnames[] = {
21333 (char *) "self",(char *) "name", NULL
21334 };
21335
21336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21338 if (!SWIG_IsOK(res1)) {
21339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21340 }
21341 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21342 {
21343 arg2 = wxString_in_helper(obj1);
21344 if (arg2 == NULL) SWIG_fail;
21345 temp2 = true;
21346 }
21347 {
21348 PyThreadState* __tstate = wxPyBeginAllowThreads();
21349 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21350 wxPyEndAllowThreads(__tstate);
21351 if (PyErr_Occurred()) SWIG_fail;
21352 }
21353 {
21354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21355 }
21356 {
21357 if (temp2)
21358 delete arg2;
21359 }
21360 return resultobj;
21361 fail:
21362 {
21363 if (temp2)
21364 delete arg2;
21365 }
21366 return NULL;
21367 }
21368
21369
21370 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21371 PyObject *resultobj = 0;
21372 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21373 wxString *arg2 = 0 ;
21374 bool result;
21375 void *argp1 = 0 ;
21376 int res1 = 0 ;
21377 bool temp2 = false ;
21378 PyObject * obj0 = 0 ;
21379 PyObject * obj1 = 0 ;
21380 char * kwnames[] = {
21381 (char *) "self",(char *) "name", NULL
21382 };
21383
21384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21386 if (!SWIG_IsOK(res1)) {
21387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21388 }
21389 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21390 {
21391 arg2 = wxString_in_helper(obj1);
21392 if (arg2 == NULL) SWIG_fail;
21393 temp2 = true;
21394 }
21395 {
21396 PyThreadState* __tstate = wxPyBeginAllowThreads();
21397 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21398 wxPyEndAllowThreads(__tstate);
21399 if (PyErr_Occurred()) SWIG_fail;
21400 }
21401 {
21402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21403 }
21404 {
21405 if (temp2)
21406 delete arg2;
21407 }
21408 return resultobj;
21409 fail:
21410 {
21411 if (temp2)
21412 delete arg2;
21413 }
21414 return NULL;
21415 }
21416
21417
21418 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21419 PyObject *resultobj = 0;
21420 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21421 wxString *arg2 = 0 ;
21422 wxConfigBase::EntryType result;
21423 void *argp1 = 0 ;
21424 int res1 = 0 ;
21425 bool temp2 = false ;
21426 PyObject * obj0 = 0 ;
21427 PyObject * obj1 = 0 ;
21428 char * kwnames[] = {
21429 (char *) "self",(char *) "name", NULL
21430 };
21431
21432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21434 if (!SWIG_IsOK(res1)) {
21435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21436 }
21437 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21438 {
21439 arg2 = wxString_in_helper(obj1);
21440 if (arg2 == NULL) SWIG_fail;
21441 temp2 = true;
21442 }
21443 {
21444 PyThreadState* __tstate = wxPyBeginAllowThreads();
21445 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21446 wxPyEndAllowThreads(__tstate);
21447 if (PyErr_Occurred()) SWIG_fail;
21448 }
21449 resultobj = SWIG_From_int(static_cast< int >(result));
21450 {
21451 if (temp2)
21452 delete arg2;
21453 }
21454 return resultobj;
21455 fail:
21456 {
21457 if (temp2)
21458 delete arg2;
21459 }
21460 return NULL;
21461 }
21462
21463
21464 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21465 PyObject *resultobj = 0;
21466 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21467 wxString *arg2 = 0 ;
21468 wxString const &arg3_defvalue = wxPyEmptyString ;
21469 wxString *arg3 = (wxString *) &arg3_defvalue ;
21470 wxString result;
21471 void *argp1 = 0 ;
21472 int res1 = 0 ;
21473 bool temp2 = false ;
21474 bool temp3 = false ;
21475 PyObject * obj0 = 0 ;
21476 PyObject * obj1 = 0 ;
21477 PyObject * obj2 = 0 ;
21478 char * kwnames[] = {
21479 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21480 };
21481
21482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21484 if (!SWIG_IsOK(res1)) {
21485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21486 }
21487 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21488 {
21489 arg2 = wxString_in_helper(obj1);
21490 if (arg2 == NULL) SWIG_fail;
21491 temp2 = true;
21492 }
21493 if (obj2) {
21494 {
21495 arg3 = wxString_in_helper(obj2);
21496 if (arg3 == NULL) SWIG_fail;
21497 temp3 = true;
21498 }
21499 }
21500 {
21501 PyThreadState* __tstate = wxPyBeginAllowThreads();
21502 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21503 wxPyEndAllowThreads(__tstate);
21504 if (PyErr_Occurred()) SWIG_fail;
21505 }
21506 {
21507 #if wxUSE_UNICODE
21508 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21509 #else
21510 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21511 #endif
21512 }
21513 {
21514 if (temp2)
21515 delete arg2;
21516 }
21517 {
21518 if (temp3)
21519 delete arg3;
21520 }
21521 return resultobj;
21522 fail:
21523 {
21524 if (temp2)
21525 delete arg2;
21526 }
21527 {
21528 if (temp3)
21529 delete arg3;
21530 }
21531 return NULL;
21532 }
21533
21534
21535 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21536 PyObject *resultobj = 0;
21537 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21538 wxString *arg2 = 0 ;
21539 long arg3 = (long) 0 ;
21540 long result;
21541 void *argp1 = 0 ;
21542 int res1 = 0 ;
21543 bool temp2 = false ;
21544 long val3 ;
21545 int ecode3 = 0 ;
21546 PyObject * obj0 = 0 ;
21547 PyObject * obj1 = 0 ;
21548 PyObject * obj2 = 0 ;
21549 char * kwnames[] = {
21550 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21551 };
21552
21553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21555 if (!SWIG_IsOK(res1)) {
21556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21557 }
21558 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21559 {
21560 arg2 = wxString_in_helper(obj1);
21561 if (arg2 == NULL) SWIG_fail;
21562 temp2 = true;
21563 }
21564 if (obj2) {
21565 ecode3 = SWIG_AsVal_long(obj2, &val3);
21566 if (!SWIG_IsOK(ecode3)) {
21567 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21568 }
21569 arg3 = static_cast< long >(val3);
21570 }
21571 {
21572 PyThreadState* __tstate = wxPyBeginAllowThreads();
21573 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21574 wxPyEndAllowThreads(__tstate);
21575 if (PyErr_Occurred()) SWIG_fail;
21576 }
21577 resultobj = SWIG_From_long(static_cast< long >(result));
21578 {
21579 if (temp2)
21580 delete arg2;
21581 }
21582 return resultobj;
21583 fail:
21584 {
21585 if (temp2)
21586 delete arg2;
21587 }
21588 return NULL;
21589 }
21590
21591
21592 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21593 PyObject *resultobj = 0;
21594 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21595 wxString *arg2 = 0 ;
21596 double arg3 = (double) 0.0 ;
21597 double result;
21598 void *argp1 = 0 ;
21599 int res1 = 0 ;
21600 bool temp2 = false ;
21601 double val3 ;
21602 int ecode3 = 0 ;
21603 PyObject * obj0 = 0 ;
21604 PyObject * obj1 = 0 ;
21605 PyObject * obj2 = 0 ;
21606 char * kwnames[] = {
21607 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21608 };
21609
21610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21612 if (!SWIG_IsOK(res1)) {
21613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21614 }
21615 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21616 {
21617 arg2 = wxString_in_helper(obj1);
21618 if (arg2 == NULL) SWIG_fail;
21619 temp2 = true;
21620 }
21621 if (obj2) {
21622 ecode3 = SWIG_AsVal_double(obj2, &val3);
21623 if (!SWIG_IsOK(ecode3)) {
21624 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21625 }
21626 arg3 = static_cast< double >(val3);
21627 }
21628 {
21629 PyThreadState* __tstate = wxPyBeginAllowThreads();
21630 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21631 wxPyEndAllowThreads(__tstate);
21632 if (PyErr_Occurred()) SWIG_fail;
21633 }
21634 resultobj = SWIG_From_double(static_cast< double >(result));
21635 {
21636 if (temp2)
21637 delete arg2;
21638 }
21639 return resultobj;
21640 fail:
21641 {
21642 if (temp2)
21643 delete arg2;
21644 }
21645 return NULL;
21646 }
21647
21648
21649 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21650 PyObject *resultobj = 0;
21651 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21652 wxString *arg2 = 0 ;
21653 bool arg3 = (bool) false ;
21654 bool result;
21655 void *argp1 = 0 ;
21656 int res1 = 0 ;
21657 bool temp2 = false ;
21658 bool val3 ;
21659 int ecode3 = 0 ;
21660 PyObject * obj0 = 0 ;
21661 PyObject * obj1 = 0 ;
21662 PyObject * obj2 = 0 ;
21663 char * kwnames[] = {
21664 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21665 };
21666
21667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21669 if (!SWIG_IsOK(res1)) {
21670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21671 }
21672 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21673 {
21674 arg2 = wxString_in_helper(obj1);
21675 if (arg2 == NULL) SWIG_fail;
21676 temp2 = true;
21677 }
21678 if (obj2) {
21679 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21680 if (!SWIG_IsOK(ecode3)) {
21681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21682 }
21683 arg3 = static_cast< bool >(val3);
21684 }
21685 {
21686 PyThreadState* __tstate = wxPyBeginAllowThreads();
21687 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21688 wxPyEndAllowThreads(__tstate);
21689 if (PyErr_Occurred()) SWIG_fail;
21690 }
21691 {
21692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21693 }
21694 {
21695 if (temp2)
21696 delete arg2;
21697 }
21698 return resultobj;
21699 fail:
21700 {
21701 if (temp2)
21702 delete arg2;
21703 }
21704 return NULL;
21705 }
21706
21707
21708 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21709 PyObject *resultobj = 0;
21710 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21711 wxString *arg2 = 0 ;
21712 wxString *arg3 = 0 ;
21713 bool result;
21714 void *argp1 = 0 ;
21715 int res1 = 0 ;
21716 bool temp2 = false ;
21717 bool temp3 = false ;
21718 PyObject * obj0 = 0 ;
21719 PyObject * obj1 = 0 ;
21720 PyObject * obj2 = 0 ;
21721 char * kwnames[] = {
21722 (char *) "self",(char *) "key",(char *) "value", NULL
21723 };
21724
21725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21727 if (!SWIG_IsOK(res1)) {
21728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21729 }
21730 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21731 {
21732 arg2 = wxString_in_helper(obj1);
21733 if (arg2 == NULL) SWIG_fail;
21734 temp2 = true;
21735 }
21736 {
21737 arg3 = wxString_in_helper(obj2);
21738 if (arg3 == NULL) SWIG_fail;
21739 temp3 = true;
21740 }
21741 {
21742 PyThreadState* __tstate = wxPyBeginAllowThreads();
21743 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21744 wxPyEndAllowThreads(__tstate);
21745 if (PyErr_Occurred()) SWIG_fail;
21746 }
21747 {
21748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21749 }
21750 {
21751 if (temp2)
21752 delete arg2;
21753 }
21754 {
21755 if (temp3)
21756 delete arg3;
21757 }
21758 return resultobj;
21759 fail:
21760 {
21761 if (temp2)
21762 delete arg2;
21763 }
21764 {
21765 if (temp3)
21766 delete arg3;
21767 }
21768 return NULL;
21769 }
21770
21771
21772 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21773 PyObject *resultobj = 0;
21774 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21775 wxString *arg2 = 0 ;
21776 long arg3 ;
21777 bool result;
21778 void *argp1 = 0 ;
21779 int res1 = 0 ;
21780 bool temp2 = false ;
21781 long val3 ;
21782 int ecode3 = 0 ;
21783 PyObject * obj0 = 0 ;
21784 PyObject * obj1 = 0 ;
21785 PyObject * obj2 = 0 ;
21786 char * kwnames[] = {
21787 (char *) "self",(char *) "key",(char *) "value", NULL
21788 };
21789
21790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21792 if (!SWIG_IsOK(res1)) {
21793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21794 }
21795 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21796 {
21797 arg2 = wxString_in_helper(obj1);
21798 if (arg2 == NULL) SWIG_fail;
21799 temp2 = true;
21800 }
21801 ecode3 = SWIG_AsVal_long(obj2, &val3);
21802 if (!SWIG_IsOK(ecode3)) {
21803 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21804 }
21805 arg3 = static_cast< long >(val3);
21806 {
21807 PyThreadState* __tstate = wxPyBeginAllowThreads();
21808 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21809 wxPyEndAllowThreads(__tstate);
21810 if (PyErr_Occurred()) SWIG_fail;
21811 }
21812 {
21813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21814 }
21815 {
21816 if (temp2)
21817 delete arg2;
21818 }
21819 return resultobj;
21820 fail:
21821 {
21822 if (temp2)
21823 delete arg2;
21824 }
21825 return NULL;
21826 }
21827
21828
21829 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21830 PyObject *resultobj = 0;
21831 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21832 wxString *arg2 = 0 ;
21833 double arg3 ;
21834 bool result;
21835 void *argp1 = 0 ;
21836 int res1 = 0 ;
21837 bool temp2 = false ;
21838 double val3 ;
21839 int ecode3 = 0 ;
21840 PyObject * obj0 = 0 ;
21841 PyObject * obj1 = 0 ;
21842 PyObject * obj2 = 0 ;
21843 char * kwnames[] = {
21844 (char *) "self",(char *) "key",(char *) "value", NULL
21845 };
21846
21847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21849 if (!SWIG_IsOK(res1)) {
21850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21851 }
21852 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21853 {
21854 arg2 = wxString_in_helper(obj1);
21855 if (arg2 == NULL) SWIG_fail;
21856 temp2 = true;
21857 }
21858 ecode3 = SWIG_AsVal_double(obj2, &val3);
21859 if (!SWIG_IsOK(ecode3)) {
21860 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21861 }
21862 arg3 = static_cast< double >(val3);
21863 {
21864 PyThreadState* __tstate = wxPyBeginAllowThreads();
21865 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21866 wxPyEndAllowThreads(__tstate);
21867 if (PyErr_Occurred()) SWIG_fail;
21868 }
21869 {
21870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21871 }
21872 {
21873 if (temp2)
21874 delete arg2;
21875 }
21876 return resultobj;
21877 fail:
21878 {
21879 if (temp2)
21880 delete arg2;
21881 }
21882 return NULL;
21883 }
21884
21885
21886 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21887 PyObject *resultobj = 0;
21888 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21889 wxString *arg2 = 0 ;
21890 bool arg3 ;
21891 bool result;
21892 void *argp1 = 0 ;
21893 int res1 = 0 ;
21894 bool temp2 = false ;
21895 bool val3 ;
21896 int ecode3 = 0 ;
21897 PyObject * obj0 = 0 ;
21898 PyObject * obj1 = 0 ;
21899 PyObject * obj2 = 0 ;
21900 char * kwnames[] = {
21901 (char *) "self",(char *) "key",(char *) "value", NULL
21902 };
21903
21904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21906 if (!SWIG_IsOK(res1)) {
21907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21908 }
21909 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21910 {
21911 arg2 = wxString_in_helper(obj1);
21912 if (arg2 == NULL) SWIG_fail;
21913 temp2 = true;
21914 }
21915 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21916 if (!SWIG_IsOK(ecode3)) {
21917 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21918 }
21919 arg3 = static_cast< bool >(val3);
21920 {
21921 PyThreadState* __tstate = wxPyBeginAllowThreads();
21922 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21923 wxPyEndAllowThreads(__tstate);
21924 if (PyErr_Occurred()) SWIG_fail;
21925 }
21926 {
21927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21928 }
21929 {
21930 if (temp2)
21931 delete arg2;
21932 }
21933 return resultobj;
21934 fail:
21935 {
21936 if (temp2)
21937 delete arg2;
21938 }
21939 return NULL;
21940 }
21941
21942
21943 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21944 PyObject *resultobj = 0;
21945 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21946 bool arg2 = (bool) false ;
21947 bool result;
21948 void *argp1 = 0 ;
21949 int res1 = 0 ;
21950 bool val2 ;
21951 int ecode2 = 0 ;
21952 PyObject * obj0 = 0 ;
21953 PyObject * obj1 = 0 ;
21954 char * kwnames[] = {
21955 (char *) "self",(char *) "currentOnly", NULL
21956 };
21957
21958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21960 if (!SWIG_IsOK(res1)) {
21961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21962 }
21963 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21964 if (obj1) {
21965 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21966 if (!SWIG_IsOK(ecode2)) {
21967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21968 }
21969 arg2 = static_cast< bool >(val2);
21970 }
21971 {
21972 PyThreadState* __tstate = wxPyBeginAllowThreads();
21973 result = (bool)(arg1)->Flush(arg2);
21974 wxPyEndAllowThreads(__tstate);
21975 if (PyErr_Occurred()) SWIG_fail;
21976 }
21977 {
21978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21979 }
21980 return resultobj;
21981 fail:
21982 return NULL;
21983 }
21984
21985
21986 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21987 PyObject *resultobj = 0;
21988 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21989 wxString *arg2 = 0 ;
21990 wxString *arg3 = 0 ;
21991 bool result;
21992 void *argp1 = 0 ;
21993 int res1 = 0 ;
21994 bool temp2 = false ;
21995 bool temp3 = false ;
21996 PyObject * obj0 = 0 ;
21997 PyObject * obj1 = 0 ;
21998 PyObject * obj2 = 0 ;
21999 char * kwnames[] = {
22000 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22001 };
22002
22003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22005 if (!SWIG_IsOK(res1)) {
22006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22007 }
22008 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22009 {
22010 arg2 = wxString_in_helper(obj1);
22011 if (arg2 == NULL) SWIG_fail;
22012 temp2 = true;
22013 }
22014 {
22015 arg3 = wxString_in_helper(obj2);
22016 if (arg3 == NULL) SWIG_fail;
22017 temp3 = true;
22018 }
22019 {
22020 PyThreadState* __tstate = wxPyBeginAllowThreads();
22021 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
22022 wxPyEndAllowThreads(__tstate);
22023 if (PyErr_Occurred()) SWIG_fail;
22024 }
22025 {
22026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22027 }
22028 {
22029 if (temp2)
22030 delete arg2;
22031 }
22032 {
22033 if (temp3)
22034 delete arg3;
22035 }
22036 return resultobj;
22037 fail:
22038 {
22039 if (temp2)
22040 delete arg2;
22041 }
22042 {
22043 if (temp3)
22044 delete arg3;
22045 }
22046 return NULL;
22047 }
22048
22049
22050 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22051 PyObject *resultobj = 0;
22052 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22053 wxString *arg2 = 0 ;
22054 wxString *arg3 = 0 ;
22055 bool result;
22056 void *argp1 = 0 ;
22057 int res1 = 0 ;
22058 bool temp2 = false ;
22059 bool temp3 = false ;
22060 PyObject * obj0 = 0 ;
22061 PyObject * obj1 = 0 ;
22062 PyObject * obj2 = 0 ;
22063 char * kwnames[] = {
22064 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22065 };
22066
22067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22069 if (!SWIG_IsOK(res1)) {
22070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22071 }
22072 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22073 {
22074 arg2 = wxString_in_helper(obj1);
22075 if (arg2 == NULL) SWIG_fail;
22076 temp2 = true;
22077 }
22078 {
22079 arg3 = wxString_in_helper(obj2);
22080 if (arg3 == NULL) SWIG_fail;
22081 temp3 = true;
22082 }
22083 {
22084 PyThreadState* __tstate = wxPyBeginAllowThreads();
22085 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
22086 wxPyEndAllowThreads(__tstate);
22087 if (PyErr_Occurred()) SWIG_fail;
22088 }
22089 {
22090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22091 }
22092 {
22093 if (temp2)
22094 delete arg2;
22095 }
22096 {
22097 if (temp3)
22098 delete arg3;
22099 }
22100 return resultobj;
22101 fail:
22102 {
22103 if (temp2)
22104 delete arg2;
22105 }
22106 {
22107 if (temp3)
22108 delete arg3;
22109 }
22110 return NULL;
22111 }
22112
22113
22114 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22115 PyObject *resultobj = 0;
22116 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22117 wxString *arg2 = 0 ;
22118 bool arg3 = (bool) true ;
22119 bool result;
22120 void *argp1 = 0 ;
22121 int res1 = 0 ;
22122 bool temp2 = false ;
22123 bool val3 ;
22124 int ecode3 = 0 ;
22125 PyObject * obj0 = 0 ;
22126 PyObject * obj1 = 0 ;
22127 PyObject * obj2 = 0 ;
22128 char * kwnames[] = {
22129 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22130 };
22131
22132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22134 if (!SWIG_IsOK(res1)) {
22135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22136 }
22137 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22138 {
22139 arg2 = wxString_in_helper(obj1);
22140 if (arg2 == NULL) SWIG_fail;
22141 temp2 = true;
22142 }
22143 if (obj2) {
22144 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22145 if (!SWIG_IsOK(ecode3)) {
22146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22147 }
22148 arg3 = static_cast< bool >(val3);
22149 }
22150 {
22151 PyThreadState* __tstate = wxPyBeginAllowThreads();
22152 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22153 wxPyEndAllowThreads(__tstate);
22154 if (PyErr_Occurred()) SWIG_fail;
22155 }
22156 {
22157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22158 }
22159 {
22160 if (temp2)
22161 delete arg2;
22162 }
22163 return resultobj;
22164 fail:
22165 {
22166 if (temp2)
22167 delete arg2;
22168 }
22169 return NULL;
22170 }
22171
22172
22173 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22174 PyObject *resultobj = 0;
22175 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22176 wxString *arg2 = 0 ;
22177 bool result;
22178 void *argp1 = 0 ;
22179 int res1 = 0 ;
22180 bool temp2 = false ;
22181 PyObject * obj0 = 0 ;
22182 PyObject * obj1 = 0 ;
22183 char * kwnames[] = {
22184 (char *) "self",(char *) "key", NULL
22185 };
22186
22187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22189 if (!SWIG_IsOK(res1)) {
22190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22191 }
22192 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22193 {
22194 arg2 = wxString_in_helper(obj1);
22195 if (arg2 == NULL) SWIG_fail;
22196 temp2 = true;
22197 }
22198 {
22199 PyThreadState* __tstate = wxPyBeginAllowThreads();
22200 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22201 wxPyEndAllowThreads(__tstate);
22202 if (PyErr_Occurred()) SWIG_fail;
22203 }
22204 {
22205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22206 }
22207 {
22208 if (temp2)
22209 delete arg2;
22210 }
22211 return resultobj;
22212 fail:
22213 {
22214 if (temp2)
22215 delete arg2;
22216 }
22217 return NULL;
22218 }
22219
22220
22221 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22222 PyObject *resultobj = 0;
22223 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22224 bool result;
22225 void *argp1 = 0 ;
22226 int res1 = 0 ;
22227 PyObject *swig_obj[1] ;
22228
22229 if (!args) SWIG_fail;
22230 swig_obj[0] = args;
22231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22232 if (!SWIG_IsOK(res1)) {
22233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22234 }
22235 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22236 {
22237 PyThreadState* __tstate = wxPyBeginAllowThreads();
22238 result = (bool)(arg1)->DeleteAll();
22239 wxPyEndAllowThreads(__tstate);
22240 if (PyErr_Occurred()) SWIG_fail;
22241 }
22242 {
22243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22244 }
22245 return resultobj;
22246 fail:
22247 return NULL;
22248 }
22249
22250
22251 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22252 PyObject *resultobj = 0;
22253 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22254 bool arg2 = (bool) true ;
22255 void *argp1 = 0 ;
22256 int res1 = 0 ;
22257 bool val2 ;
22258 int ecode2 = 0 ;
22259 PyObject * obj0 = 0 ;
22260 PyObject * obj1 = 0 ;
22261 char * kwnames[] = {
22262 (char *) "self",(char *) "doIt", NULL
22263 };
22264
22265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22267 if (!SWIG_IsOK(res1)) {
22268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22269 }
22270 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22271 if (obj1) {
22272 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22273 if (!SWIG_IsOK(ecode2)) {
22274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22275 }
22276 arg2 = static_cast< bool >(val2);
22277 }
22278 {
22279 PyThreadState* __tstate = wxPyBeginAllowThreads();
22280 (arg1)->SetExpandEnvVars(arg2);
22281 wxPyEndAllowThreads(__tstate);
22282 if (PyErr_Occurred()) SWIG_fail;
22283 }
22284 resultobj = SWIG_Py_Void();
22285 return resultobj;
22286 fail:
22287 return NULL;
22288 }
22289
22290
22291 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22292 PyObject *resultobj = 0;
22293 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22294 bool result;
22295 void *argp1 = 0 ;
22296 int res1 = 0 ;
22297 PyObject *swig_obj[1] ;
22298
22299 if (!args) SWIG_fail;
22300 swig_obj[0] = args;
22301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22302 if (!SWIG_IsOK(res1)) {
22303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22304 }
22305 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22306 {
22307 PyThreadState* __tstate = wxPyBeginAllowThreads();
22308 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22309 wxPyEndAllowThreads(__tstate);
22310 if (PyErr_Occurred()) SWIG_fail;
22311 }
22312 {
22313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22314 }
22315 return resultobj;
22316 fail:
22317 return NULL;
22318 }
22319
22320
22321 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22322 PyObject *resultobj = 0;
22323 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22324 bool arg2 = (bool) true ;
22325 void *argp1 = 0 ;
22326 int res1 = 0 ;
22327 bool val2 ;
22328 int ecode2 = 0 ;
22329 PyObject * obj0 = 0 ;
22330 PyObject * obj1 = 0 ;
22331 char * kwnames[] = {
22332 (char *) "self",(char *) "doIt", NULL
22333 };
22334
22335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22337 if (!SWIG_IsOK(res1)) {
22338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22339 }
22340 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22341 if (obj1) {
22342 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22343 if (!SWIG_IsOK(ecode2)) {
22344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22345 }
22346 arg2 = static_cast< bool >(val2);
22347 }
22348 {
22349 PyThreadState* __tstate = wxPyBeginAllowThreads();
22350 (arg1)->SetRecordDefaults(arg2);
22351 wxPyEndAllowThreads(__tstate);
22352 if (PyErr_Occurred()) SWIG_fail;
22353 }
22354 resultobj = SWIG_Py_Void();
22355 return resultobj;
22356 fail:
22357 return NULL;
22358 }
22359
22360
22361 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22362 PyObject *resultobj = 0;
22363 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22364 bool result;
22365 void *argp1 = 0 ;
22366 int res1 = 0 ;
22367 PyObject *swig_obj[1] ;
22368
22369 if (!args) SWIG_fail;
22370 swig_obj[0] = args;
22371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22372 if (!SWIG_IsOK(res1)) {
22373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22374 }
22375 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22376 {
22377 PyThreadState* __tstate = wxPyBeginAllowThreads();
22378 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22379 wxPyEndAllowThreads(__tstate);
22380 if (PyErr_Occurred()) SWIG_fail;
22381 }
22382 {
22383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22384 }
22385 return resultobj;
22386 fail:
22387 return NULL;
22388 }
22389
22390
22391 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22392 PyObject *resultobj = 0;
22393 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22394 wxString *arg2 = 0 ;
22395 wxString result;
22396 void *argp1 = 0 ;
22397 int res1 = 0 ;
22398 bool temp2 = false ;
22399 PyObject * obj0 = 0 ;
22400 PyObject * obj1 = 0 ;
22401 char * kwnames[] = {
22402 (char *) "self",(char *) "str", NULL
22403 };
22404
22405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22407 if (!SWIG_IsOK(res1)) {
22408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22409 }
22410 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22411 {
22412 arg2 = wxString_in_helper(obj1);
22413 if (arg2 == NULL) SWIG_fail;
22414 temp2 = true;
22415 }
22416 {
22417 PyThreadState* __tstate = wxPyBeginAllowThreads();
22418 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22419 wxPyEndAllowThreads(__tstate);
22420 if (PyErr_Occurred()) SWIG_fail;
22421 }
22422 {
22423 #if wxUSE_UNICODE
22424 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22425 #else
22426 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22427 #endif
22428 }
22429 {
22430 if (temp2)
22431 delete arg2;
22432 }
22433 return resultobj;
22434 fail:
22435 {
22436 if (temp2)
22437 delete arg2;
22438 }
22439 return NULL;
22440 }
22441
22442
22443 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22444 PyObject *resultobj = 0;
22445 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22446 wxString result;
22447 void *argp1 = 0 ;
22448 int res1 = 0 ;
22449 PyObject *swig_obj[1] ;
22450
22451 if (!args) SWIG_fail;
22452 swig_obj[0] = args;
22453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22454 if (!SWIG_IsOK(res1)) {
22455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22456 }
22457 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22458 {
22459 PyThreadState* __tstate = wxPyBeginAllowThreads();
22460 result = ((wxConfigBase const *)arg1)->GetAppName();
22461 wxPyEndAllowThreads(__tstate);
22462 if (PyErr_Occurred()) SWIG_fail;
22463 }
22464 {
22465 #if wxUSE_UNICODE
22466 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22467 #else
22468 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22469 #endif
22470 }
22471 return resultobj;
22472 fail:
22473 return NULL;
22474 }
22475
22476
22477 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22478 PyObject *resultobj = 0;
22479 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22480 wxString result;
22481 void *argp1 = 0 ;
22482 int res1 = 0 ;
22483 PyObject *swig_obj[1] ;
22484
22485 if (!args) SWIG_fail;
22486 swig_obj[0] = args;
22487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22488 if (!SWIG_IsOK(res1)) {
22489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22490 }
22491 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22492 {
22493 PyThreadState* __tstate = wxPyBeginAllowThreads();
22494 result = ((wxConfigBase const *)arg1)->GetVendorName();
22495 wxPyEndAllowThreads(__tstate);
22496 if (PyErr_Occurred()) SWIG_fail;
22497 }
22498 {
22499 #if wxUSE_UNICODE
22500 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22501 #else
22502 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22503 #endif
22504 }
22505 return resultobj;
22506 fail:
22507 return NULL;
22508 }
22509
22510
22511 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22512 PyObject *resultobj = 0;
22513 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22514 wxString *arg2 = 0 ;
22515 void *argp1 = 0 ;
22516 int res1 = 0 ;
22517 bool temp2 = false ;
22518 PyObject * obj0 = 0 ;
22519 PyObject * obj1 = 0 ;
22520 char * kwnames[] = {
22521 (char *) "self",(char *) "appName", NULL
22522 };
22523
22524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22526 if (!SWIG_IsOK(res1)) {
22527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22528 }
22529 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22530 {
22531 arg2 = wxString_in_helper(obj1);
22532 if (arg2 == NULL) SWIG_fail;
22533 temp2 = true;
22534 }
22535 {
22536 PyThreadState* __tstate = wxPyBeginAllowThreads();
22537 (arg1)->SetAppName((wxString const &)*arg2);
22538 wxPyEndAllowThreads(__tstate);
22539 if (PyErr_Occurred()) SWIG_fail;
22540 }
22541 resultobj = SWIG_Py_Void();
22542 {
22543 if (temp2)
22544 delete arg2;
22545 }
22546 return resultobj;
22547 fail:
22548 {
22549 if (temp2)
22550 delete arg2;
22551 }
22552 return NULL;
22553 }
22554
22555
22556 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22557 PyObject *resultobj = 0;
22558 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22559 wxString *arg2 = 0 ;
22560 void *argp1 = 0 ;
22561 int res1 = 0 ;
22562 bool temp2 = false ;
22563 PyObject * obj0 = 0 ;
22564 PyObject * obj1 = 0 ;
22565 char * kwnames[] = {
22566 (char *) "self",(char *) "vendorName", NULL
22567 };
22568
22569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22571 if (!SWIG_IsOK(res1)) {
22572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22573 }
22574 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22575 {
22576 arg2 = wxString_in_helper(obj1);
22577 if (arg2 == NULL) SWIG_fail;
22578 temp2 = true;
22579 }
22580 {
22581 PyThreadState* __tstate = wxPyBeginAllowThreads();
22582 (arg1)->SetVendorName((wxString const &)*arg2);
22583 wxPyEndAllowThreads(__tstate);
22584 if (PyErr_Occurred()) SWIG_fail;
22585 }
22586 resultobj = SWIG_Py_Void();
22587 {
22588 if (temp2)
22589 delete arg2;
22590 }
22591 return resultobj;
22592 fail:
22593 {
22594 if (temp2)
22595 delete arg2;
22596 }
22597 return NULL;
22598 }
22599
22600
22601 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22602 PyObject *resultobj = 0;
22603 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22604 long arg2 ;
22605 void *argp1 = 0 ;
22606 int res1 = 0 ;
22607 long val2 ;
22608 int ecode2 = 0 ;
22609 PyObject * obj0 = 0 ;
22610 PyObject * obj1 = 0 ;
22611 char * kwnames[] = {
22612 (char *) "self",(char *) "style", NULL
22613 };
22614
22615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22617 if (!SWIG_IsOK(res1)) {
22618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22619 }
22620 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22621 ecode2 = SWIG_AsVal_long(obj1, &val2);
22622 if (!SWIG_IsOK(ecode2)) {
22623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22624 }
22625 arg2 = static_cast< long >(val2);
22626 {
22627 PyThreadState* __tstate = wxPyBeginAllowThreads();
22628 (arg1)->SetStyle(arg2);
22629 wxPyEndAllowThreads(__tstate);
22630 if (PyErr_Occurred()) SWIG_fail;
22631 }
22632 resultobj = SWIG_Py_Void();
22633 return resultobj;
22634 fail:
22635 return NULL;
22636 }
22637
22638
22639 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22640 PyObject *resultobj = 0;
22641 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22642 long result;
22643 void *argp1 = 0 ;
22644 int res1 = 0 ;
22645 PyObject *swig_obj[1] ;
22646
22647 if (!args) SWIG_fail;
22648 swig_obj[0] = args;
22649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22650 if (!SWIG_IsOK(res1)) {
22651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22652 }
22653 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22654 {
22655 PyThreadState* __tstate = wxPyBeginAllowThreads();
22656 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22657 wxPyEndAllowThreads(__tstate);
22658 if (PyErr_Occurred()) SWIG_fail;
22659 }
22660 resultobj = SWIG_From_long(static_cast< long >(result));
22661 return resultobj;
22662 fail:
22663 return NULL;
22664 }
22665
22666
22667 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22668 PyObject *obj;
22669 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22670 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22671 return SWIG_Py_Void();
22672 }
22673
22674 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22675 PyObject *resultobj = 0;
22676 wxString const &arg1_defvalue = wxPyEmptyString ;
22677 wxString *arg1 = (wxString *) &arg1_defvalue ;
22678 wxString const &arg2_defvalue = wxPyEmptyString ;
22679 wxString *arg2 = (wxString *) &arg2_defvalue ;
22680 wxString const &arg3_defvalue = wxPyEmptyString ;
22681 wxString *arg3 = (wxString *) &arg3_defvalue ;
22682 wxString const &arg4_defvalue = wxPyEmptyString ;
22683 wxString *arg4 = (wxString *) &arg4_defvalue ;
22684 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22685 wxConfig *result = 0 ;
22686 bool temp1 = false ;
22687 bool temp2 = false ;
22688 bool temp3 = false ;
22689 bool temp4 = false ;
22690 long val5 ;
22691 int ecode5 = 0 ;
22692 PyObject * obj0 = 0 ;
22693 PyObject * obj1 = 0 ;
22694 PyObject * obj2 = 0 ;
22695 PyObject * obj3 = 0 ;
22696 PyObject * obj4 = 0 ;
22697 char * kwnames[] = {
22698 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22699 };
22700
22701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22702 if (obj0) {
22703 {
22704 arg1 = wxString_in_helper(obj0);
22705 if (arg1 == NULL) SWIG_fail;
22706 temp1 = true;
22707 }
22708 }
22709 if (obj1) {
22710 {
22711 arg2 = wxString_in_helper(obj1);
22712 if (arg2 == NULL) SWIG_fail;
22713 temp2 = true;
22714 }
22715 }
22716 if (obj2) {
22717 {
22718 arg3 = wxString_in_helper(obj2);
22719 if (arg3 == NULL) SWIG_fail;
22720 temp3 = true;
22721 }
22722 }
22723 if (obj3) {
22724 {
22725 arg4 = wxString_in_helper(obj3);
22726 if (arg4 == NULL) SWIG_fail;
22727 temp4 = true;
22728 }
22729 }
22730 if (obj4) {
22731 ecode5 = SWIG_AsVal_long(obj4, &val5);
22732 if (!SWIG_IsOK(ecode5)) {
22733 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22734 }
22735 arg5 = static_cast< long >(val5);
22736 }
22737 {
22738 PyThreadState* __tstate = wxPyBeginAllowThreads();
22739 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22740 wxPyEndAllowThreads(__tstate);
22741 if (PyErr_Occurred()) SWIG_fail;
22742 }
22743 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22744 {
22745 if (temp1)
22746 delete arg1;
22747 }
22748 {
22749 if (temp2)
22750 delete arg2;
22751 }
22752 {
22753 if (temp3)
22754 delete arg3;
22755 }
22756 {
22757 if (temp4)
22758 delete arg4;
22759 }
22760 return resultobj;
22761 fail:
22762 {
22763 if (temp1)
22764 delete arg1;
22765 }
22766 {
22767 if (temp2)
22768 delete arg2;
22769 }
22770 {
22771 if (temp3)
22772 delete arg3;
22773 }
22774 {
22775 if (temp4)
22776 delete arg4;
22777 }
22778 return NULL;
22779 }
22780
22781
22782 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22783 PyObject *resultobj = 0;
22784 wxConfig *arg1 = (wxConfig *) 0 ;
22785 void *argp1 = 0 ;
22786 int res1 = 0 ;
22787 PyObject *swig_obj[1] ;
22788
22789 if (!args) SWIG_fail;
22790 swig_obj[0] = args;
22791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22792 if (!SWIG_IsOK(res1)) {
22793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22794 }
22795 arg1 = reinterpret_cast< wxConfig * >(argp1);
22796 {
22797 PyThreadState* __tstate = wxPyBeginAllowThreads();
22798 delete arg1;
22799
22800 wxPyEndAllowThreads(__tstate);
22801 if (PyErr_Occurred()) SWIG_fail;
22802 }
22803 resultobj = SWIG_Py_Void();
22804 return resultobj;
22805 fail:
22806 return NULL;
22807 }
22808
22809
22810 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22811 PyObject *obj;
22812 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22813 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22814 return SWIG_Py_Void();
22815 }
22816
22817 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22818 return SWIG_Python_InitShadowInstance(args);
22819 }
22820
22821 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22822 PyObject *resultobj = 0;
22823 wxString const &arg1_defvalue = wxPyEmptyString ;
22824 wxString *arg1 = (wxString *) &arg1_defvalue ;
22825 wxString const &arg2_defvalue = wxPyEmptyString ;
22826 wxString *arg2 = (wxString *) &arg2_defvalue ;
22827 wxString const &arg3_defvalue = wxPyEmptyString ;
22828 wxString *arg3 = (wxString *) &arg3_defvalue ;
22829 wxString const &arg4_defvalue = wxPyEmptyString ;
22830 wxString *arg4 = (wxString *) &arg4_defvalue ;
22831 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22832 wxFileConfig *result = 0 ;
22833 bool temp1 = false ;
22834 bool temp2 = false ;
22835 bool temp3 = false ;
22836 bool temp4 = false ;
22837 long val5 ;
22838 int ecode5 = 0 ;
22839 PyObject * obj0 = 0 ;
22840 PyObject * obj1 = 0 ;
22841 PyObject * obj2 = 0 ;
22842 PyObject * obj3 = 0 ;
22843 PyObject * obj4 = 0 ;
22844 char * kwnames[] = {
22845 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22846 };
22847
22848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22849 if (obj0) {
22850 {
22851 arg1 = wxString_in_helper(obj0);
22852 if (arg1 == NULL) SWIG_fail;
22853 temp1 = true;
22854 }
22855 }
22856 if (obj1) {
22857 {
22858 arg2 = wxString_in_helper(obj1);
22859 if (arg2 == NULL) SWIG_fail;
22860 temp2 = true;
22861 }
22862 }
22863 if (obj2) {
22864 {
22865 arg3 = wxString_in_helper(obj2);
22866 if (arg3 == NULL) SWIG_fail;
22867 temp3 = true;
22868 }
22869 }
22870 if (obj3) {
22871 {
22872 arg4 = wxString_in_helper(obj3);
22873 if (arg4 == NULL) SWIG_fail;
22874 temp4 = true;
22875 }
22876 }
22877 if (obj4) {
22878 ecode5 = SWIG_AsVal_long(obj4, &val5);
22879 if (!SWIG_IsOK(ecode5)) {
22880 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22881 }
22882 arg5 = static_cast< long >(val5);
22883 }
22884 {
22885 PyThreadState* __tstate = wxPyBeginAllowThreads();
22886 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22887 wxPyEndAllowThreads(__tstate);
22888 if (PyErr_Occurred()) SWIG_fail;
22889 }
22890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22891 {
22892 if (temp1)
22893 delete arg1;
22894 }
22895 {
22896 if (temp2)
22897 delete arg2;
22898 }
22899 {
22900 if (temp3)
22901 delete arg3;
22902 }
22903 {
22904 if (temp4)
22905 delete arg4;
22906 }
22907 return resultobj;
22908 fail:
22909 {
22910 if (temp1)
22911 delete arg1;
22912 }
22913 {
22914 if (temp2)
22915 delete arg2;
22916 }
22917 {
22918 if (temp3)
22919 delete arg3;
22920 }
22921 {
22922 if (temp4)
22923 delete arg4;
22924 }
22925 return NULL;
22926 }
22927
22928
22929 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22930 PyObject *resultobj = 0;
22931 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22932 void *argp1 = 0 ;
22933 int res1 = 0 ;
22934 PyObject *swig_obj[1] ;
22935
22936 if (!args) SWIG_fail;
22937 swig_obj[0] = args;
22938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22939 if (!SWIG_IsOK(res1)) {
22940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22941 }
22942 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22943 {
22944 PyThreadState* __tstate = wxPyBeginAllowThreads();
22945 delete arg1;
22946
22947 wxPyEndAllowThreads(__tstate);
22948 if (PyErr_Occurred()) SWIG_fail;
22949 }
22950 resultobj = SWIG_Py_Void();
22951 return resultobj;
22952 fail:
22953 return NULL;
22954 }
22955
22956
22957 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22958 PyObject *obj;
22959 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22960 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22961 return SWIG_Py_Void();
22962 }
22963
22964 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22965 return SWIG_Python_InitShadowInstance(args);
22966 }
22967
22968 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22969 PyObject *resultobj = 0;
22970 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22971 wxString *arg2 = 0 ;
22972 wxConfigPathChanger *result = 0 ;
22973 void *argp1 = 0 ;
22974 int res1 = 0 ;
22975 bool temp2 = false ;
22976 PyObject * obj0 = 0 ;
22977 PyObject * obj1 = 0 ;
22978 char * kwnames[] = {
22979 (char *) "config",(char *) "entry", NULL
22980 };
22981
22982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22984 if (!SWIG_IsOK(res1)) {
22985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22986 }
22987 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22988 {
22989 arg2 = wxString_in_helper(obj1);
22990 if (arg2 == NULL) SWIG_fail;
22991 temp2 = true;
22992 }
22993 {
22994 PyThreadState* __tstate = wxPyBeginAllowThreads();
22995 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
22996 wxPyEndAllowThreads(__tstate);
22997 if (PyErr_Occurred()) SWIG_fail;
22998 }
22999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
23000 {
23001 if (temp2)
23002 delete arg2;
23003 }
23004 return resultobj;
23005 fail:
23006 {
23007 if (temp2)
23008 delete arg2;
23009 }
23010 return NULL;
23011 }
23012
23013
23014 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23015 PyObject *resultobj = 0;
23016 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23017 void *argp1 = 0 ;
23018 int res1 = 0 ;
23019 PyObject *swig_obj[1] ;
23020
23021 if (!args) SWIG_fail;
23022 swig_obj[0] = args;
23023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
23024 if (!SWIG_IsOK(res1)) {
23025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
23026 }
23027 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23028 {
23029 PyThreadState* __tstate = wxPyBeginAllowThreads();
23030 delete arg1;
23031
23032 wxPyEndAllowThreads(__tstate);
23033 if (PyErr_Occurred()) SWIG_fail;
23034 }
23035 resultobj = SWIG_Py_Void();
23036 return resultobj;
23037 fail:
23038 return NULL;
23039 }
23040
23041
23042 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23043 PyObject *resultobj = 0;
23044 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23045 wxString *result = 0 ;
23046 void *argp1 = 0 ;
23047 int res1 = 0 ;
23048 PyObject *swig_obj[1] ;
23049
23050 if (!args) SWIG_fail;
23051 swig_obj[0] = args;
23052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
23053 if (!SWIG_IsOK(res1)) {
23054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
23055 }
23056 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23057 {
23058 PyThreadState* __tstate = wxPyBeginAllowThreads();
23059 {
23060 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
23061 result = (wxString *) &_result_ref;
23062 }
23063 wxPyEndAllowThreads(__tstate);
23064 if (PyErr_Occurred()) SWIG_fail;
23065 }
23066 {
23067 #if wxUSE_UNICODE
23068 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23069 #else
23070 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23071 #endif
23072 }
23073 return resultobj;
23074 fail:
23075 return NULL;
23076 }
23077
23078
23079 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23080 PyObject *obj;
23081 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23082 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
23083 return SWIG_Py_Void();
23084 }
23085
23086 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23087 return SWIG_Python_InitShadowInstance(args);
23088 }
23089
23090 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23091 PyObject *resultobj = 0;
23092 wxString *arg1 = 0 ;
23093 wxString result;
23094 bool temp1 = false ;
23095 PyObject * obj0 = 0 ;
23096 char * kwnames[] = {
23097 (char *) "sz", NULL
23098 };
23099
23100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23101 {
23102 arg1 = wxString_in_helper(obj0);
23103 if (arg1 == NULL) SWIG_fail;
23104 temp1 = true;
23105 }
23106 {
23107 PyThreadState* __tstate = wxPyBeginAllowThreads();
23108 result = wxExpandEnvVars((wxString const &)*arg1);
23109 wxPyEndAllowThreads(__tstate);
23110 if (PyErr_Occurred()) SWIG_fail;
23111 }
23112 {
23113 #if wxUSE_UNICODE
23114 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23115 #else
23116 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23117 #endif
23118 }
23119 {
23120 if (temp1)
23121 delete arg1;
23122 }
23123 return resultobj;
23124 fail:
23125 {
23126 if (temp1)
23127 delete arg1;
23128 }
23129 return NULL;
23130 }
23131
23132
23133 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23134 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23135 return 1;
23136 }
23137
23138
23139 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23140 PyObject *pyobj = 0;
23141
23142 {
23143 #if wxUSE_UNICODE
23144 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23145 #else
23146 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23147 #endif
23148 }
23149 return pyobj;
23150 }
23151
23152
23153 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23154 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23155 return 1;
23156 }
23157
23158
23159 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23160 PyObject *pyobj = 0;
23161
23162 {
23163 #if wxUSE_UNICODE
23164 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23165 #else
23166 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23167 #endif
23168 }
23169 return pyobj;
23170 }
23171
23172
23173 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23174 PyObject *resultobj = 0;
23175 wxDateTime::Country arg1 ;
23176 int val1 ;
23177 int ecode1 = 0 ;
23178 PyObject * obj0 = 0 ;
23179 char * kwnames[] = {
23180 (char *) "country", NULL
23181 };
23182
23183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23184 ecode1 = SWIG_AsVal_int(obj0, &val1);
23185 if (!SWIG_IsOK(ecode1)) {
23186 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23187 }
23188 arg1 = static_cast< wxDateTime::Country >(val1);
23189 {
23190 PyThreadState* __tstate = wxPyBeginAllowThreads();
23191 wxDateTime::SetCountry(arg1);
23192 wxPyEndAllowThreads(__tstate);
23193 if (PyErr_Occurred()) SWIG_fail;
23194 }
23195 resultobj = SWIG_Py_Void();
23196 return resultobj;
23197 fail:
23198 return NULL;
23199 }
23200
23201
23202 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23203 PyObject *resultobj = 0;
23204 wxDateTime::Country result;
23205
23206 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23207 {
23208 PyThreadState* __tstate = wxPyBeginAllowThreads();
23209 result = (wxDateTime::Country)wxDateTime::GetCountry();
23210 wxPyEndAllowThreads(__tstate);
23211 if (PyErr_Occurred()) SWIG_fail;
23212 }
23213 resultobj = SWIG_From_int(static_cast< int >(result));
23214 return resultobj;
23215 fail:
23216 return NULL;
23217 }
23218
23219
23220 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23221 PyObject *resultobj = 0;
23222 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23223 bool result;
23224 int val1 ;
23225 int ecode1 = 0 ;
23226 PyObject * obj0 = 0 ;
23227 char * kwnames[] = {
23228 (char *) "country", NULL
23229 };
23230
23231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23232 if (obj0) {
23233 ecode1 = SWIG_AsVal_int(obj0, &val1);
23234 if (!SWIG_IsOK(ecode1)) {
23235 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23236 }
23237 arg1 = static_cast< wxDateTime::Country >(val1);
23238 }
23239 {
23240 PyThreadState* __tstate = wxPyBeginAllowThreads();
23241 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23242 wxPyEndAllowThreads(__tstate);
23243 if (PyErr_Occurred()) SWIG_fail;
23244 }
23245 {
23246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23247 }
23248 return resultobj;
23249 fail:
23250 return NULL;
23251 }
23252
23253
23254 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23255 PyObject *resultobj = 0;
23256 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23257 int result;
23258 int val1 ;
23259 int ecode1 = 0 ;
23260 PyObject * obj0 = 0 ;
23261 char * kwnames[] = {
23262 (char *) "cal", NULL
23263 };
23264
23265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23266 if (obj0) {
23267 ecode1 = SWIG_AsVal_int(obj0, &val1);
23268 if (!SWIG_IsOK(ecode1)) {
23269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23270 }
23271 arg1 = static_cast< wxDateTime::Calendar >(val1);
23272 }
23273 {
23274 PyThreadState* __tstate = wxPyBeginAllowThreads();
23275 result = (int)wxDateTime::GetCurrentYear(arg1);
23276 wxPyEndAllowThreads(__tstate);
23277 if (PyErr_Occurred()) SWIG_fail;
23278 }
23279 resultobj = SWIG_From_int(static_cast< int >(result));
23280 return resultobj;
23281 fail:
23282 return NULL;
23283 }
23284
23285
23286 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23287 PyObject *resultobj = 0;
23288 int arg1 ;
23289 int result;
23290 int val1 ;
23291 int ecode1 = 0 ;
23292 PyObject * obj0 = 0 ;
23293 char * kwnames[] = {
23294 (char *) "year", NULL
23295 };
23296
23297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23298 ecode1 = SWIG_AsVal_int(obj0, &val1);
23299 if (!SWIG_IsOK(ecode1)) {
23300 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23301 }
23302 arg1 = static_cast< int >(val1);
23303 {
23304 PyThreadState* __tstate = wxPyBeginAllowThreads();
23305 result = (int)wxDateTime::ConvertYearToBC(arg1);
23306 wxPyEndAllowThreads(__tstate);
23307 if (PyErr_Occurred()) SWIG_fail;
23308 }
23309 resultobj = SWIG_From_int(static_cast< int >(result));
23310 return resultobj;
23311 fail:
23312 return NULL;
23313 }
23314
23315
23316 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23317 PyObject *resultobj = 0;
23318 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23319 wxDateTime::Month result;
23320 int val1 ;
23321 int ecode1 = 0 ;
23322 PyObject * obj0 = 0 ;
23323 char * kwnames[] = {
23324 (char *) "cal", NULL
23325 };
23326
23327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23328 if (obj0) {
23329 ecode1 = SWIG_AsVal_int(obj0, &val1);
23330 if (!SWIG_IsOK(ecode1)) {
23331 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23332 }
23333 arg1 = static_cast< wxDateTime::Calendar >(val1);
23334 }
23335 {
23336 PyThreadState* __tstate = wxPyBeginAllowThreads();
23337 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23338 wxPyEndAllowThreads(__tstate);
23339 if (PyErr_Occurred()) SWIG_fail;
23340 }
23341 resultobj = SWIG_From_int(static_cast< int >(result));
23342 return resultobj;
23343 fail:
23344 return NULL;
23345 }
23346
23347
23348 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23349 PyObject *resultobj = 0;
23350 int arg1 = (int) wxDateTime::Inv_Year ;
23351 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23352 bool result;
23353 int val1 ;
23354 int ecode1 = 0 ;
23355 int val2 ;
23356 int ecode2 = 0 ;
23357 PyObject * obj0 = 0 ;
23358 PyObject * obj1 = 0 ;
23359 char * kwnames[] = {
23360 (char *) "year",(char *) "cal", NULL
23361 };
23362
23363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23364 if (obj0) {
23365 ecode1 = SWIG_AsVal_int(obj0, &val1);
23366 if (!SWIG_IsOK(ecode1)) {
23367 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23368 }
23369 arg1 = static_cast< int >(val1);
23370 }
23371 if (obj1) {
23372 ecode2 = SWIG_AsVal_int(obj1, &val2);
23373 if (!SWIG_IsOK(ecode2)) {
23374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23375 }
23376 arg2 = static_cast< wxDateTime::Calendar >(val2);
23377 }
23378 {
23379 PyThreadState* __tstate = wxPyBeginAllowThreads();
23380 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23381 wxPyEndAllowThreads(__tstate);
23382 if (PyErr_Occurred()) SWIG_fail;
23383 }
23384 {
23385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23386 }
23387 return resultobj;
23388 fail:
23389 return NULL;
23390 }
23391
23392
23393 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23394 PyObject *resultobj = 0;
23395 int arg1 = (int) wxDateTime::Inv_Year ;
23396 int result;
23397 int val1 ;
23398 int ecode1 = 0 ;
23399 PyObject * obj0 = 0 ;
23400 char * kwnames[] = {
23401 (char *) "year", NULL
23402 };
23403
23404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23405 if (obj0) {
23406 ecode1 = SWIG_AsVal_int(obj0, &val1);
23407 if (!SWIG_IsOK(ecode1)) {
23408 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23409 }
23410 arg1 = static_cast< int >(val1);
23411 }
23412 {
23413 PyThreadState* __tstate = wxPyBeginAllowThreads();
23414 result = (int)wxDateTime::GetCentury(arg1);
23415 wxPyEndAllowThreads(__tstate);
23416 if (PyErr_Occurred()) SWIG_fail;
23417 }
23418 resultobj = SWIG_From_int(static_cast< int >(result));
23419 return resultobj;
23420 fail:
23421 return NULL;
23422 }
23423
23424
23425 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23426 PyObject *resultobj = 0;
23427 int arg1 ;
23428 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23429 int result;
23430 int val1 ;
23431 int ecode1 = 0 ;
23432 int val2 ;
23433 int ecode2 = 0 ;
23434 PyObject * obj0 = 0 ;
23435 PyObject * obj1 = 0 ;
23436 char * kwnames[] = {
23437 (char *) "year",(char *) "cal", NULL
23438 };
23439
23440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23441 ecode1 = SWIG_AsVal_int(obj0, &val1);
23442 if (!SWIG_IsOK(ecode1)) {
23443 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23444 }
23445 arg1 = static_cast< int >(val1);
23446 if (obj1) {
23447 ecode2 = SWIG_AsVal_int(obj1, &val2);
23448 if (!SWIG_IsOK(ecode2)) {
23449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23450 }
23451 arg2 = static_cast< wxDateTime::Calendar >(val2);
23452 }
23453 {
23454 PyThreadState* __tstate = wxPyBeginAllowThreads();
23455 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23456 wxPyEndAllowThreads(__tstate);
23457 if (PyErr_Occurred()) SWIG_fail;
23458 }
23459 resultobj = SWIG_From_int(static_cast< int >(result));
23460 return resultobj;
23461 fail:
23462 return NULL;
23463 }
23464
23465
23466 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23467 PyObject *resultobj = 0;
23468 wxDateTime::Month arg1 ;
23469 int arg2 = (int) wxDateTime::Inv_Year ;
23470 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23471 int result;
23472 int val1 ;
23473 int ecode1 = 0 ;
23474 int val2 ;
23475 int ecode2 = 0 ;
23476 int val3 ;
23477 int ecode3 = 0 ;
23478 PyObject * obj0 = 0 ;
23479 PyObject * obj1 = 0 ;
23480 PyObject * obj2 = 0 ;
23481 char * kwnames[] = {
23482 (char *) "month",(char *) "year",(char *) "cal", NULL
23483 };
23484
23485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23486 ecode1 = SWIG_AsVal_int(obj0, &val1);
23487 if (!SWIG_IsOK(ecode1)) {
23488 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23489 }
23490 arg1 = static_cast< wxDateTime::Month >(val1);
23491 if (obj1) {
23492 ecode2 = SWIG_AsVal_int(obj1, &val2);
23493 if (!SWIG_IsOK(ecode2)) {
23494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23495 }
23496 arg2 = static_cast< int >(val2);
23497 }
23498 if (obj2) {
23499 ecode3 = SWIG_AsVal_int(obj2, &val3);
23500 if (!SWIG_IsOK(ecode3)) {
23501 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23502 }
23503 arg3 = static_cast< wxDateTime::Calendar >(val3);
23504 }
23505 {
23506 PyThreadState* __tstate = wxPyBeginAllowThreads();
23507 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23508 wxPyEndAllowThreads(__tstate);
23509 if (PyErr_Occurred()) SWIG_fail;
23510 }
23511 resultobj = SWIG_From_int(static_cast< int >(result));
23512 return resultobj;
23513 fail:
23514 return NULL;
23515 }
23516
23517
23518 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23519 PyObject *resultobj = 0;
23520 wxDateTime::Month arg1 ;
23521 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23522 wxString result;
23523 int val1 ;
23524 int ecode1 = 0 ;
23525 int val2 ;
23526 int ecode2 = 0 ;
23527 PyObject * obj0 = 0 ;
23528 PyObject * obj1 = 0 ;
23529 char * kwnames[] = {
23530 (char *) "month",(char *) "flags", NULL
23531 };
23532
23533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23534 ecode1 = SWIG_AsVal_int(obj0, &val1);
23535 if (!SWIG_IsOK(ecode1)) {
23536 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23537 }
23538 arg1 = static_cast< wxDateTime::Month >(val1);
23539 if (obj1) {
23540 ecode2 = SWIG_AsVal_int(obj1, &val2);
23541 if (!SWIG_IsOK(ecode2)) {
23542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23543 }
23544 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23545 }
23546 {
23547 PyThreadState* __tstate = wxPyBeginAllowThreads();
23548 result = wxDateTime::GetMonthName(arg1,arg2);
23549 wxPyEndAllowThreads(__tstate);
23550 if (PyErr_Occurred()) SWIG_fail;
23551 }
23552 {
23553 #if wxUSE_UNICODE
23554 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23555 #else
23556 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23557 #endif
23558 }
23559 return resultobj;
23560 fail:
23561 return NULL;
23562 }
23563
23564
23565 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23566 PyObject *resultobj = 0;
23567 wxDateTime::WeekDay arg1 ;
23568 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23569 wxString result;
23570 int val1 ;
23571 int ecode1 = 0 ;
23572 int val2 ;
23573 int ecode2 = 0 ;
23574 PyObject * obj0 = 0 ;
23575 PyObject * obj1 = 0 ;
23576 char * kwnames[] = {
23577 (char *) "weekday",(char *) "flags", NULL
23578 };
23579
23580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23581 ecode1 = SWIG_AsVal_int(obj0, &val1);
23582 if (!SWIG_IsOK(ecode1)) {
23583 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23584 }
23585 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23586 if (obj1) {
23587 ecode2 = SWIG_AsVal_int(obj1, &val2);
23588 if (!SWIG_IsOK(ecode2)) {
23589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23590 }
23591 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23592 }
23593 {
23594 PyThreadState* __tstate = wxPyBeginAllowThreads();
23595 result = wxDateTime::GetWeekDayName(arg1,arg2);
23596 wxPyEndAllowThreads(__tstate);
23597 if (PyErr_Occurred()) SWIG_fail;
23598 }
23599 {
23600 #if wxUSE_UNICODE
23601 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23602 #else
23603 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23604 #endif
23605 }
23606 return resultobj;
23607 fail:
23608 return NULL;
23609 }
23610
23611
23612 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23613 PyObject *resultobj = 0;
23614 PyObject *result = 0 ;
23615
23616 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23617 {
23618 PyThreadState* __tstate = wxPyBeginAllowThreads();
23619 result = (PyObject *)wxDateTime_GetAmPmStrings();
23620 wxPyEndAllowThreads(__tstate);
23621 if (PyErr_Occurred()) SWIG_fail;
23622 }
23623 resultobj = result;
23624 return resultobj;
23625 fail:
23626 return NULL;
23627 }
23628
23629
23630 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23631 PyObject *resultobj = 0;
23632 int arg1 = (int) wxDateTime::Inv_Year ;
23633 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23634 bool result;
23635 int val1 ;
23636 int ecode1 = 0 ;
23637 int val2 ;
23638 int ecode2 = 0 ;
23639 PyObject * obj0 = 0 ;
23640 PyObject * obj1 = 0 ;
23641 char * kwnames[] = {
23642 (char *) "year",(char *) "country", NULL
23643 };
23644
23645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23646 if (obj0) {
23647 ecode1 = SWIG_AsVal_int(obj0, &val1);
23648 if (!SWIG_IsOK(ecode1)) {
23649 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23650 }
23651 arg1 = static_cast< int >(val1);
23652 }
23653 if (obj1) {
23654 ecode2 = SWIG_AsVal_int(obj1, &val2);
23655 if (!SWIG_IsOK(ecode2)) {
23656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23657 }
23658 arg2 = static_cast< wxDateTime::Country >(val2);
23659 }
23660 {
23661 PyThreadState* __tstate = wxPyBeginAllowThreads();
23662 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23663 wxPyEndAllowThreads(__tstate);
23664 if (PyErr_Occurred()) SWIG_fail;
23665 }
23666 {
23667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23668 }
23669 return resultobj;
23670 fail:
23671 return NULL;
23672 }
23673
23674
23675 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23676 PyObject *resultobj = 0;
23677 int arg1 = (int) wxDateTime::Inv_Year ;
23678 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23679 wxDateTime result;
23680 int val1 ;
23681 int ecode1 = 0 ;
23682 int val2 ;
23683 int ecode2 = 0 ;
23684 PyObject * obj0 = 0 ;
23685 PyObject * obj1 = 0 ;
23686 char * kwnames[] = {
23687 (char *) "year",(char *) "country", NULL
23688 };
23689
23690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23691 if (obj0) {
23692 ecode1 = SWIG_AsVal_int(obj0, &val1);
23693 if (!SWIG_IsOK(ecode1)) {
23694 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23695 }
23696 arg1 = static_cast< int >(val1);
23697 }
23698 if (obj1) {
23699 ecode2 = SWIG_AsVal_int(obj1, &val2);
23700 if (!SWIG_IsOK(ecode2)) {
23701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23702 }
23703 arg2 = static_cast< wxDateTime::Country >(val2);
23704 }
23705 {
23706 PyThreadState* __tstate = wxPyBeginAllowThreads();
23707 result = wxDateTime::GetBeginDST(arg1,arg2);
23708 wxPyEndAllowThreads(__tstate);
23709 if (PyErr_Occurred()) SWIG_fail;
23710 }
23711 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23712 return resultobj;
23713 fail:
23714 return NULL;
23715 }
23716
23717
23718 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23719 PyObject *resultobj = 0;
23720 int arg1 = (int) wxDateTime::Inv_Year ;
23721 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23722 wxDateTime result;
23723 int val1 ;
23724 int ecode1 = 0 ;
23725 int val2 ;
23726 int ecode2 = 0 ;
23727 PyObject * obj0 = 0 ;
23728 PyObject * obj1 = 0 ;
23729 char * kwnames[] = {
23730 (char *) "year",(char *) "country", NULL
23731 };
23732
23733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23734 if (obj0) {
23735 ecode1 = SWIG_AsVal_int(obj0, &val1);
23736 if (!SWIG_IsOK(ecode1)) {
23737 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23738 }
23739 arg1 = static_cast< int >(val1);
23740 }
23741 if (obj1) {
23742 ecode2 = SWIG_AsVal_int(obj1, &val2);
23743 if (!SWIG_IsOK(ecode2)) {
23744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23745 }
23746 arg2 = static_cast< wxDateTime::Country >(val2);
23747 }
23748 {
23749 PyThreadState* __tstate = wxPyBeginAllowThreads();
23750 result = wxDateTime::GetEndDST(arg1,arg2);
23751 wxPyEndAllowThreads(__tstate);
23752 if (PyErr_Occurred()) SWIG_fail;
23753 }
23754 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23755 return resultobj;
23756 fail:
23757 return NULL;
23758 }
23759
23760
23761 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23762 PyObject *resultobj = 0;
23763 wxDateTime result;
23764
23765 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23766 {
23767 PyThreadState* __tstate = wxPyBeginAllowThreads();
23768 result = wxDateTime::Now();
23769 wxPyEndAllowThreads(__tstate);
23770 if (PyErr_Occurred()) SWIG_fail;
23771 }
23772 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23773 return resultobj;
23774 fail:
23775 return NULL;
23776 }
23777
23778
23779 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23780 PyObject *resultobj = 0;
23781 wxDateTime result;
23782
23783 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23784 {
23785 PyThreadState* __tstate = wxPyBeginAllowThreads();
23786 result = wxDateTime::UNow();
23787 wxPyEndAllowThreads(__tstate);
23788 if (PyErr_Occurred()) SWIG_fail;
23789 }
23790 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23791 return resultobj;
23792 fail:
23793 return NULL;
23794 }
23795
23796
23797 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23798 PyObject *resultobj = 0;
23799 wxDateTime result;
23800
23801 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23802 {
23803 PyThreadState* __tstate = wxPyBeginAllowThreads();
23804 result = wxDateTime::Today();
23805 wxPyEndAllowThreads(__tstate);
23806 if (PyErr_Occurred()) SWIG_fail;
23807 }
23808 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23809 return resultobj;
23810 fail:
23811 return NULL;
23812 }
23813
23814
23815 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23816 PyObject *resultobj = 0;
23817 wxDateTime *result = 0 ;
23818
23819 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23820 {
23821 PyThreadState* __tstate = wxPyBeginAllowThreads();
23822 result = (wxDateTime *)new wxDateTime();
23823 wxPyEndAllowThreads(__tstate);
23824 if (PyErr_Occurred()) SWIG_fail;
23825 }
23826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23827 return resultobj;
23828 fail:
23829 return NULL;
23830 }
23831
23832
23833 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23834 PyObject *resultobj = 0;
23835 time_t arg1 ;
23836 wxDateTime *result = 0 ;
23837 unsigned int val1 ;
23838 int ecode1 = 0 ;
23839 PyObject * obj0 = 0 ;
23840 char * kwnames[] = {
23841 (char *) "timet", NULL
23842 };
23843
23844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23845 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23846 if (!SWIG_IsOK(ecode1)) {
23847 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23848 }
23849 arg1 = static_cast< time_t >(val1);
23850 {
23851 PyThreadState* __tstate = wxPyBeginAllowThreads();
23852 result = (wxDateTime *)new wxDateTime(arg1);
23853 wxPyEndAllowThreads(__tstate);
23854 if (PyErr_Occurred()) SWIG_fail;
23855 }
23856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23857 return resultobj;
23858 fail:
23859 return NULL;
23860 }
23861
23862
23863 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23864 PyObject *resultobj = 0;
23865 double arg1 ;
23866 wxDateTime *result = 0 ;
23867 double val1 ;
23868 int ecode1 = 0 ;
23869 PyObject * obj0 = 0 ;
23870 char * kwnames[] = {
23871 (char *) "jdn", NULL
23872 };
23873
23874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23875 ecode1 = SWIG_AsVal_double(obj0, &val1);
23876 if (!SWIG_IsOK(ecode1)) {
23877 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23878 }
23879 arg1 = static_cast< double >(val1);
23880 {
23881 PyThreadState* __tstate = wxPyBeginAllowThreads();
23882 result = (wxDateTime *)new wxDateTime(arg1);
23883 wxPyEndAllowThreads(__tstate);
23884 if (PyErr_Occurred()) SWIG_fail;
23885 }
23886 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23887 return resultobj;
23888 fail:
23889 return NULL;
23890 }
23891
23892
23893 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23894 PyObject *resultobj = 0;
23895 int arg1 ;
23896 int arg2 = (int) 0 ;
23897 int arg3 = (int) 0 ;
23898 int arg4 = (int) 0 ;
23899 wxDateTime *result = 0 ;
23900 int val1 ;
23901 int ecode1 = 0 ;
23902 int val2 ;
23903 int ecode2 = 0 ;
23904 int val3 ;
23905 int ecode3 = 0 ;
23906 int val4 ;
23907 int ecode4 = 0 ;
23908 PyObject * obj0 = 0 ;
23909 PyObject * obj1 = 0 ;
23910 PyObject * obj2 = 0 ;
23911 PyObject * obj3 = 0 ;
23912 char * kwnames[] = {
23913 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23914 };
23915
23916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23917 ecode1 = SWIG_AsVal_int(obj0, &val1);
23918 if (!SWIG_IsOK(ecode1)) {
23919 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23920 }
23921 arg1 = static_cast< int >(val1);
23922 if (obj1) {
23923 ecode2 = SWIG_AsVal_int(obj1, &val2);
23924 if (!SWIG_IsOK(ecode2)) {
23925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23926 }
23927 arg2 = static_cast< int >(val2);
23928 }
23929 if (obj2) {
23930 ecode3 = SWIG_AsVal_int(obj2, &val3);
23931 if (!SWIG_IsOK(ecode3)) {
23932 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23933 }
23934 arg3 = static_cast< int >(val3);
23935 }
23936 if (obj3) {
23937 ecode4 = SWIG_AsVal_int(obj3, &val4);
23938 if (!SWIG_IsOK(ecode4)) {
23939 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23940 }
23941 arg4 = static_cast< int >(val4);
23942 }
23943 {
23944 PyThreadState* __tstate = wxPyBeginAllowThreads();
23945 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23946 wxPyEndAllowThreads(__tstate);
23947 if (PyErr_Occurred()) SWIG_fail;
23948 }
23949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23950 return resultobj;
23951 fail:
23952 return NULL;
23953 }
23954
23955
23956 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23957 PyObject *resultobj = 0;
23958 int arg1 ;
23959 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23960 int arg3 = (int) wxDateTime::Inv_Year ;
23961 int arg4 = (int) 0 ;
23962 int arg5 = (int) 0 ;
23963 int arg6 = (int) 0 ;
23964 int arg7 = (int) 0 ;
23965 wxDateTime *result = 0 ;
23966 int val1 ;
23967 int ecode1 = 0 ;
23968 int val2 ;
23969 int ecode2 = 0 ;
23970 int val3 ;
23971 int ecode3 = 0 ;
23972 int val4 ;
23973 int ecode4 = 0 ;
23974 int val5 ;
23975 int ecode5 = 0 ;
23976 int val6 ;
23977 int ecode6 = 0 ;
23978 int val7 ;
23979 int ecode7 = 0 ;
23980 PyObject * obj0 = 0 ;
23981 PyObject * obj1 = 0 ;
23982 PyObject * obj2 = 0 ;
23983 PyObject * obj3 = 0 ;
23984 PyObject * obj4 = 0 ;
23985 PyObject * obj5 = 0 ;
23986 PyObject * obj6 = 0 ;
23987 char * kwnames[] = {
23988 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23989 };
23990
23991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23992 ecode1 = SWIG_AsVal_int(obj0, &val1);
23993 if (!SWIG_IsOK(ecode1)) {
23994 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
23995 }
23996 arg1 = static_cast< int >(val1);
23997 if (obj1) {
23998 ecode2 = SWIG_AsVal_int(obj1, &val2);
23999 if (!SWIG_IsOK(ecode2)) {
24000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24001 }
24002 arg2 = static_cast< wxDateTime::Month >(val2);
24003 }
24004 if (obj2) {
24005 ecode3 = SWIG_AsVal_int(obj2, &val3);
24006 if (!SWIG_IsOK(ecode3)) {
24007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
24008 }
24009 arg3 = static_cast< int >(val3);
24010 }
24011 if (obj3) {
24012 ecode4 = SWIG_AsVal_int(obj3, &val4);
24013 if (!SWIG_IsOK(ecode4)) {
24014 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
24015 }
24016 arg4 = static_cast< int >(val4);
24017 }
24018 if (obj4) {
24019 ecode5 = SWIG_AsVal_int(obj4, &val5);
24020 if (!SWIG_IsOK(ecode5)) {
24021 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
24022 }
24023 arg5 = static_cast< int >(val5);
24024 }
24025 if (obj5) {
24026 ecode6 = SWIG_AsVal_int(obj5, &val6);
24027 if (!SWIG_IsOK(ecode6)) {
24028 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
24029 }
24030 arg6 = static_cast< int >(val6);
24031 }
24032 if (obj6) {
24033 ecode7 = SWIG_AsVal_int(obj6, &val7);
24034 if (!SWIG_IsOK(ecode7)) {
24035 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
24036 }
24037 arg7 = static_cast< int >(val7);
24038 }
24039 {
24040 PyThreadState* __tstate = wxPyBeginAllowThreads();
24041 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24042 wxPyEndAllowThreads(__tstate);
24043 if (PyErr_Occurred()) SWIG_fail;
24044 }
24045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24046 return resultobj;
24047 fail:
24048 return NULL;
24049 }
24050
24051
24052 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24053 PyObject *resultobj = 0;
24054 wxDateTime *arg1 = 0 ;
24055 wxDateTime *result = 0 ;
24056 void *argp1 = 0 ;
24057 int res1 = 0 ;
24058 PyObject * obj0 = 0 ;
24059 char * kwnames[] = {
24060 (char *) "date", NULL
24061 };
24062
24063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
24064 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
24065 if (!SWIG_IsOK(res1)) {
24066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24067 }
24068 if (!argp1) {
24069 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24070 }
24071 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24072 {
24073 PyThreadState* __tstate = wxPyBeginAllowThreads();
24074 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
24075 wxPyEndAllowThreads(__tstate);
24076 if (PyErr_Occurred()) SWIG_fail;
24077 }
24078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24079 return resultobj;
24080 fail:
24081 return NULL;
24082 }
24083
24084
24085 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24086 PyObject *resultobj = 0;
24087 wxDateTime *arg1 = (wxDateTime *) 0 ;
24088 void *argp1 = 0 ;
24089 int res1 = 0 ;
24090 PyObject *swig_obj[1] ;
24091
24092 if (!args) SWIG_fail;
24093 swig_obj[0] = args;
24094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24095 if (!SWIG_IsOK(res1)) {
24096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24097 }
24098 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24099 {
24100 PyThreadState* __tstate = wxPyBeginAllowThreads();
24101 delete arg1;
24102
24103 wxPyEndAllowThreads(__tstate);
24104 if (PyErr_Occurred()) SWIG_fail;
24105 }
24106 resultobj = SWIG_Py_Void();
24107 return resultobj;
24108 fail:
24109 return NULL;
24110 }
24111
24112
24113 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24114 PyObject *resultobj = 0;
24115 wxDateTime *arg1 = (wxDateTime *) 0 ;
24116 wxDateTime *result = 0 ;
24117 void *argp1 = 0 ;
24118 int res1 = 0 ;
24119 PyObject *swig_obj[1] ;
24120
24121 if (!args) SWIG_fail;
24122 swig_obj[0] = args;
24123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24124 if (!SWIG_IsOK(res1)) {
24125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24126 }
24127 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24128 {
24129 PyThreadState* __tstate = wxPyBeginAllowThreads();
24130 {
24131 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24132 result = (wxDateTime *) &_result_ref;
24133 }
24134 wxPyEndAllowThreads(__tstate);
24135 if (PyErr_Occurred()) SWIG_fail;
24136 }
24137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24138 return resultobj;
24139 fail:
24140 return NULL;
24141 }
24142
24143
24144 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24145 PyObject *resultobj = 0;
24146 wxDateTime *arg1 = (wxDateTime *) 0 ;
24147 time_t arg2 ;
24148 wxDateTime *result = 0 ;
24149 void *argp1 = 0 ;
24150 int res1 = 0 ;
24151 unsigned int val2 ;
24152 int ecode2 = 0 ;
24153 PyObject * obj0 = 0 ;
24154 PyObject * obj1 = 0 ;
24155 char * kwnames[] = {
24156 (char *) "self",(char *) "timet", NULL
24157 };
24158
24159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24161 if (!SWIG_IsOK(res1)) {
24162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24163 }
24164 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24165 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24166 if (!SWIG_IsOK(ecode2)) {
24167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24168 }
24169 arg2 = static_cast< time_t >(val2);
24170 {
24171 PyThreadState* __tstate = wxPyBeginAllowThreads();
24172 {
24173 wxDateTime &_result_ref = (arg1)->Set(arg2);
24174 result = (wxDateTime *) &_result_ref;
24175 }
24176 wxPyEndAllowThreads(__tstate);
24177 if (PyErr_Occurred()) SWIG_fail;
24178 }
24179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24180 return resultobj;
24181 fail:
24182 return NULL;
24183 }
24184
24185
24186 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24187 PyObject *resultobj = 0;
24188 wxDateTime *arg1 = (wxDateTime *) 0 ;
24189 double arg2 ;
24190 wxDateTime *result = 0 ;
24191 void *argp1 = 0 ;
24192 int res1 = 0 ;
24193 double val2 ;
24194 int ecode2 = 0 ;
24195 PyObject * obj0 = 0 ;
24196 PyObject * obj1 = 0 ;
24197 char * kwnames[] = {
24198 (char *) "self",(char *) "jdn", NULL
24199 };
24200
24201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24203 if (!SWIG_IsOK(res1)) {
24204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24205 }
24206 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24207 ecode2 = SWIG_AsVal_double(obj1, &val2);
24208 if (!SWIG_IsOK(ecode2)) {
24209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24210 }
24211 arg2 = static_cast< double >(val2);
24212 {
24213 PyThreadState* __tstate = wxPyBeginAllowThreads();
24214 {
24215 wxDateTime &_result_ref = (arg1)->Set(arg2);
24216 result = (wxDateTime *) &_result_ref;
24217 }
24218 wxPyEndAllowThreads(__tstate);
24219 if (PyErr_Occurred()) SWIG_fail;
24220 }
24221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24222 return resultobj;
24223 fail:
24224 return NULL;
24225 }
24226
24227
24228 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24229 PyObject *resultobj = 0;
24230 wxDateTime *arg1 = (wxDateTime *) 0 ;
24231 int arg2 ;
24232 int arg3 = (int) 0 ;
24233 int arg4 = (int) 0 ;
24234 int arg5 = (int) 0 ;
24235 wxDateTime *result = 0 ;
24236 void *argp1 = 0 ;
24237 int res1 = 0 ;
24238 int val2 ;
24239 int ecode2 = 0 ;
24240 int val3 ;
24241 int ecode3 = 0 ;
24242 int val4 ;
24243 int ecode4 = 0 ;
24244 int val5 ;
24245 int ecode5 = 0 ;
24246 PyObject * obj0 = 0 ;
24247 PyObject * obj1 = 0 ;
24248 PyObject * obj2 = 0 ;
24249 PyObject * obj3 = 0 ;
24250 PyObject * obj4 = 0 ;
24251 char * kwnames[] = {
24252 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24253 };
24254
24255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24257 if (!SWIG_IsOK(res1)) {
24258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24259 }
24260 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24261 ecode2 = SWIG_AsVal_int(obj1, &val2);
24262 if (!SWIG_IsOK(ecode2)) {
24263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24264 }
24265 arg2 = static_cast< int >(val2);
24266 if (obj2) {
24267 ecode3 = SWIG_AsVal_int(obj2, &val3);
24268 if (!SWIG_IsOK(ecode3)) {
24269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24270 }
24271 arg3 = static_cast< int >(val3);
24272 }
24273 if (obj3) {
24274 ecode4 = SWIG_AsVal_int(obj3, &val4);
24275 if (!SWIG_IsOK(ecode4)) {
24276 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24277 }
24278 arg4 = static_cast< int >(val4);
24279 }
24280 if (obj4) {
24281 ecode5 = SWIG_AsVal_int(obj4, &val5);
24282 if (!SWIG_IsOK(ecode5)) {
24283 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24284 }
24285 arg5 = static_cast< int >(val5);
24286 }
24287 {
24288 PyThreadState* __tstate = wxPyBeginAllowThreads();
24289 {
24290 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24291 result = (wxDateTime *) &_result_ref;
24292 }
24293 wxPyEndAllowThreads(__tstate);
24294 if (PyErr_Occurred()) SWIG_fail;
24295 }
24296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24297 return resultobj;
24298 fail:
24299 return NULL;
24300 }
24301
24302
24303 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24304 PyObject *resultobj = 0;
24305 wxDateTime *arg1 = (wxDateTime *) 0 ;
24306 int arg2 ;
24307 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24308 int arg4 = (int) wxDateTime::Inv_Year ;
24309 int arg5 = (int) 0 ;
24310 int arg6 = (int) 0 ;
24311 int arg7 = (int) 0 ;
24312 int arg8 = (int) 0 ;
24313 wxDateTime *result = 0 ;
24314 void *argp1 = 0 ;
24315 int res1 = 0 ;
24316 int val2 ;
24317 int ecode2 = 0 ;
24318 int val3 ;
24319 int ecode3 = 0 ;
24320 int val4 ;
24321 int ecode4 = 0 ;
24322 int val5 ;
24323 int ecode5 = 0 ;
24324 int val6 ;
24325 int ecode6 = 0 ;
24326 int val7 ;
24327 int ecode7 = 0 ;
24328 int val8 ;
24329 int ecode8 = 0 ;
24330 PyObject * obj0 = 0 ;
24331 PyObject * obj1 = 0 ;
24332 PyObject * obj2 = 0 ;
24333 PyObject * obj3 = 0 ;
24334 PyObject * obj4 = 0 ;
24335 PyObject * obj5 = 0 ;
24336 PyObject * obj6 = 0 ;
24337 PyObject * obj7 = 0 ;
24338 char * kwnames[] = {
24339 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24340 };
24341
24342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24344 if (!SWIG_IsOK(res1)) {
24345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24346 }
24347 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24348 ecode2 = SWIG_AsVal_int(obj1, &val2);
24349 if (!SWIG_IsOK(ecode2)) {
24350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24351 }
24352 arg2 = static_cast< int >(val2);
24353 if (obj2) {
24354 ecode3 = SWIG_AsVal_int(obj2, &val3);
24355 if (!SWIG_IsOK(ecode3)) {
24356 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24357 }
24358 arg3 = static_cast< wxDateTime::Month >(val3);
24359 }
24360 if (obj3) {
24361 ecode4 = SWIG_AsVal_int(obj3, &val4);
24362 if (!SWIG_IsOK(ecode4)) {
24363 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24364 }
24365 arg4 = static_cast< int >(val4);
24366 }
24367 if (obj4) {
24368 ecode5 = SWIG_AsVal_int(obj4, &val5);
24369 if (!SWIG_IsOK(ecode5)) {
24370 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24371 }
24372 arg5 = static_cast< int >(val5);
24373 }
24374 if (obj5) {
24375 ecode6 = SWIG_AsVal_int(obj5, &val6);
24376 if (!SWIG_IsOK(ecode6)) {
24377 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24378 }
24379 arg6 = static_cast< int >(val6);
24380 }
24381 if (obj6) {
24382 ecode7 = SWIG_AsVal_int(obj6, &val7);
24383 if (!SWIG_IsOK(ecode7)) {
24384 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24385 }
24386 arg7 = static_cast< int >(val7);
24387 }
24388 if (obj7) {
24389 ecode8 = SWIG_AsVal_int(obj7, &val8);
24390 if (!SWIG_IsOK(ecode8)) {
24391 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24392 }
24393 arg8 = static_cast< int >(val8);
24394 }
24395 {
24396 PyThreadState* __tstate = wxPyBeginAllowThreads();
24397 {
24398 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24399 result = (wxDateTime *) &_result_ref;
24400 }
24401 wxPyEndAllowThreads(__tstate);
24402 if (PyErr_Occurred()) SWIG_fail;
24403 }
24404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24405 return resultobj;
24406 fail:
24407 return NULL;
24408 }
24409
24410
24411 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24412 PyObject *resultobj = 0;
24413 wxDateTime *arg1 = (wxDateTime *) 0 ;
24414 wxDateTime *result = 0 ;
24415 void *argp1 = 0 ;
24416 int res1 = 0 ;
24417 PyObject *swig_obj[1] ;
24418
24419 if (!args) SWIG_fail;
24420 swig_obj[0] = args;
24421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24422 if (!SWIG_IsOK(res1)) {
24423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24424 }
24425 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24426 {
24427 PyThreadState* __tstate = wxPyBeginAllowThreads();
24428 {
24429 wxDateTime &_result_ref = (arg1)->ResetTime();
24430 result = (wxDateTime *) &_result_ref;
24431 }
24432 wxPyEndAllowThreads(__tstate);
24433 if (PyErr_Occurred()) SWIG_fail;
24434 }
24435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24436 return resultobj;
24437 fail:
24438 return NULL;
24439 }
24440
24441
24442 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24443 PyObject *resultobj = 0;
24444 wxDateTime *arg1 = (wxDateTime *) 0 ;
24445 int arg2 ;
24446 wxDateTime *result = 0 ;
24447 void *argp1 = 0 ;
24448 int res1 = 0 ;
24449 int val2 ;
24450 int ecode2 = 0 ;
24451 PyObject * obj0 = 0 ;
24452 PyObject * obj1 = 0 ;
24453 char * kwnames[] = {
24454 (char *) "self",(char *) "year", NULL
24455 };
24456
24457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24459 if (!SWIG_IsOK(res1)) {
24460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24461 }
24462 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24463 ecode2 = SWIG_AsVal_int(obj1, &val2);
24464 if (!SWIG_IsOK(ecode2)) {
24465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24466 }
24467 arg2 = static_cast< int >(val2);
24468 {
24469 PyThreadState* __tstate = wxPyBeginAllowThreads();
24470 {
24471 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24472 result = (wxDateTime *) &_result_ref;
24473 }
24474 wxPyEndAllowThreads(__tstate);
24475 if (PyErr_Occurred()) SWIG_fail;
24476 }
24477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24478 return resultobj;
24479 fail:
24480 return NULL;
24481 }
24482
24483
24484 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24485 PyObject *resultobj = 0;
24486 wxDateTime *arg1 = (wxDateTime *) 0 ;
24487 wxDateTime::Month arg2 ;
24488 wxDateTime *result = 0 ;
24489 void *argp1 = 0 ;
24490 int res1 = 0 ;
24491 int val2 ;
24492 int ecode2 = 0 ;
24493 PyObject * obj0 = 0 ;
24494 PyObject * obj1 = 0 ;
24495 char * kwnames[] = {
24496 (char *) "self",(char *) "month", NULL
24497 };
24498
24499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24501 if (!SWIG_IsOK(res1)) {
24502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24503 }
24504 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24505 ecode2 = SWIG_AsVal_int(obj1, &val2);
24506 if (!SWIG_IsOK(ecode2)) {
24507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24508 }
24509 arg2 = static_cast< wxDateTime::Month >(val2);
24510 {
24511 PyThreadState* __tstate = wxPyBeginAllowThreads();
24512 {
24513 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24514 result = (wxDateTime *) &_result_ref;
24515 }
24516 wxPyEndAllowThreads(__tstate);
24517 if (PyErr_Occurred()) SWIG_fail;
24518 }
24519 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24520 return resultobj;
24521 fail:
24522 return NULL;
24523 }
24524
24525
24526 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24527 PyObject *resultobj = 0;
24528 wxDateTime *arg1 = (wxDateTime *) 0 ;
24529 int arg2 ;
24530 wxDateTime *result = 0 ;
24531 void *argp1 = 0 ;
24532 int res1 = 0 ;
24533 int val2 ;
24534 int ecode2 = 0 ;
24535 PyObject * obj0 = 0 ;
24536 PyObject * obj1 = 0 ;
24537 char * kwnames[] = {
24538 (char *) "self",(char *) "day", NULL
24539 };
24540
24541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24543 if (!SWIG_IsOK(res1)) {
24544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24545 }
24546 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24547 ecode2 = SWIG_AsVal_int(obj1, &val2);
24548 if (!SWIG_IsOK(ecode2)) {
24549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24550 }
24551 arg2 = static_cast< int >(val2);
24552 {
24553 PyThreadState* __tstate = wxPyBeginAllowThreads();
24554 {
24555 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24556 result = (wxDateTime *) &_result_ref;
24557 }
24558 wxPyEndAllowThreads(__tstate);
24559 if (PyErr_Occurred()) SWIG_fail;
24560 }
24561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24562 return resultobj;
24563 fail:
24564 return NULL;
24565 }
24566
24567
24568 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24569 PyObject *resultobj = 0;
24570 wxDateTime *arg1 = (wxDateTime *) 0 ;
24571 int arg2 ;
24572 wxDateTime *result = 0 ;
24573 void *argp1 = 0 ;
24574 int res1 = 0 ;
24575 int val2 ;
24576 int ecode2 = 0 ;
24577 PyObject * obj0 = 0 ;
24578 PyObject * obj1 = 0 ;
24579 char * kwnames[] = {
24580 (char *) "self",(char *) "hour", NULL
24581 };
24582
24583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24585 if (!SWIG_IsOK(res1)) {
24586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24587 }
24588 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24589 ecode2 = SWIG_AsVal_int(obj1, &val2);
24590 if (!SWIG_IsOK(ecode2)) {
24591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24592 }
24593 arg2 = static_cast< int >(val2);
24594 {
24595 PyThreadState* __tstate = wxPyBeginAllowThreads();
24596 {
24597 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24598 result = (wxDateTime *) &_result_ref;
24599 }
24600 wxPyEndAllowThreads(__tstate);
24601 if (PyErr_Occurred()) SWIG_fail;
24602 }
24603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24604 return resultobj;
24605 fail:
24606 return NULL;
24607 }
24608
24609
24610 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24611 PyObject *resultobj = 0;
24612 wxDateTime *arg1 = (wxDateTime *) 0 ;
24613 int arg2 ;
24614 wxDateTime *result = 0 ;
24615 void *argp1 = 0 ;
24616 int res1 = 0 ;
24617 int val2 ;
24618 int ecode2 = 0 ;
24619 PyObject * obj0 = 0 ;
24620 PyObject * obj1 = 0 ;
24621 char * kwnames[] = {
24622 (char *) "self",(char *) "minute", NULL
24623 };
24624
24625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24627 if (!SWIG_IsOK(res1)) {
24628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24629 }
24630 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24631 ecode2 = SWIG_AsVal_int(obj1, &val2);
24632 if (!SWIG_IsOK(ecode2)) {
24633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24634 }
24635 arg2 = static_cast< int >(val2);
24636 {
24637 PyThreadState* __tstate = wxPyBeginAllowThreads();
24638 {
24639 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24640 result = (wxDateTime *) &_result_ref;
24641 }
24642 wxPyEndAllowThreads(__tstate);
24643 if (PyErr_Occurred()) SWIG_fail;
24644 }
24645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24646 return resultobj;
24647 fail:
24648 return NULL;
24649 }
24650
24651
24652 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24653 PyObject *resultobj = 0;
24654 wxDateTime *arg1 = (wxDateTime *) 0 ;
24655 int arg2 ;
24656 wxDateTime *result = 0 ;
24657 void *argp1 = 0 ;
24658 int res1 = 0 ;
24659 int val2 ;
24660 int ecode2 = 0 ;
24661 PyObject * obj0 = 0 ;
24662 PyObject * obj1 = 0 ;
24663 char * kwnames[] = {
24664 (char *) "self",(char *) "second", NULL
24665 };
24666
24667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24669 if (!SWIG_IsOK(res1)) {
24670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24671 }
24672 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24673 ecode2 = SWIG_AsVal_int(obj1, &val2);
24674 if (!SWIG_IsOK(ecode2)) {
24675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24676 }
24677 arg2 = static_cast< int >(val2);
24678 {
24679 PyThreadState* __tstate = wxPyBeginAllowThreads();
24680 {
24681 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24682 result = (wxDateTime *) &_result_ref;
24683 }
24684 wxPyEndAllowThreads(__tstate);
24685 if (PyErr_Occurred()) SWIG_fail;
24686 }
24687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24688 return resultobj;
24689 fail:
24690 return NULL;
24691 }
24692
24693
24694 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24695 PyObject *resultobj = 0;
24696 wxDateTime *arg1 = (wxDateTime *) 0 ;
24697 int arg2 ;
24698 wxDateTime *result = 0 ;
24699 void *argp1 = 0 ;
24700 int res1 = 0 ;
24701 int val2 ;
24702 int ecode2 = 0 ;
24703 PyObject * obj0 = 0 ;
24704 PyObject * obj1 = 0 ;
24705 char * kwnames[] = {
24706 (char *) "self",(char *) "millisecond", NULL
24707 };
24708
24709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24711 if (!SWIG_IsOK(res1)) {
24712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24713 }
24714 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24715 ecode2 = SWIG_AsVal_int(obj1, &val2);
24716 if (!SWIG_IsOK(ecode2)) {
24717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24718 }
24719 arg2 = static_cast< int >(val2);
24720 {
24721 PyThreadState* __tstate = wxPyBeginAllowThreads();
24722 {
24723 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24724 result = (wxDateTime *) &_result_ref;
24725 }
24726 wxPyEndAllowThreads(__tstate);
24727 if (PyErr_Occurred()) SWIG_fail;
24728 }
24729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24730 return resultobj;
24731 fail:
24732 return NULL;
24733 }
24734
24735
24736 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24737 PyObject *resultobj = 0;
24738 wxDateTime *arg1 = (wxDateTime *) 0 ;
24739 wxDateTime::WeekDay arg2 ;
24740 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24741 wxDateTime *result = 0 ;
24742 void *argp1 = 0 ;
24743 int res1 = 0 ;
24744 int val2 ;
24745 int ecode2 = 0 ;
24746 int val3 ;
24747 int ecode3 = 0 ;
24748 PyObject * obj0 = 0 ;
24749 PyObject * obj1 = 0 ;
24750 PyObject * obj2 = 0 ;
24751 char * kwnames[] = {
24752 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24753 };
24754
24755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24757 if (!SWIG_IsOK(res1)) {
24758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24759 }
24760 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24761 ecode2 = SWIG_AsVal_int(obj1, &val2);
24762 if (!SWIG_IsOK(ecode2)) {
24763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24764 }
24765 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24766 if (obj2) {
24767 ecode3 = SWIG_AsVal_int(obj2, &val3);
24768 if (!SWIG_IsOK(ecode3)) {
24769 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24770 }
24771 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24772 }
24773 {
24774 PyThreadState* __tstate = wxPyBeginAllowThreads();
24775 {
24776 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24777 result = (wxDateTime *) &_result_ref;
24778 }
24779 wxPyEndAllowThreads(__tstate);
24780 if (PyErr_Occurred()) SWIG_fail;
24781 }
24782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24783 return resultobj;
24784 fail:
24785 return NULL;
24786 }
24787
24788
24789 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24790 PyObject *resultobj = 0;
24791 wxDateTime *arg1 = (wxDateTime *) 0 ;
24792 wxDateTime::WeekDay arg2 ;
24793 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24794 wxDateTime result;
24795 void *argp1 = 0 ;
24796 int res1 = 0 ;
24797 int val2 ;
24798 int ecode2 = 0 ;
24799 int val3 ;
24800 int ecode3 = 0 ;
24801 PyObject * obj0 = 0 ;
24802 PyObject * obj1 = 0 ;
24803 PyObject * obj2 = 0 ;
24804 char * kwnames[] = {
24805 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24806 };
24807
24808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24810 if (!SWIG_IsOK(res1)) {
24811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24812 }
24813 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24814 ecode2 = SWIG_AsVal_int(obj1, &val2);
24815 if (!SWIG_IsOK(ecode2)) {
24816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24817 }
24818 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24819 if (obj2) {
24820 ecode3 = SWIG_AsVal_int(obj2, &val3);
24821 if (!SWIG_IsOK(ecode3)) {
24822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24823 }
24824 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24825 }
24826 {
24827 PyThreadState* __tstate = wxPyBeginAllowThreads();
24828 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24829 wxPyEndAllowThreads(__tstate);
24830 if (PyErr_Occurred()) SWIG_fail;
24831 }
24832 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24833 return resultobj;
24834 fail:
24835 return NULL;
24836 }
24837
24838
24839 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24840 PyObject *resultobj = 0;
24841 wxDateTime *arg1 = (wxDateTime *) 0 ;
24842 wxDateTime::WeekDay arg2 ;
24843 wxDateTime *result = 0 ;
24844 void *argp1 = 0 ;
24845 int res1 = 0 ;
24846 int val2 ;
24847 int ecode2 = 0 ;
24848 PyObject * obj0 = 0 ;
24849 PyObject * obj1 = 0 ;
24850 char * kwnames[] = {
24851 (char *) "self",(char *) "weekday", NULL
24852 };
24853
24854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24856 if (!SWIG_IsOK(res1)) {
24857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24858 }
24859 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24860 ecode2 = SWIG_AsVal_int(obj1, &val2);
24861 if (!SWIG_IsOK(ecode2)) {
24862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24863 }
24864 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24865 {
24866 PyThreadState* __tstate = wxPyBeginAllowThreads();
24867 {
24868 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24869 result = (wxDateTime *) &_result_ref;
24870 }
24871 wxPyEndAllowThreads(__tstate);
24872 if (PyErr_Occurred()) SWIG_fail;
24873 }
24874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24875 return resultobj;
24876 fail:
24877 return NULL;
24878 }
24879
24880
24881 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24882 PyObject *resultobj = 0;
24883 wxDateTime *arg1 = (wxDateTime *) 0 ;
24884 wxDateTime::WeekDay arg2 ;
24885 wxDateTime result;
24886 void *argp1 = 0 ;
24887 int res1 = 0 ;
24888 int val2 ;
24889 int ecode2 = 0 ;
24890 PyObject * obj0 = 0 ;
24891 PyObject * obj1 = 0 ;
24892 char * kwnames[] = {
24893 (char *) "self",(char *) "weekday", NULL
24894 };
24895
24896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24898 if (!SWIG_IsOK(res1)) {
24899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24900 }
24901 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24902 ecode2 = SWIG_AsVal_int(obj1, &val2);
24903 if (!SWIG_IsOK(ecode2)) {
24904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24905 }
24906 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24907 {
24908 PyThreadState* __tstate = wxPyBeginAllowThreads();
24909 result = (arg1)->GetNextWeekDay(arg2);
24910 wxPyEndAllowThreads(__tstate);
24911 if (PyErr_Occurred()) SWIG_fail;
24912 }
24913 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24914 return resultobj;
24915 fail:
24916 return NULL;
24917 }
24918
24919
24920 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24921 PyObject *resultobj = 0;
24922 wxDateTime *arg1 = (wxDateTime *) 0 ;
24923 wxDateTime::WeekDay arg2 ;
24924 wxDateTime *result = 0 ;
24925 void *argp1 = 0 ;
24926 int res1 = 0 ;
24927 int val2 ;
24928 int ecode2 = 0 ;
24929 PyObject * obj0 = 0 ;
24930 PyObject * obj1 = 0 ;
24931 char * kwnames[] = {
24932 (char *) "self",(char *) "weekday", NULL
24933 };
24934
24935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24937 if (!SWIG_IsOK(res1)) {
24938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24939 }
24940 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24941 ecode2 = SWIG_AsVal_int(obj1, &val2);
24942 if (!SWIG_IsOK(ecode2)) {
24943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24944 }
24945 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24946 {
24947 PyThreadState* __tstate = wxPyBeginAllowThreads();
24948 {
24949 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24950 result = (wxDateTime *) &_result_ref;
24951 }
24952 wxPyEndAllowThreads(__tstate);
24953 if (PyErr_Occurred()) SWIG_fail;
24954 }
24955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24956 return resultobj;
24957 fail:
24958 return NULL;
24959 }
24960
24961
24962 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24963 PyObject *resultobj = 0;
24964 wxDateTime *arg1 = (wxDateTime *) 0 ;
24965 wxDateTime::WeekDay arg2 ;
24966 wxDateTime result;
24967 void *argp1 = 0 ;
24968 int res1 = 0 ;
24969 int val2 ;
24970 int ecode2 = 0 ;
24971 PyObject * obj0 = 0 ;
24972 PyObject * obj1 = 0 ;
24973 char * kwnames[] = {
24974 (char *) "self",(char *) "weekday", NULL
24975 };
24976
24977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24979 if (!SWIG_IsOK(res1)) {
24980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24981 }
24982 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24983 ecode2 = SWIG_AsVal_int(obj1, &val2);
24984 if (!SWIG_IsOK(ecode2)) {
24985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24986 }
24987 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24988 {
24989 PyThreadState* __tstate = wxPyBeginAllowThreads();
24990 result = (arg1)->GetPrevWeekDay(arg2);
24991 wxPyEndAllowThreads(__tstate);
24992 if (PyErr_Occurred()) SWIG_fail;
24993 }
24994 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24995 return resultobj;
24996 fail:
24997 return NULL;
24998 }
24999
25000
25001 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25002 PyObject *resultobj = 0;
25003 wxDateTime *arg1 = (wxDateTime *) 0 ;
25004 wxDateTime::WeekDay arg2 ;
25005 int arg3 = (int) 1 ;
25006 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25007 int arg5 = (int) wxDateTime::Inv_Year ;
25008 bool 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 int val5 ;
25018 int ecode5 = 0 ;
25019 PyObject * obj0 = 0 ;
25020 PyObject * obj1 = 0 ;
25021 PyObject * obj2 = 0 ;
25022 PyObject * obj3 = 0 ;
25023 PyObject * obj4 = 0 ;
25024 char * kwnames[] = {
25025 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
25026 };
25027
25028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25030 if (!SWIG_IsOK(res1)) {
25031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25032 }
25033 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25034 ecode2 = SWIG_AsVal_int(obj1, &val2);
25035 if (!SWIG_IsOK(ecode2)) {
25036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25037 }
25038 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25039 if (obj2) {
25040 ecode3 = SWIG_AsVal_int(obj2, &val3);
25041 if (!SWIG_IsOK(ecode3)) {
25042 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
25043 }
25044 arg3 = static_cast< int >(val3);
25045 }
25046 if (obj3) {
25047 ecode4 = SWIG_AsVal_int(obj3, &val4);
25048 if (!SWIG_IsOK(ecode4)) {
25049 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
25050 }
25051 arg4 = static_cast< wxDateTime::Month >(val4);
25052 }
25053 if (obj4) {
25054 ecode5 = SWIG_AsVal_int(obj4, &val5);
25055 if (!SWIG_IsOK(ecode5)) {
25056 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
25057 }
25058 arg5 = static_cast< int >(val5);
25059 }
25060 {
25061 PyThreadState* __tstate = wxPyBeginAllowThreads();
25062 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
25063 wxPyEndAllowThreads(__tstate);
25064 if (PyErr_Occurred()) SWIG_fail;
25065 }
25066 {
25067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25068 }
25069 return resultobj;
25070 fail:
25071 return NULL;
25072 }
25073
25074
25075 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25076 PyObject *resultobj = 0;
25077 wxDateTime *arg1 = (wxDateTime *) 0 ;
25078 wxDateTime::WeekDay arg2 ;
25079 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25080 int arg4 = (int) wxDateTime::Inv_Year ;
25081 bool result;
25082 void *argp1 = 0 ;
25083 int res1 = 0 ;
25084 int val2 ;
25085 int ecode2 = 0 ;
25086 int val3 ;
25087 int ecode3 = 0 ;
25088 int val4 ;
25089 int ecode4 = 0 ;
25090 PyObject * obj0 = 0 ;
25091 PyObject * obj1 = 0 ;
25092 PyObject * obj2 = 0 ;
25093 PyObject * obj3 = 0 ;
25094 char * kwnames[] = {
25095 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25096 };
25097
25098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25100 if (!SWIG_IsOK(res1)) {
25101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25102 }
25103 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25104 ecode2 = SWIG_AsVal_int(obj1, &val2);
25105 if (!SWIG_IsOK(ecode2)) {
25106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25107 }
25108 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25109 if (obj2) {
25110 ecode3 = SWIG_AsVal_int(obj2, &val3);
25111 if (!SWIG_IsOK(ecode3)) {
25112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25113 }
25114 arg3 = static_cast< wxDateTime::Month >(val3);
25115 }
25116 if (obj3) {
25117 ecode4 = SWIG_AsVal_int(obj3, &val4);
25118 if (!SWIG_IsOK(ecode4)) {
25119 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25120 }
25121 arg4 = static_cast< int >(val4);
25122 }
25123 {
25124 PyThreadState* __tstate = wxPyBeginAllowThreads();
25125 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25126 wxPyEndAllowThreads(__tstate);
25127 if (PyErr_Occurred()) SWIG_fail;
25128 }
25129 {
25130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25131 }
25132 return resultobj;
25133 fail:
25134 return NULL;
25135 }
25136
25137
25138 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25139 PyObject *resultobj = 0;
25140 wxDateTime *arg1 = (wxDateTime *) 0 ;
25141 wxDateTime::WeekDay arg2 ;
25142 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25143 int arg4 = (int) wxDateTime::Inv_Year ;
25144 wxDateTime result;
25145 void *argp1 = 0 ;
25146 int res1 = 0 ;
25147 int val2 ;
25148 int ecode2 = 0 ;
25149 int val3 ;
25150 int ecode3 = 0 ;
25151 int val4 ;
25152 int ecode4 = 0 ;
25153 PyObject * obj0 = 0 ;
25154 PyObject * obj1 = 0 ;
25155 PyObject * obj2 = 0 ;
25156 PyObject * obj3 = 0 ;
25157 char * kwnames[] = {
25158 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25159 };
25160
25161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25163 if (!SWIG_IsOK(res1)) {
25164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25165 }
25166 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25167 ecode2 = SWIG_AsVal_int(obj1, &val2);
25168 if (!SWIG_IsOK(ecode2)) {
25169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25170 }
25171 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25172 if (obj2) {
25173 ecode3 = SWIG_AsVal_int(obj2, &val3);
25174 if (!SWIG_IsOK(ecode3)) {
25175 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25176 }
25177 arg3 = static_cast< wxDateTime::Month >(val3);
25178 }
25179 if (obj3) {
25180 ecode4 = SWIG_AsVal_int(obj3, &val4);
25181 if (!SWIG_IsOK(ecode4)) {
25182 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25183 }
25184 arg4 = static_cast< int >(val4);
25185 }
25186 {
25187 PyThreadState* __tstate = wxPyBeginAllowThreads();
25188 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25189 wxPyEndAllowThreads(__tstate);
25190 if (PyErr_Occurred()) SWIG_fail;
25191 }
25192 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25193 return resultobj;
25194 fail:
25195 return NULL;
25196 }
25197
25198
25199 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25200 PyObject *resultobj = 0;
25201 wxDateTime *arg1 = (wxDateTime *) 0 ;
25202 int arg2 ;
25203 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25204 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25205 bool result;
25206 void *argp1 = 0 ;
25207 int res1 = 0 ;
25208 int val2 ;
25209 int ecode2 = 0 ;
25210 int val3 ;
25211 int ecode3 = 0 ;
25212 int val4 ;
25213 int ecode4 = 0 ;
25214 PyObject * obj0 = 0 ;
25215 PyObject * obj1 = 0 ;
25216 PyObject * obj2 = 0 ;
25217 PyObject * obj3 = 0 ;
25218 char * kwnames[] = {
25219 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25220 };
25221
25222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25224 if (!SWIG_IsOK(res1)) {
25225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25226 }
25227 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25228 ecode2 = SWIG_AsVal_int(obj1, &val2);
25229 if (!SWIG_IsOK(ecode2)) {
25230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25231 }
25232 arg2 = static_cast< int >(val2);
25233 if (obj2) {
25234 ecode3 = SWIG_AsVal_int(obj2, &val3);
25235 if (!SWIG_IsOK(ecode3)) {
25236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25237 }
25238 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25239 }
25240 if (obj3) {
25241 ecode4 = SWIG_AsVal_int(obj3, &val4);
25242 if (!SWIG_IsOK(ecode4)) {
25243 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25244 }
25245 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25246 }
25247 {
25248 PyThreadState* __tstate = wxPyBeginAllowThreads();
25249 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25250 wxPyEndAllowThreads(__tstate);
25251 if (PyErr_Occurred()) SWIG_fail;
25252 }
25253 {
25254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25255 }
25256 return resultobj;
25257 fail:
25258 return NULL;
25259 }
25260
25261
25262 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25263 PyObject *resultobj = 0;
25264 wxDateTime *arg1 = (wxDateTime *) 0 ;
25265 int arg2 ;
25266 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25267 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25268 wxDateTime result;
25269 void *argp1 = 0 ;
25270 int res1 = 0 ;
25271 int val2 ;
25272 int ecode2 = 0 ;
25273 int val3 ;
25274 int ecode3 = 0 ;
25275 int val4 ;
25276 int ecode4 = 0 ;
25277 PyObject * obj0 = 0 ;
25278 PyObject * obj1 = 0 ;
25279 PyObject * obj2 = 0 ;
25280 PyObject * obj3 = 0 ;
25281 char * kwnames[] = {
25282 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25283 };
25284
25285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25287 if (!SWIG_IsOK(res1)) {
25288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25289 }
25290 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25291 ecode2 = SWIG_AsVal_int(obj1, &val2);
25292 if (!SWIG_IsOK(ecode2)) {
25293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25294 }
25295 arg2 = static_cast< int >(val2);
25296 if (obj2) {
25297 ecode3 = SWIG_AsVal_int(obj2, &val3);
25298 if (!SWIG_IsOK(ecode3)) {
25299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25300 }
25301 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25302 }
25303 if (obj3) {
25304 ecode4 = SWIG_AsVal_int(obj3, &val4);
25305 if (!SWIG_IsOK(ecode4)) {
25306 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25307 }
25308 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25309 }
25310 {
25311 PyThreadState* __tstate = wxPyBeginAllowThreads();
25312 result = (arg1)->GetWeek(arg2,arg3,arg4);
25313 wxPyEndAllowThreads(__tstate);
25314 if (PyErr_Occurred()) SWIG_fail;
25315 }
25316 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25317 return resultobj;
25318 fail:
25319 return NULL;
25320 }
25321
25322
25323 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25324 PyObject *resultobj = 0;
25325 int arg1 ;
25326 int arg2 ;
25327 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25328 wxDateTime result;
25329 int val1 ;
25330 int ecode1 = 0 ;
25331 int val2 ;
25332 int ecode2 = 0 ;
25333 int val3 ;
25334 int ecode3 = 0 ;
25335 PyObject * obj0 = 0 ;
25336 PyObject * obj1 = 0 ;
25337 PyObject * obj2 = 0 ;
25338 char * kwnames[] = {
25339 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25340 };
25341
25342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25343 ecode1 = SWIG_AsVal_int(obj0, &val1);
25344 if (!SWIG_IsOK(ecode1)) {
25345 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25346 }
25347 arg1 = static_cast< int >(val1);
25348 ecode2 = SWIG_AsVal_int(obj1, &val2);
25349 if (!SWIG_IsOK(ecode2)) {
25350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25351 }
25352 arg2 = static_cast< int >(val2);
25353 if (obj2) {
25354 ecode3 = SWIG_AsVal_int(obj2, &val3);
25355 if (!SWIG_IsOK(ecode3)) {
25356 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25357 }
25358 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25359 }
25360 {
25361 PyThreadState* __tstate = wxPyBeginAllowThreads();
25362 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25363 wxPyEndAllowThreads(__tstate);
25364 if (PyErr_Occurred()) SWIG_fail;
25365 }
25366 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25367 return resultobj;
25368 fail:
25369 return NULL;
25370 }
25371
25372
25373 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25374 PyObject *resultobj = 0;
25375 wxDateTime *arg1 = (wxDateTime *) 0 ;
25376 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25377 int arg3 = (int) wxDateTime::Inv_Year ;
25378 wxDateTime *result = 0 ;
25379 void *argp1 = 0 ;
25380 int res1 = 0 ;
25381 int val2 ;
25382 int ecode2 = 0 ;
25383 int val3 ;
25384 int ecode3 = 0 ;
25385 PyObject * obj0 = 0 ;
25386 PyObject * obj1 = 0 ;
25387 PyObject * obj2 = 0 ;
25388 char * kwnames[] = {
25389 (char *) "self",(char *) "month",(char *) "year", NULL
25390 };
25391
25392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25394 if (!SWIG_IsOK(res1)) {
25395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25396 }
25397 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25398 if (obj1) {
25399 ecode2 = SWIG_AsVal_int(obj1, &val2);
25400 if (!SWIG_IsOK(ecode2)) {
25401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25402 }
25403 arg2 = static_cast< wxDateTime::Month >(val2);
25404 }
25405 if (obj2) {
25406 ecode3 = SWIG_AsVal_int(obj2, &val3);
25407 if (!SWIG_IsOK(ecode3)) {
25408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25409 }
25410 arg3 = static_cast< int >(val3);
25411 }
25412 {
25413 PyThreadState* __tstate = wxPyBeginAllowThreads();
25414 {
25415 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25416 result = (wxDateTime *) &_result_ref;
25417 }
25418 wxPyEndAllowThreads(__tstate);
25419 if (PyErr_Occurred()) SWIG_fail;
25420 }
25421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25422 return resultobj;
25423 fail:
25424 return NULL;
25425 }
25426
25427
25428 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25429 PyObject *resultobj = 0;
25430 wxDateTime *arg1 = (wxDateTime *) 0 ;
25431 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25432 int arg3 = (int) wxDateTime::Inv_Year ;
25433 wxDateTime result;
25434 void *argp1 = 0 ;
25435 int res1 = 0 ;
25436 int val2 ;
25437 int ecode2 = 0 ;
25438 int val3 ;
25439 int ecode3 = 0 ;
25440 PyObject * obj0 = 0 ;
25441 PyObject * obj1 = 0 ;
25442 PyObject * obj2 = 0 ;
25443 char * kwnames[] = {
25444 (char *) "self",(char *) "month",(char *) "year", NULL
25445 };
25446
25447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25449 if (!SWIG_IsOK(res1)) {
25450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25451 }
25452 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25453 if (obj1) {
25454 ecode2 = SWIG_AsVal_int(obj1, &val2);
25455 if (!SWIG_IsOK(ecode2)) {
25456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25457 }
25458 arg2 = static_cast< wxDateTime::Month >(val2);
25459 }
25460 if (obj2) {
25461 ecode3 = SWIG_AsVal_int(obj2, &val3);
25462 if (!SWIG_IsOK(ecode3)) {
25463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25464 }
25465 arg3 = static_cast< int >(val3);
25466 }
25467 {
25468 PyThreadState* __tstate = wxPyBeginAllowThreads();
25469 result = (arg1)->GetLastMonthDay(arg2,arg3);
25470 wxPyEndAllowThreads(__tstate);
25471 if (PyErr_Occurred()) SWIG_fail;
25472 }
25473 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25474 return resultobj;
25475 fail:
25476 return NULL;
25477 }
25478
25479
25480 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25481 PyObject *resultobj = 0;
25482 wxDateTime *arg1 = (wxDateTime *) 0 ;
25483 int arg2 ;
25484 wxDateTime *result = 0 ;
25485 void *argp1 = 0 ;
25486 int res1 = 0 ;
25487 int val2 ;
25488 int ecode2 = 0 ;
25489 PyObject * obj0 = 0 ;
25490 PyObject * obj1 = 0 ;
25491 char * kwnames[] = {
25492 (char *) "self",(char *) "yday", NULL
25493 };
25494
25495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25497 if (!SWIG_IsOK(res1)) {
25498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25499 }
25500 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25501 ecode2 = SWIG_AsVal_int(obj1, &val2);
25502 if (!SWIG_IsOK(ecode2)) {
25503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25504 }
25505 arg2 = static_cast< int >(val2);
25506 {
25507 PyThreadState* __tstate = wxPyBeginAllowThreads();
25508 {
25509 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25510 result = (wxDateTime *) &_result_ref;
25511 }
25512 wxPyEndAllowThreads(__tstate);
25513 if (PyErr_Occurred()) SWIG_fail;
25514 }
25515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25516 return resultobj;
25517 fail:
25518 return NULL;
25519 }
25520
25521
25522 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25523 PyObject *resultobj = 0;
25524 wxDateTime *arg1 = (wxDateTime *) 0 ;
25525 int arg2 ;
25526 wxDateTime result;
25527 void *argp1 = 0 ;
25528 int res1 = 0 ;
25529 int val2 ;
25530 int ecode2 = 0 ;
25531 PyObject * obj0 = 0 ;
25532 PyObject * obj1 = 0 ;
25533 char * kwnames[] = {
25534 (char *) "self",(char *) "yday", NULL
25535 };
25536
25537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25539 if (!SWIG_IsOK(res1)) {
25540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25541 }
25542 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25543 ecode2 = SWIG_AsVal_int(obj1, &val2);
25544 if (!SWIG_IsOK(ecode2)) {
25545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25546 }
25547 arg2 = static_cast< int >(val2);
25548 {
25549 PyThreadState* __tstate = wxPyBeginAllowThreads();
25550 result = (arg1)->GetYearDay(arg2);
25551 wxPyEndAllowThreads(__tstate);
25552 if (PyErr_Occurred()) SWIG_fail;
25553 }
25554 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25555 return resultobj;
25556 fail:
25557 return NULL;
25558 }
25559
25560
25561 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25562 PyObject *resultobj = 0;
25563 wxDateTime *arg1 = (wxDateTime *) 0 ;
25564 double result;
25565 void *argp1 = 0 ;
25566 int res1 = 0 ;
25567 PyObject *swig_obj[1] ;
25568
25569 if (!args) SWIG_fail;
25570 swig_obj[0] = args;
25571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25572 if (!SWIG_IsOK(res1)) {
25573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25574 }
25575 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25576 {
25577 PyThreadState* __tstate = wxPyBeginAllowThreads();
25578 result = (double)(arg1)->GetJulianDayNumber();
25579 wxPyEndAllowThreads(__tstate);
25580 if (PyErr_Occurred()) SWIG_fail;
25581 }
25582 resultobj = SWIG_From_double(static_cast< double >(result));
25583 return resultobj;
25584 fail:
25585 return NULL;
25586 }
25587
25588
25589 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25590 PyObject *resultobj = 0;
25591 wxDateTime *arg1 = (wxDateTime *) 0 ;
25592 double result;
25593 void *argp1 = 0 ;
25594 int res1 = 0 ;
25595 PyObject *swig_obj[1] ;
25596
25597 if (!args) SWIG_fail;
25598 swig_obj[0] = args;
25599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25600 if (!SWIG_IsOK(res1)) {
25601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25602 }
25603 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25604 {
25605 PyThreadState* __tstate = wxPyBeginAllowThreads();
25606 result = (double)(arg1)->GetJDN();
25607 wxPyEndAllowThreads(__tstate);
25608 if (PyErr_Occurred()) SWIG_fail;
25609 }
25610 resultobj = SWIG_From_double(static_cast< double >(result));
25611 return resultobj;
25612 fail:
25613 return NULL;
25614 }
25615
25616
25617 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25618 PyObject *resultobj = 0;
25619 wxDateTime *arg1 = (wxDateTime *) 0 ;
25620 double result;
25621 void *argp1 = 0 ;
25622 int res1 = 0 ;
25623 PyObject *swig_obj[1] ;
25624
25625 if (!args) SWIG_fail;
25626 swig_obj[0] = args;
25627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25628 if (!SWIG_IsOK(res1)) {
25629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25630 }
25631 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25632 {
25633 PyThreadState* __tstate = wxPyBeginAllowThreads();
25634 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25635 wxPyEndAllowThreads(__tstate);
25636 if (PyErr_Occurred()) SWIG_fail;
25637 }
25638 resultobj = SWIG_From_double(static_cast< double >(result));
25639 return resultobj;
25640 fail:
25641 return NULL;
25642 }
25643
25644
25645 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25646 PyObject *resultobj = 0;
25647 wxDateTime *arg1 = (wxDateTime *) 0 ;
25648 double result;
25649 void *argp1 = 0 ;
25650 int res1 = 0 ;
25651 PyObject *swig_obj[1] ;
25652
25653 if (!args) SWIG_fail;
25654 swig_obj[0] = args;
25655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25656 if (!SWIG_IsOK(res1)) {
25657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25658 }
25659 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25660 {
25661 PyThreadState* __tstate = wxPyBeginAllowThreads();
25662 result = (double)(arg1)->GetMJD();
25663 wxPyEndAllowThreads(__tstate);
25664 if (PyErr_Occurred()) SWIG_fail;
25665 }
25666 resultobj = SWIG_From_double(static_cast< double >(result));
25667 return resultobj;
25668 fail:
25669 return NULL;
25670 }
25671
25672
25673 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25674 PyObject *resultobj = 0;
25675 wxDateTime *arg1 = (wxDateTime *) 0 ;
25676 double result;
25677 void *argp1 = 0 ;
25678 int res1 = 0 ;
25679 PyObject *swig_obj[1] ;
25680
25681 if (!args) SWIG_fail;
25682 swig_obj[0] = args;
25683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25684 if (!SWIG_IsOK(res1)) {
25685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25686 }
25687 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25688 {
25689 PyThreadState* __tstate = wxPyBeginAllowThreads();
25690 result = (double)(arg1)->GetRataDie();
25691 wxPyEndAllowThreads(__tstate);
25692 if (PyErr_Occurred()) SWIG_fail;
25693 }
25694 resultobj = SWIG_From_double(static_cast< double >(result));
25695 return resultobj;
25696 fail:
25697 return NULL;
25698 }
25699
25700
25701 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25702 PyObject *resultobj = 0;
25703 wxDateTime *arg1 = (wxDateTime *) 0 ;
25704 wxDateTime::TimeZone *arg2 = 0 ;
25705 bool arg3 = (bool) false ;
25706 wxDateTime result;
25707 void *argp1 = 0 ;
25708 int res1 = 0 ;
25709 bool temp2 = false ;
25710 bool val3 ;
25711 int ecode3 = 0 ;
25712 PyObject * obj0 = 0 ;
25713 PyObject * obj1 = 0 ;
25714 PyObject * obj2 = 0 ;
25715 char * kwnames[] = {
25716 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25717 };
25718
25719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) 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_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25723 }
25724 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25725 {
25726 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25727 temp2 = true;
25728 }
25729 if (obj2) {
25730 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25731 if (!SWIG_IsOK(ecode3)) {
25732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25733 }
25734 arg3 = static_cast< bool >(val3);
25735 }
25736 {
25737 PyThreadState* __tstate = wxPyBeginAllowThreads();
25738 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25739 wxPyEndAllowThreads(__tstate);
25740 if (PyErr_Occurred()) SWIG_fail;
25741 }
25742 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25743 {
25744 if (temp2) delete arg2;
25745 }
25746 return resultobj;
25747 fail:
25748 {
25749 if (temp2) delete arg2;
25750 }
25751 return NULL;
25752 }
25753
25754
25755 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25756 PyObject *resultobj = 0;
25757 wxDateTime *arg1 = (wxDateTime *) 0 ;
25758 wxDateTime::TimeZone *arg2 = 0 ;
25759 bool arg3 = (bool) false ;
25760 wxDateTime *result = 0 ;
25761 void *argp1 = 0 ;
25762 int res1 = 0 ;
25763 bool temp2 = false ;
25764 bool val3 ;
25765 int ecode3 = 0 ;
25766 PyObject * obj0 = 0 ;
25767 PyObject * obj1 = 0 ;
25768 PyObject * obj2 = 0 ;
25769 char * kwnames[] = {
25770 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25771 };
25772
25773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25775 if (!SWIG_IsOK(res1)) {
25776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25777 }
25778 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25779 {
25780 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25781 temp2 = true;
25782 }
25783 if (obj2) {
25784 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25785 if (!SWIG_IsOK(ecode3)) {
25786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25787 }
25788 arg3 = static_cast< bool >(val3);
25789 }
25790 {
25791 PyThreadState* __tstate = wxPyBeginAllowThreads();
25792 {
25793 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25794 result = (wxDateTime *) &_result_ref;
25795 }
25796 wxPyEndAllowThreads(__tstate);
25797 if (PyErr_Occurred()) SWIG_fail;
25798 }
25799 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25800 {
25801 if (temp2) delete arg2;
25802 }
25803 return resultobj;
25804 fail:
25805 {
25806 if (temp2) delete arg2;
25807 }
25808 return NULL;
25809 }
25810
25811
25812 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25813 PyObject *resultobj = 0;
25814 wxDateTime *arg1 = (wxDateTime *) 0 ;
25815 wxDateTime::TimeZone *arg2 = 0 ;
25816 bool arg3 = (bool) false ;
25817 wxDateTime result;
25818 void *argp1 = 0 ;
25819 int res1 = 0 ;
25820 bool temp2 = false ;
25821 bool val3 ;
25822 int ecode3 = 0 ;
25823 PyObject * obj0 = 0 ;
25824 PyObject * obj1 = 0 ;
25825 PyObject * obj2 = 0 ;
25826 char * kwnames[] = {
25827 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25828 };
25829
25830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25832 if (!SWIG_IsOK(res1)) {
25833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25834 }
25835 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25836 {
25837 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25838 temp2 = true;
25839 }
25840 if (obj2) {
25841 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25842 if (!SWIG_IsOK(ecode3)) {
25843 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25844 }
25845 arg3 = static_cast< bool >(val3);
25846 }
25847 {
25848 PyThreadState* __tstate = wxPyBeginAllowThreads();
25849 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25850 wxPyEndAllowThreads(__tstate);
25851 if (PyErr_Occurred()) SWIG_fail;
25852 }
25853 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25854 {
25855 if (temp2) delete arg2;
25856 }
25857 return resultobj;
25858 fail:
25859 {
25860 if (temp2) delete arg2;
25861 }
25862 return NULL;
25863 }
25864
25865
25866 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25867 PyObject *resultobj = 0;
25868 wxDateTime *arg1 = (wxDateTime *) 0 ;
25869 wxDateTime::TimeZone *arg2 = 0 ;
25870 bool arg3 = (bool) false ;
25871 wxDateTime *result = 0 ;
25872 void *argp1 = 0 ;
25873 int res1 = 0 ;
25874 bool temp2 = false ;
25875 bool val3 ;
25876 int ecode3 = 0 ;
25877 PyObject * obj0 = 0 ;
25878 PyObject * obj1 = 0 ;
25879 PyObject * obj2 = 0 ;
25880 char * kwnames[] = {
25881 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25882 };
25883
25884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25886 if (!SWIG_IsOK(res1)) {
25887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25888 }
25889 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25890 {
25891 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25892 temp2 = true;
25893 }
25894 if (obj2) {
25895 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25896 if (!SWIG_IsOK(ecode3)) {
25897 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25898 }
25899 arg3 = static_cast< bool >(val3);
25900 }
25901 {
25902 PyThreadState* __tstate = wxPyBeginAllowThreads();
25903 {
25904 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25905 result = (wxDateTime *) &_result_ref;
25906 }
25907 wxPyEndAllowThreads(__tstate);
25908 if (PyErr_Occurred()) SWIG_fail;
25909 }
25910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25911 {
25912 if (temp2) delete arg2;
25913 }
25914 return resultobj;
25915 fail:
25916 {
25917 if (temp2) delete arg2;
25918 }
25919 return NULL;
25920 }
25921
25922
25923 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25924 PyObject *resultobj = 0;
25925 wxDateTime *arg1 = (wxDateTime *) 0 ;
25926 bool arg2 = (bool) false ;
25927 wxDateTime result;
25928 void *argp1 = 0 ;
25929 int res1 = 0 ;
25930 bool val2 ;
25931 int ecode2 = 0 ;
25932 PyObject * obj0 = 0 ;
25933 PyObject * obj1 = 0 ;
25934 char * kwnames[] = {
25935 (char *) "self",(char *) "noDST", NULL
25936 };
25937
25938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25940 if (!SWIG_IsOK(res1)) {
25941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25942 }
25943 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25944 if (obj1) {
25945 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25946 if (!SWIG_IsOK(ecode2)) {
25947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25948 }
25949 arg2 = static_cast< bool >(val2);
25950 }
25951 {
25952 PyThreadState* __tstate = wxPyBeginAllowThreads();
25953 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25954 wxPyEndAllowThreads(__tstate);
25955 if (PyErr_Occurred()) SWIG_fail;
25956 }
25957 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25958 return resultobj;
25959 fail:
25960 return NULL;
25961 }
25962
25963
25964 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25965 PyObject *resultobj = 0;
25966 wxDateTime *arg1 = (wxDateTime *) 0 ;
25967 bool arg2 = (bool) false ;
25968 wxDateTime *result = 0 ;
25969 void *argp1 = 0 ;
25970 int res1 = 0 ;
25971 bool val2 ;
25972 int ecode2 = 0 ;
25973 PyObject * obj0 = 0 ;
25974 PyObject * obj1 = 0 ;
25975 char * kwnames[] = {
25976 (char *) "self",(char *) "noDST", NULL
25977 };
25978
25979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25981 if (!SWIG_IsOK(res1)) {
25982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25983 }
25984 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25985 if (obj1) {
25986 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25987 if (!SWIG_IsOK(ecode2)) {
25988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
25989 }
25990 arg2 = static_cast< bool >(val2);
25991 }
25992 {
25993 PyThreadState* __tstate = wxPyBeginAllowThreads();
25994 {
25995 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
25996 result = (wxDateTime *) &_result_ref;
25997 }
25998 wxPyEndAllowThreads(__tstate);
25999 if (PyErr_Occurred()) SWIG_fail;
26000 }
26001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26002 return resultobj;
26003 fail:
26004 return NULL;
26005 }
26006
26007
26008 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26009 PyObject *resultobj = 0;
26010 wxDateTime *arg1 = (wxDateTime *) 0 ;
26011 bool arg2 = (bool) false ;
26012 wxDateTime result;
26013 void *argp1 = 0 ;
26014 int res1 = 0 ;
26015 bool val2 ;
26016 int ecode2 = 0 ;
26017 PyObject * obj0 = 0 ;
26018 PyObject * obj1 = 0 ;
26019 char * kwnames[] = {
26020 (char *) "self",(char *) "noDST", NULL
26021 };
26022
26023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26025 if (!SWIG_IsOK(res1)) {
26026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26027 }
26028 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26029 if (obj1) {
26030 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26031 if (!SWIG_IsOK(ecode2)) {
26032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
26033 }
26034 arg2 = static_cast< bool >(val2);
26035 }
26036 {
26037 PyThreadState* __tstate = wxPyBeginAllowThreads();
26038 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
26039 wxPyEndAllowThreads(__tstate);
26040 if (PyErr_Occurred()) SWIG_fail;
26041 }
26042 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26043 return resultobj;
26044 fail:
26045 return NULL;
26046 }
26047
26048
26049 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26050 PyObject *resultobj = 0;
26051 wxDateTime *arg1 = (wxDateTime *) 0 ;
26052 bool arg2 = (bool) false ;
26053 wxDateTime *result = 0 ;
26054 void *argp1 = 0 ;
26055 int res1 = 0 ;
26056 bool val2 ;
26057 int ecode2 = 0 ;
26058 PyObject * obj0 = 0 ;
26059 PyObject * obj1 = 0 ;
26060 char * kwnames[] = {
26061 (char *) "self",(char *) "noDST", NULL
26062 };
26063
26064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26066 if (!SWIG_IsOK(res1)) {
26067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
26068 }
26069 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26070 if (obj1) {
26071 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26072 if (!SWIG_IsOK(ecode2)) {
26073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
26074 }
26075 arg2 = static_cast< bool >(val2);
26076 }
26077 {
26078 PyThreadState* __tstate = wxPyBeginAllowThreads();
26079 {
26080 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
26081 result = (wxDateTime *) &_result_ref;
26082 }
26083 wxPyEndAllowThreads(__tstate);
26084 if (PyErr_Occurred()) SWIG_fail;
26085 }
26086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26087 return resultobj;
26088 fail:
26089 return NULL;
26090 }
26091
26092
26093 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26094 PyObject *resultobj = 0;
26095 wxDateTime *arg1 = (wxDateTime *) 0 ;
26096 bool arg2 = (bool) false ;
26097 wxDateTime result;
26098 void *argp1 = 0 ;
26099 int res1 = 0 ;
26100 bool val2 ;
26101 int ecode2 = 0 ;
26102 PyObject * obj0 = 0 ;
26103 PyObject * obj1 = 0 ;
26104 char * kwnames[] = {
26105 (char *) "self",(char *) "noDST", NULL
26106 };
26107
26108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26110 if (!SWIG_IsOK(res1)) {
26111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26112 }
26113 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26114 if (obj1) {
26115 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26116 if (!SWIG_IsOK(ecode2)) {
26117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26118 }
26119 arg2 = static_cast< bool >(val2);
26120 }
26121 {
26122 PyThreadState* __tstate = wxPyBeginAllowThreads();
26123 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26124 wxPyEndAllowThreads(__tstate);
26125 if (PyErr_Occurred()) SWIG_fail;
26126 }
26127 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26128 return resultobj;
26129 fail:
26130 return NULL;
26131 }
26132
26133
26134 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26135 PyObject *resultobj = 0;
26136 wxDateTime *arg1 = (wxDateTime *) 0 ;
26137 bool arg2 = (bool) false ;
26138 wxDateTime *result = 0 ;
26139 void *argp1 = 0 ;
26140 int res1 = 0 ;
26141 bool val2 ;
26142 int ecode2 = 0 ;
26143 PyObject * obj0 = 0 ;
26144 PyObject * obj1 = 0 ;
26145 char * kwnames[] = {
26146 (char *) "self",(char *) "noDST", NULL
26147 };
26148
26149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26151 if (!SWIG_IsOK(res1)) {
26152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26153 }
26154 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26155 if (obj1) {
26156 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26157 if (!SWIG_IsOK(ecode2)) {
26158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26159 }
26160 arg2 = static_cast< bool >(val2);
26161 }
26162 {
26163 PyThreadState* __tstate = wxPyBeginAllowThreads();
26164 {
26165 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26166 result = (wxDateTime *) &_result_ref;
26167 }
26168 wxPyEndAllowThreads(__tstate);
26169 if (PyErr_Occurred()) SWIG_fail;
26170 }
26171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26172 return resultobj;
26173 fail:
26174 return NULL;
26175 }
26176
26177
26178 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26179 PyObject *resultobj = 0;
26180 wxDateTime *arg1 = (wxDateTime *) 0 ;
26181 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26182 int result;
26183 void *argp1 = 0 ;
26184 int res1 = 0 ;
26185 int val2 ;
26186 int ecode2 = 0 ;
26187 PyObject * obj0 = 0 ;
26188 PyObject * obj1 = 0 ;
26189 char * kwnames[] = {
26190 (char *) "self",(char *) "country", NULL
26191 };
26192
26193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26195 if (!SWIG_IsOK(res1)) {
26196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26197 }
26198 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26199 if (obj1) {
26200 ecode2 = SWIG_AsVal_int(obj1, &val2);
26201 if (!SWIG_IsOK(ecode2)) {
26202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26203 }
26204 arg2 = static_cast< wxDateTime::Country >(val2);
26205 }
26206 {
26207 PyThreadState* __tstate = wxPyBeginAllowThreads();
26208 result = (int)(arg1)->IsDST(arg2);
26209 wxPyEndAllowThreads(__tstate);
26210 if (PyErr_Occurred()) SWIG_fail;
26211 }
26212 resultobj = SWIG_From_int(static_cast< int >(result));
26213 return resultobj;
26214 fail:
26215 return NULL;
26216 }
26217
26218
26219 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26220 PyObject *resultobj = 0;
26221 wxDateTime *arg1 = (wxDateTime *) 0 ;
26222 bool result;
26223 void *argp1 = 0 ;
26224 int res1 = 0 ;
26225 PyObject *swig_obj[1] ;
26226
26227 if (!args) SWIG_fail;
26228 swig_obj[0] = args;
26229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26230 if (!SWIG_IsOK(res1)) {
26231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26232 }
26233 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26234 {
26235 PyThreadState* __tstate = wxPyBeginAllowThreads();
26236 result = (bool)((wxDateTime const *)arg1)->IsValid();
26237 wxPyEndAllowThreads(__tstate);
26238 if (PyErr_Occurred()) SWIG_fail;
26239 }
26240 {
26241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26242 }
26243 return resultobj;
26244 fail:
26245 return NULL;
26246 }
26247
26248
26249 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26250 PyObject *resultobj = 0;
26251 wxDateTime *arg1 = (wxDateTime *) 0 ;
26252 time_t result;
26253 void *argp1 = 0 ;
26254 int res1 = 0 ;
26255 PyObject *swig_obj[1] ;
26256
26257 if (!args) SWIG_fail;
26258 swig_obj[0] = args;
26259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26260 if (!SWIG_IsOK(res1)) {
26261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26262 }
26263 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26264 {
26265 PyThreadState* __tstate = wxPyBeginAllowThreads();
26266 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26267 wxPyEndAllowThreads(__tstate);
26268 if (PyErr_Occurred()) SWIG_fail;
26269 }
26270 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26271 return resultobj;
26272 fail:
26273 return NULL;
26274 }
26275
26276
26277 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26278 PyObject *resultobj = 0;
26279 wxDateTime *arg1 = (wxDateTime *) 0 ;
26280 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26281 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26282 int result;
26283 void *argp1 = 0 ;
26284 int res1 = 0 ;
26285 bool temp2 = false ;
26286 PyObject * obj0 = 0 ;
26287 PyObject * obj1 = 0 ;
26288 char * kwnames[] = {
26289 (char *) "self",(char *) "tz", NULL
26290 };
26291
26292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26294 if (!SWIG_IsOK(res1)) {
26295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26296 }
26297 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26298 if (obj1) {
26299 {
26300 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26301 temp2 = true;
26302 }
26303 }
26304 {
26305 PyThreadState* __tstate = wxPyBeginAllowThreads();
26306 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26307 wxPyEndAllowThreads(__tstate);
26308 if (PyErr_Occurred()) SWIG_fail;
26309 }
26310 resultobj = SWIG_From_int(static_cast< int >(result));
26311 {
26312 if (temp2) delete arg2;
26313 }
26314 return resultobj;
26315 fail:
26316 {
26317 if (temp2) delete arg2;
26318 }
26319 return NULL;
26320 }
26321
26322
26323 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26324 PyObject *resultobj = 0;
26325 wxDateTime *arg1 = (wxDateTime *) 0 ;
26326 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26327 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26328 wxDateTime::Month result;
26329 void *argp1 = 0 ;
26330 int res1 = 0 ;
26331 bool temp2 = false ;
26332 PyObject * obj0 = 0 ;
26333 PyObject * obj1 = 0 ;
26334 char * kwnames[] = {
26335 (char *) "self",(char *) "tz", NULL
26336 };
26337
26338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26340 if (!SWIG_IsOK(res1)) {
26341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26342 }
26343 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26344 if (obj1) {
26345 {
26346 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26347 temp2 = true;
26348 }
26349 }
26350 {
26351 PyThreadState* __tstate = wxPyBeginAllowThreads();
26352 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26353 wxPyEndAllowThreads(__tstate);
26354 if (PyErr_Occurred()) SWIG_fail;
26355 }
26356 resultobj = SWIG_From_int(static_cast< int >(result));
26357 {
26358 if (temp2) delete arg2;
26359 }
26360 return resultobj;
26361 fail:
26362 {
26363 if (temp2) delete arg2;
26364 }
26365 return NULL;
26366 }
26367
26368
26369 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26370 PyObject *resultobj = 0;
26371 wxDateTime *arg1 = (wxDateTime *) 0 ;
26372 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26373 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26374 int result;
26375 void *argp1 = 0 ;
26376 int res1 = 0 ;
26377 bool temp2 = false ;
26378 PyObject * obj0 = 0 ;
26379 PyObject * obj1 = 0 ;
26380 char * kwnames[] = {
26381 (char *) "self",(char *) "tz", NULL
26382 };
26383
26384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26386 if (!SWIG_IsOK(res1)) {
26387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26388 }
26389 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26390 if (obj1) {
26391 {
26392 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26393 temp2 = true;
26394 }
26395 }
26396 {
26397 PyThreadState* __tstate = wxPyBeginAllowThreads();
26398 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26399 wxPyEndAllowThreads(__tstate);
26400 if (PyErr_Occurred()) SWIG_fail;
26401 }
26402 resultobj = SWIG_From_int(static_cast< int >(result));
26403 {
26404 if (temp2) delete arg2;
26405 }
26406 return resultobj;
26407 fail:
26408 {
26409 if (temp2) delete arg2;
26410 }
26411 return NULL;
26412 }
26413
26414
26415 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26416 PyObject *resultobj = 0;
26417 wxDateTime *arg1 = (wxDateTime *) 0 ;
26418 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26419 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26420 wxDateTime::WeekDay result;
26421 void *argp1 = 0 ;
26422 int res1 = 0 ;
26423 bool temp2 = false ;
26424 PyObject * obj0 = 0 ;
26425 PyObject * obj1 = 0 ;
26426 char * kwnames[] = {
26427 (char *) "self",(char *) "tz", NULL
26428 };
26429
26430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26432 if (!SWIG_IsOK(res1)) {
26433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26434 }
26435 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26436 if (obj1) {
26437 {
26438 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26439 temp2 = true;
26440 }
26441 }
26442 {
26443 PyThreadState* __tstate = wxPyBeginAllowThreads();
26444 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26445 wxPyEndAllowThreads(__tstate);
26446 if (PyErr_Occurred()) SWIG_fail;
26447 }
26448 resultobj = SWIG_From_int(static_cast< int >(result));
26449 {
26450 if (temp2) delete arg2;
26451 }
26452 return resultobj;
26453 fail:
26454 {
26455 if (temp2) delete arg2;
26456 }
26457 return NULL;
26458 }
26459
26460
26461 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26462 PyObject *resultobj = 0;
26463 wxDateTime *arg1 = (wxDateTime *) 0 ;
26464 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26465 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26466 int result;
26467 void *argp1 = 0 ;
26468 int res1 = 0 ;
26469 bool temp2 = false ;
26470 PyObject * obj0 = 0 ;
26471 PyObject * obj1 = 0 ;
26472 char * kwnames[] = {
26473 (char *) "self",(char *) "tz", NULL
26474 };
26475
26476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26478 if (!SWIG_IsOK(res1)) {
26479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26480 }
26481 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26482 if (obj1) {
26483 {
26484 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26485 temp2 = true;
26486 }
26487 }
26488 {
26489 PyThreadState* __tstate = wxPyBeginAllowThreads();
26490 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26491 wxPyEndAllowThreads(__tstate);
26492 if (PyErr_Occurred()) SWIG_fail;
26493 }
26494 resultobj = SWIG_From_int(static_cast< int >(result));
26495 {
26496 if (temp2) delete arg2;
26497 }
26498 return resultobj;
26499 fail:
26500 {
26501 if (temp2) delete arg2;
26502 }
26503 return NULL;
26504 }
26505
26506
26507 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26508 PyObject *resultobj = 0;
26509 wxDateTime *arg1 = (wxDateTime *) 0 ;
26510 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26511 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26512 int result;
26513 void *argp1 = 0 ;
26514 int res1 = 0 ;
26515 bool temp2 = false ;
26516 PyObject * obj0 = 0 ;
26517 PyObject * obj1 = 0 ;
26518 char * kwnames[] = {
26519 (char *) "self",(char *) "tz", NULL
26520 };
26521
26522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26524 if (!SWIG_IsOK(res1)) {
26525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26526 }
26527 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26528 if (obj1) {
26529 {
26530 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26531 temp2 = true;
26532 }
26533 }
26534 {
26535 PyThreadState* __tstate = wxPyBeginAllowThreads();
26536 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26537 wxPyEndAllowThreads(__tstate);
26538 if (PyErr_Occurred()) SWIG_fail;
26539 }
26540 resultobj = SWIG_From_int(static_cast< int >(result));
26541 {
26542 if (temp2) delete arg2;
26543 }
26544 return resultobj;
26545 fail:
26546 {
26547 if (temp2) delete arg2;
26548 }
26549 return NULL;
26550 }
26551
26552
26553 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26554 PyObject *resultobj = 0;
26555 wxDateTime *arg1 = (wxDateTime *) 0 ;
26556 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26557 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26558 int result;
26559 void *argp1 = 0 ;
26560 int res1 = 0 ;
26561 bool temp2 = false ;
26562 PyObject * obj0 = 0 ;
26563 PyObject * obj1 = 0 ;
26564 char * kwnames[] = {
26565 (char *) "self",(char *) "tz", NULL
26566 };
26567
26568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26570 if (!SWIG_IsOK(res1)) {
26571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26572 }
26573 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26574 if (obj1) {
26575 {
26576 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26577 temp2 = true;
26578 }
26579 }
26580 {
26581 PyThreadState* __tstate = wxPyBeginAllowThreads();
26582 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26583 wxPyEndAllowThreads(__tstate);
26584 if (PyErr_Occurred()) SWIG_fail;
26585 }
26586 resultobj = SWIG_From_int(static_cast< int >(result));
26587 {
26588 if (temp2) delete arg2;
26589 }
26590 return resultobj;
26591 fail:
26592 {
26593 if (temp2) delete arg2;
26594 }
26595 return NULL;
26596 }
26597
26598
26599 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26600 PyObject *resultobj = 0;
26601 wxDateTime *arg1 = (wxDateTime *) 0 ;
26602 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26603 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26604 int result;
26605 void *argp1 = 0 ;
26606 int res1 = 0 ;
26607 bool temp2 = false ;
26608 PyObject * obj0 = 0 ;
26609 PyObject * obj1 = 0 ;
26610 char * kwnames[] = {
26611 (char *) "self",(char *) "tz", NULL
26612 };
26613
26614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26616 if (!SWIG_IsOK(res1)) {
26617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26618 }
26619 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26620 if (obj1) {
26621 {
26622 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26623 temp2 = true;
26624 }
26625 }
26626 {
26627 PyThreadState* __tstate = wxPyBeginAllowThreads();
26628 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26629 wxPyEndAllowThreads(__tstate);
26630 if (PyErr_Occurred()) SWIG_fail;
26631 }
26632 resultobj = SWIG_From_int(static_cast< int >(result));
26633 {
26634 if (temp2) delete arg2;
26635 }
26636 return resultobj;
26637 fail:
26638 {
26639 if (temp2) delete arg2;
26640 }
26641 return NULL;
26642 }
26643
26644
26645 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26646 PyObject *resultobj = 0;
26647 wxDateTime *arg1 = (wxDateTime *) 0 ;
26648 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26649 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26650 int result;
26651 void *argp1 = 0 ;
26652 int res1 = 0 ;
26653 bool temp2 = false ;
26654 PyObject * obj0 = 0 ;
26655 PyObject * obj1 = 0 ;
26656 char * kwnames[] = {
26657 (char *) "self",(char *) "tz", NULL
26658 };
26659
26660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26662 if (!SWIG_IsOK(res1)) {
26663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26664 }
26665 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26666 if (obj1) {
26667 {
26668 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26669 temp2 = true;
26670 }
26671 }
26672 {
26673 PyThreadState* __tstate = wxPyBeginAllowThreads();
26674 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26675 wxPyEndAllowThreads(__tstate);
26676 if (PyErr_Occurred()) SWIG_fail;
26677 }
26678 resultobj = SWIG_From_int(static_cast< int >(result));
26679 {
26680 if (temp2) delete arg2;
26681 }
26682 return resultobj;
26683 fail:
26684 {
26685 if (temp2) delete arg2;
26686 }
26687 return NULL;
26688 }
26689
26690
26691 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26692 PyObject *resultobj = 0;
26693 wxDateTime *arg1 = (wxDateTime *) 0 ;
26694 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26695 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26696 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26697 int result;
26698 void *argp1 = 0 ;
26699 int res1 = 0 ;
26700 int val2 ;
26701 int ecode2 = 0 ;
26702 bool temp3 = false ;
26703 PyObject * obj0 = 0 ;
26704 PyObject * obj1 = 0 ;
26705 PyObject * obj2 = 0 ;
26706 char * kwnames[] = {
26707 (char *) "self",(char *) "flags",(char *) "tz", NULL
26708 };
26709
26710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26712 if (!SWIG_IsOK(res1)) {
26713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26714 }
26715 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26716 if (obj1) {
26717 ecode2 = SWIG_AsVal_int(obj1, &val2);
26718 if (!SWIG_IsOK(ecode2)) {
26719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26720 }
26721 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26722 }
26723 if (obj2) {
26724 {
26725 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26726 temp3 = true;
26727 }
26728 }
26729 {
26730 PyThreadState* __tstate = wxPyBeginAllowThreads();
26731 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26732 wxPyEndAllowThreads(__tstate);
26733 if (PyErr_Occurred()) SWIG_fail;
26734 }
26735 resultobj = SWIG_From_int(static_cast< int >(result));
26736 {
26737 if (temp3) delete arg3;
26738 }
26739 return resultobj;
26740 fail:
26741 {
26742 if (temp3) delete arg3;
26743 }
26744 return NULL;
26745 }
26746
26747
26748 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26749 PyObject *resultobj = 0;
26750 wxDateTime *arg1 = (wxDateTime *) 0 ;
26751 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26752 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26753 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26754 int result;
26755 void *argp1 = 0 ;
26756 int res1 = 0 ;
26757 int val2 ;
26758 int ecode2 = 0 ;
26759 bool temp3 = false ;
26760 PyObject * obj0 = 0 ;
26761 PyObject * obj1 = 0 ;
26762 PyObject * obj2 = 0 ;
26763 char * kwnames[] = {
26764 (char *) "self",(char *) "flags",(char *) "tz", NULL
26765 };
26766
26767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26769 if (!SWIG_IsOK(res1)) {
26770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26771 }
26772 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26773 if (obj1) {
26774 ecode2 = SWIG_AsVal_int(obj1, &val2);
26775 if (!SWIG_IsOK(ecode2)) {
26776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26777 }
26778 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26779 }
26780 if (obj2) {
26781 {
26782 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26783 temp3 = true;
26784 }
26785 }
26786 {
26787 PyThreadState* __tstate = wxPyBeginAllowThreads();
26788 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26789 wxPyEndAllowThreads(__tstate);
26790 if (PyErr_Occurred()) SWIG_fail;
26791 }
26792 resultobj = SWIG_From_int(static_cast< int >(result));
26793 {
26794 if (temp3) delete arg3;
26795 }
26796 return resultobj;
26797 fail:
26798 {
26799 if (temp3) delete arg3;
26800 }
26801 return NULL;
26802 }
26803
26804
26805 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26806 PyObject *resultobj = 0;
26807 wxDateTime *arg1 = (wxDateTime *) 0 ;
26808 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26809 bool result;
26810 void *argp1 = 0 ;
26811 int res1 = 0 ;
26812 int val2 ;
26813 int ecode2 = 0 ;
26814 PyObject * obj0 = 0 ;
26815 PyObject * obj1 = 0 ;
26816 char * kwnames[] = {
26817 (char *) "self",(char *) "country", NULL
26818 };
26819
26820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26822 if (!SWIG_IsOK(res1)) {
26823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26824 }
26825 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26826 if (obj1) {
26827 ecode2 = SWIG_AsVal_int(obj1, &val2);
26828 if (!SWIG_IsOK(ecode2)) {
26829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26830 }
26831 arg2 = static_cast< wxDateTime::Country >(val2);
26832 }
26833 {
26834 PyThreadState* __tstate = wxPyBeginAllowThreads();
26835 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26836 wxPyEndAllowThreads(__tstate);
26837 if (PyErr_Occurred()) SWIG_fail;
26838 }
26839 {
26840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26841 }
26842 return resultobj;
26843 fail:
26844 return NULL;
26845 }
26846
26847
26848 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26849 PyObject *resultobj = 0;
26850 wxDateTime *arg1 = (wxDateTime *) 0 ;
26851 wxDateTime *arg2 = 0 ;
26852 bool result;
26853 void *argp1 = 0 ;
26854 int res1 = 0 ;
26855 void *argp2 = 0 ;
26856 int res2 = 0 ;
26857 PyObject * obj0 = 0 ;
26858 PyObject * obj1 = 0 ;
26859 char * kwnames[] = {
26860 (char *) "self",(char *) "datetime", NULL
26861 };
26862
26863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26865 if (!SWIG_IsOK(res1)) {
26866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26867 }
26868 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26869 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26870 if (!SWIG_IsOK(res2)) {
26871 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26872 }
26873 if (!argp2) {
26874 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26875 }
26876 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26877 {
26878 PyThreadState* __tstate = wxPyBeginAllowThreads();
26879 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26880 wxPyEndAllowThreads(__tstate);
26881 if (PyErr_Occurred()) SWIG_fail;
26882 }
26883 {
26884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26885 }
26886 return resultobj;
26887 fail:
26888 return NULL;
26889 }
26890
26891
26892 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26893 PyObject *resultobj = 0;
26894 wxDateTime *arg1 = (wxDateTime *) 0 ;
26895 wxDateTime *arg2 = 0 ;
26896 bool result;
26897 void *argp1 = 0 ;
26898 int res1 = 0 ;
26899 void *argp2 = 0 ;
26900 int res2 = 0 ;
26901 PyObject * obj0 = 0 ;
26902 PyObject * obj1 = 0 ;
26903 char * kwnames[] = {
26904 (char *) "self",(char *) "datetime", NULL
26905 };
26906
26907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26909 if (!SWIG_IsOK(res1)) {
26910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26911 }
26912 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26913 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26914 if (!SWIG_IsOK(res2)) {
26915 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26916 }
26917 if (!argp2) {
26918 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26919 }
26920 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26921 {
26922 PyThreadState* __tstate = wxPyBeginAllowThreads();
26923 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26924 wxPyEndAllowThreads(__tstate);
26925 if (PyErr_Occurred()) SWIG_fail;
26926 }
26927 {
26928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26929 }
26930 return resultobj;
26931 fail:
26932 return NULL;
26933 }
26934
26935
26936 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26937 PyObject *resultobj = 0;
26938 wxDateTime *arg1 = (wxDateTime *) 0 ;
26939 wxDateTime *arg2 = 0 ;
26940 bool result;
26941 void *argp1 = 0 ;
26942 int res1 = 0 ;
26943 void *argp2 = 0 ;
26944 int res2 = 0 ;
26945 PyObject * obj0 = 0 ;
26946 PyObject * obj1 = 0 ;
26947 char * kwnames[] = {
26948 (char *) "self",(char *) "datetime", NULL
26949 };
26950
26951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26953 if (!SWIG_IsOK(res1)) {
26954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26955 }
26956 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26957 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26958 if (!SWIG_IsOK(res2)) {
26959 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26960 }
26961 if (!argp2) {
26962 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26963 }
26964 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26965 {
26966 PyThreadState* __tstate = wxPyBeginAllowThreads();
26967 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26968 wxPyEndAllowThreads(__tstate);
26969 if (PyErr_Occurred()) SWIG_fail;
26970 }
26971 {
26972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26973 }
26974 return resultobj;
26975 fail:
26976 return NULL;
26977 }
26978
26979
26980 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26981 PyObject *resultobj = 0;
26982 wxDateTime *arg1 = (wxDateTime *) 0 ;
26983 wxDateTime *arg2 = 0 ;
26984 wxDateTime *arg3 = 0 ;
26985 bool result;
26986 void *argp1 = 0 ;
26987 int res1 = 0 ;
26988 void *argp2 = 0 ;
26989 int res2 = 0 ;
26990 void *argp3 = 0 ;
26991 int res3 = 0 ;
26992 PyObject * obj0 = 0 ;
26993 PyObject * obj1 = 0 ;
26994 PyObject * obj2 = 0 ;
26995 char * kwnames[] = {
26996 (char *) "self",(char *) "t1",(char *) "t2", NULL
26997 };
26998
26999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27001 if (!SWIG_IsOK(res1)) {
27002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27003 }
27004 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27005 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27006 if (!SWIG_IsOK(res2)) {
27007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27008 }
27009 if (!argp2) {
27010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27011 }
27012 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27013 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27014 if (!SWIG_IsOK(res3)) {
27015 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27016 }
27017 if (!argp3) {
27018 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27019 }
27020 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27021 {
27022 PyThreadState* __tstate = wxPyBeginAllowThreads();
27023 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27024 wxPyEndAllowThreads(__tstate);
27025 if (PyErr_Occurred()) SWIG_fail;
27026 }
27027 {
27028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27029 }
27030 return resultobj;
27031 fail:
27032 return NULL;
27033 }
27034
27035
27036 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27037 PyObject *resultobj = 0;
27038 wxDateTime *arg1 = (wxDateTime *) 0 ;
27039 wxDateTime *arg2 = 0 ;
27040 wxDateTime *arg3 = 0 ;
27041 bool result;
27042 void *argp1 = 0 ;
27043 int res1 = 0 ;
27044 void *argp2 = 0 ;
27045 int res2 = 0 ;
27046 void *argp3 = 0 ;
27047 int res3 = 0 ;
27048 PyObject * obj0 = 0 ;
27049 PyObject * obj1 = 0 ;
27050 PyObject * obj2 = 0 ;
27051 char * kwnames[] = {
27052 (char *) "self",(char *) "t1",(char *) "t2", NULL
27053 };
27054
27055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27057 if (!SWIG_IsOK(res1)) {
27058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27059 }
27060 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27061 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27062 if (!SWIG_IsOK(res2)) {
27063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27064 }
27065 if (!argp2) {
27066 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27067 }
27068 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27069 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27070 if (!SWIG_IsOK(res3)) {
27071 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27072 }
27073 if (!argp3) {
27074 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27075 }
27076 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27077 {
27078 PyThreadState* __tstate = wxPyBeginAllowThreads();
27079 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27080 wxPyEndAllowThreads(__tstate);
27081 if (PyErr_Occurred()) SWIG_fail;
27082 }
27083 {
27084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27085 }
27086 return resultobj;
27087 fail:
27088 return NULL;
27089 }
27090
27091
27092 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27093 PyObject *resultobj = 0;
27094 wxDateTime *arg1 = (wxDateTime *) 0 ;
27095 wxDateTime *arg2 = 0 ;
27096 bool result;
27097 void *argp1 = 0 ;
27098 int res1 = 0 ;
27099 void *argp2 = 0 ;
27100 int res2 = 0 ;
27101 PyObject * obj0 = 0 ;
27102 PyObject * obj1 = 0 ;
27103 char * kwnames[] = {
27104 (char *) "self",(char *) "dt", NULL
27105 };
27106
27107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27109 if (!SWIG_IsOK(res1)) {
27110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27111 }
27112 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27113 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27114 if (!SWIG_IsOK(res2)) {
27115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27116 }
27117 if (!argp2) {
27118 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27119 }
27120 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27121 {
27122 PyThreadState* __tstate = wxPyBeginAllowThreads();
27123 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27124 wxPyEndAllowThreads(__tstate);
27125 if (PyErr_Occurred()) SWIG_fail;
27126 }
27127 {
27128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27129 }
27130 return resultobj;
27131 fail:
27132 return NULL;
27133 }
27134
27135
27136 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27137 PyObject *resultobj = 0;
27138 wxDateTime *arg1 = (wxDateTime *) 0 ;
27139 wxDateTime *arg2 = 0 ;
27140 bool result;
27141 void *argp1 = 0 ;
27142 int res1 = 0 ;
27143 void *argp2 = 0 ;
27144 int res2 = 0 ;
27145 PyObject * obj0 = 0 ;
27146 PyObject * obj1 = 0 ;
27147 char * kwnames[] = {
27148 (char *) "self",(char *) "dt", NULL
27149 };
27150
27151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27153 if (!SWIG_IsOK(res1)) {
27154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27155 }
27156 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27157 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27158 if (!SWIG_IsOK(res2)) {
27159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27160 }
27161 if (!argp2) {
27162 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27163 }
27164 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27165 {
27166 PyThreadState* __tstate = wxPyBeginAllowThreads();
27167 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27168 wxPyEndAllowThreads(__tstate);
27169 if (PyErr_Occurred()) SWIG_fail;
27170 }
27171 {
27172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27173 }
27174 return resultobj;
27175 fail:
27176 return NULL;
27177 }
27178
27179
27180 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27181 PyObject *resultobj = 0;
27182 wxDateTime *arg1 = (wxDateTime *) 0 ;
27183 wxDateTime *arg2 = 0 ;
27184 wxTimeSpan *arg3 = 0 ;
27185 bool result;
27186 void *argp1 = 0 ;
27187 int res1 = 0 ;
27188 void *argp2 = 0 ;
27189 int res2 = 0 ;
27190 void *argp3 = 0 ;
27191 int res3 = 0 ;
27192 PyObject * obj0 = 0 ;
27193 PyObject * obj1 = 0 ;
27194 PyObject * obj2 = 0 ;
27195 char * kwnames[] = {
27196 (char *) "self",(char *) "dt",(char *) "ts", NULL
27197 };
27198
27199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27201 if (!SWIG_IsOK(res1)) {
27202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27203 }
27204 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27205 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27206 if (!SWIG_IsOK(res2)) {
27207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27208 }
27209 if (!argp2) {
27210 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27211 }
27212 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27213 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27214 if (!SWIG_IsOK(res3)) {
27215 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27216 }
27217 if (!argp3) {
27218 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27219 }
27220 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27221 {
27222 PyThreadState* __tstate = wxPyBeginAllowThreads();
27223 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27224 wxPyEndAllowThreads(__tstate);
27225 if (PyErr_Occurred()) SWIG_fail;
27226 }
27227 {
27228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27229 }
27230 return resultobj;
27231 fail:
27232 return NULL;
27233 }
27234
27235
27236 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27237 PyObject *resultobj = 0;
27238 wxDateTime *arg1 = (wxDateTime *) 0 ;
27239 wxTimeSpan *arg2 = 0 ;
27240 wxDateTime *result = 0 ;
27241 void *argp1 = 0 ;
27242 int res1 = 0 ;
27243 void *argp2 = 0 ;
27244 int res2 = 0 ;
27245 PyObject * obj0 = 0 ;
27246 PyObject * obj1 = 0 ;
27247 char * kwnames[] = {
27248 (char *) "self",(char *) "diff", NULL
27249 };
27250
27251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27253 if (!SWIG_IsOK(res1)) {
27254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27255 }
27256 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27257 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27258 if (!SWIG_IsOK(res2)) {
27259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27260 }
27261 if (!argp2) {
27262 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27263 }
27264 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27265 {
27266 PyThreadState* __tstate = wxPyBeginAllowThreads();
27267 {
27268 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27269 result = (wxDateTime *) &_result_ref;
27270 }
27271 wxPyEndAllowThreads(__tstate);
27272 if (PyErr_Occurred()) SWIG_fail;
27273 }
27274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27275 return resultobj;
27276 fail:
27277 return NULL;
27278 }
27279
27280
27281 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27282 PyObject *resultobj = 0;
27283 wxDateTime *arg1 = (wxDateTime *) 0 ;
27284 wxDateSpan *arg2 = 0 ;
27285 wxDateTime *result = 0 ;
27286 void *argp1 = 0 ;
27287 int res1 = 0 ;
27288 void *argp2 = 0 ;
27289 int res2 = 0 ;
27290 PyObject * obj0 = 0 ;
27291 PyObject * obj1 = 0 ;
27292 char * kwnames[] = {
27293 (char *) "self",(char *) "diff", NULL
27294 };
27295
27296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27298 if (!SWIG_IsOK(res1)) {
27299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27300 }
27301 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27302 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27303 if (!SWIG_IsOK(res2)) {
27304 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27305 }
27306 if (!argp2) {
27307 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27308 }
27309 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27310 {
27311 PyThreadState* __tstate = wxPyBeginAllowThreads();
27312 {
27313 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27314 result = (wxDateTime *) &_result_ref;
27315 }
27316 wxPyEndAllowThreads(__tstate);
27317 if (PyErr_Occurred()) SWIG_fail;
27318 }
27319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27320 return resultobj;
27321 fail:
27322 return NULL;
27323 }
27324
27325
27326 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27327 PyObject *resultobj = 0;
27328 wxDateTime *arg1 = (wxDateTime *) 0 ;
27329 wxTimeSpan *arg2 = 0 ;
27330 wxDateTime *result = 0 ;
27331 void *argp1 = 0 ;
27332 int res1 = 0 ;
27333 void *argp2 = 0 ;
27334 int res2 = 0 ;
27335 PyObject * obj0 = 0 ;
27336 PyObject * obj1 = 0 ;
27337 char * kwnames[] = {
27338 (char *) "self",(char *) "diff", NULL
27339 };
27340
27341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27343 if (!SWIG_IsOK(res1)) {
27344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27345 }
27346 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27347 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27348 if (!SWIG_IsOK(res2)) {
27349 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27350 }
27351 if (!argp2) {
27352 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27353 }
27354 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27355 {
27356 PyThreadState* __tstate = wxPyBeginAllowThreads();
27357 {
27358 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27359 result = (wxDateTime *) &_result_ref;
27360 }
27361 wxPyEndAllowThreads(__tstate);
27362 if (PyErr_Occurred()) SWIG_fail;
27363 }
27364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27365 return resultobj;
27366 fail:
27367 return NULL;
27368 }
27369
27370
27371 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27372 PyObject *resultobj = 0;
27373 wxDateTime *arg1 = (wxDateTime *) 0 ;
27374 wxDateSpan *arg2 = 0 ;
27375 wxDateTime *result = 0 ;
27376 void *argp1 = 0 ;
27377 int res1 = 0 ;
27378 void *argp2 = 0 ;
27379 int res2 = 0 ;
27380 PyObject * obj0 = 0 ;
27381 PyObject * obj1 = 0 ;
27382 char * kwnames[] = {
27383 (char *) "self",(char *) "diff", NULL
27384 };
27385
27386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27388 if (!SWIG_IsOK(res1)) {
27389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27390 }
27391 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27392 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27393 if (!SWIG_IsOK(res2)) {
27394 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27395 }
27396 if (!argp2) {
27397 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27398 }
27399 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27400 {
27401 PyThreadState* __tstate = wxPyBeginAllowThreads();
27402 {
27403 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27404 result = (wxDateTime *) &_result_ref;
27405 }
27406 wxPyEndAllowThreads(__tstate);
27407 if (PyErr_Occurred()) SWIG_fail;
27408 }
27409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27410 return resultobj;
27411 fail:
27412 return NULL;
27413 }
27414
27415
27416 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27417 PyObject *resultobj = 0;
27418 wxDateTime *arg1 = (wxDateTime *) 0 ;
27419 wxDateTime *arg2 = 0 ;
27420 wxTimeSpan result;
27421 void *argp1 = 0 ;
27422 int res1 = 0 ;
27423 void *argp2 = 0 ;
27424 int res2 = 0 ;
27425 PyObject * obj0 = 0 ;
27426 PyObject * obj1 = 0 ;
27427 char * kwnames[] = {
27428 (char *) "self",(char *) "dt", NULL
27429 };
27430
27431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27433 if (!SWIG_IsOK(res1)) {
27434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27435 }
27436 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27437 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27438 if (!SWIG_IsOK(res2)) {
27439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27440 }
27441 if (!argp2) {
27442 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27443 }
27444 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27445 {
27446 PyThreadState* __tstate = wxPyBeginAllowThreads();
27447 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27448 wxPyEndAllowThreads(__tstate);
27449 if (PyErr_Occurred()) SWIG_fail;
27450 }
27451 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27452 return resultobj;
27453 fail:
27454 return NULL;
27455 }
27456
27457
27458 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27459 PyObject *resultobj = 0;
27460 wxDateTime *arg1 = (wxDateTime *) 0 ;
27461 wxTimeSpan *arg2 = 0 ;
27462 wxDateTime *result = 0 ;
27463 void *argp1 = 0 ;
27464 int res1 = 0 ;
27465 void *argp2 = 0 ;
27466 int res2 = 0 ;
27467
27468 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27470 if (!SWIG_IsOK(res1)) {
27471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27472 }
27473 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27474 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27475 if (!SWIG_IsOK(res2)) {
27476 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27477 }
27478 if (!argp2) {
27479 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27480 }
27481 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27482 {
27483 PyThreadState* __tstate = wxPyBeginAllowThreads();
27484 {
27485 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27486 result = (wxDateTime *) &_result_ref;
27487 }
27488 wxPyEndAllowThreads(__tstate);
27489 if (PyErr_Occurred()) SWIG_fail;
27490 }
27491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27492 return resultobj;
27493 fail:
27494 return NULL;
27495 }
27496
27497
27498 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27499 PyObject *resultobj = 0;
27500 wxDateTime *arg1 = (wxDateTime *) 0 ;
27501 wxDateSpan *arg2 = 0 ;
27502 wxDateTime *result = 0 ;
27503 void *argp1 = 0 ;
27504 int res1 = 0 ;
27505 void *argp2 = 0 ;
27506 int res2 = 0 ;
27507
27508 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27510 if (!SWIG_IsOK(res1)) {
27511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27512 }
27513 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27514 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27515 if (!SWIG_IsOK(res2)) {
27516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27517 }
27518 if (!argp2) {
27519 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27520 }
27521 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27522 {
27523 PyThreadState* __tstate = wxPyBeginAllowThreads();
27524 {
27525 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27526 result = (wxDateTime *) &_result_ref;
27527 }
27528 wxPyEndAllowThreads(__tstate);
27529 if (PyErr_Occurred()) SWIG_fail;
27530 }
27531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27532 return resultobj;
27533 fail:
27534 return NULL;
27535 }
27536
27537
27538 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27539 int argc;
27540 PyObject *argv[3];
27541
27542 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27543 --argc;
27544 if (argc == 2) {
27545 int _v = 0;
27546 {
27547 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27548 _v = SWIG_CheckState(res);
27549 }
27550 if (!_v) goto check_1;
27551 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27552 }
27553 check_1:
27554
27555 if (argc == 2) {
27556 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27557 }
27558
27559 fail:
27560 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27561 return NULL;
27562 }
27563
27564
27565 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27566 PyObject *resultobj = 0;
27567 wxDateTime *arg1 = (wxDateTime *) 0 ;
27568 wxTimeSpan *arg2 = 0 ;
27569 wxDateTime *result = 0 ;
27570 void *argp1 = 0 ;
27571 int res1 = 0 ;
27572 void *argp2 = 0 ;
27573 int res2 = 0 ;
27574
27575 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27577 if (!SWIG_IsOK(res1)) {
27578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27579 }
27580 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27581 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27582 if (!SWIG_IsOK(res2)) {
27583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27584 }
27585 if (!argp2) {
27586 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27587 }
27588 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27589 {
27590 PyThreadState* __tstate = wxPyBeginAllowThreads();
27591 {
27592 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27593 result = (wxDateTime *) &_result_ref;
27594 }
27595 wxPyEndAllowThreads(__tstate);
27596 if (PyErr_Occurred()) SWIG_fail;
27597 }
27598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27599 return resultobj;
27600 fail:
27601 return NULL;
27602 }
27603
27604
27605 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27606 PyObject *resultobj = 0;
27607 wxDateTime *arg1 = (wxDateTime *) 0 ;
27608 wxDateSpan *arg2 = 0 ;
27609 wxDateTime *result = 0 ;
27610 void *argp1 = 0 ;
27611 int res1 = 0 ;
27612 void *argp2 = 0 ;
27613 int res2 = 0 ;
27614
27615 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27617 if (!SWIG_IsOK(res1)) {
27618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27619 }
27620 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27621 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27622 if (!SWIG_IsOK(res2)) {
27623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27624 }
27625 if (!argp2) {
27626 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27627 }
27628 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27629 {
27630 PyThreadState* __tstate = wxPyBeginAllowThreads();
27631 {
27632 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27633 result = (wxDateTime *) &_result_ref;
27634 }
27635 wxPyEndAllowThreads(__tstate);
27636 if (PyErr_Occurred()) SWIG_fail;
27637 }
27638 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27639 return resultobj;
27640 fail:
27641 return NULL;
27642 }
27643
27644
27645 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27646 int argc;
27647 PyObject *argv[3];
27648
27649 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27650 --argc;
27651 if (argc == 2) {
27652 int _v = 0;
27653 {
27654 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27655 _v = SWIG_CheckState(res);
27656 }
27657 if (!_v) goto check_1;
27658 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27659 }
27660 check_1:
27661
27662 if (argc == 2) {
27663 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27664 }
27665
27666 fail:
27667 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27668 return NULL;
27669 }
27670
27671
27672 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27673 PyObject *resultobj = 0;
27674 wxDateTime *arg1 = (wxDateTime *) 0 ;
27675 wxTimeSpan *arg2 = 0 ;
27676 wxDateTime result;
27677 void *argp1 = 0 ;
27678 int res1 = 0 ;
27679 void *argp2 = 0 ;
27680 int res2 = 0 ;
27681
27682 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27684 if (!SWIG_IsOK(res1)) {
27685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27686 }
27687 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27688 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27689 if (!SWIG_IsOK(res2)) {
27690 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27691 }
27692 if (!argp2) {
27693 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27694 }
27695 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27696 {
27697 PyThreadState* __tstate = wxPyBeginAllowThreads();
27698 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27699 wxPyEndAllowThreads(__tstate);
27700 if (PyErr_Occurred()) SWIG_fail;
27701 }
27702 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27703 return resultobj;
27704 fail:
27705 return NULL;
27706 }
27707
27708
27709 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27710 PyObject *resultobj = 0;
27711 wxDateTime *arg1 = (wxDateTime *) 0 ;
27712 wxDateSpan *arg2 = 0 ;
27713 wxDateTime result;
27714 void *argp1 = 0 ;
27715 int res1 = 0 ;
27716 void *argp2 = 0 ;
27717 int res2 = 0 ;
27718
27719 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27721 if (!SWIG_IsOK(res1)) {
27722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27723 }
27724 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27725 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27726 if (!SWIG_IsOK(res2)) {
27727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27728 }
27729 if (!argp2) {
27730 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27731 }
27732 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27733 {
27734 PyThreadState* __tstate = wxPyBeginAllowThreads();
27735 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27736 wxPyEndAllowThreads(__tstate);
27737 if (PyErr_Occurred()) SWIG_fail;
27738 }
27739 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27740 return resultobj;
27741 fail:
27742 return NULL;
27743 }
27744
27745
27746 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27747 int argc;
27748 PyObject *argv[3];
27749
27750 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27751 --argc;
27752 if (argc == 2) {
27753 int _v = 0;
27754 {
27755 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27756 _v = SWIG_CheckState(res);
27757 }
27758 if (!_v) goto check_1;
27759 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27760 }
27761 check_1:
27762
27763 if (argc == 2) {
27764 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27765 }
27766
27767 fail:
27768 Py_INCREF(Py_NotImplemented);
27769 return Py_NotImplemented;
27770 }
27771
27772
27773 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27774 PyObject *resultobj = 0;
27775 wxDateTime *arg1 = (wxDateTime *) 0 ;
27776 wxDateTime *arg2 = 0 ;
27777 wxTimeSpan result;
27778 void *argp1 = 0 ;
27779 int res1 = 0 ;
27780 void *argp2 = 0 ;
27781 int res2 = 0 ;
27782
27783 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27785 if (!SWIG_IsOK(res1)) {
27786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27787 }
27788 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27789 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27790 if (!SWIG_IsOK(res2)) {
27791 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27792 }
27793 if (!argp2) {
27794 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27795 }
27796 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27797 {
27798 PyThreadState* __tstate = wxPyBeginAllowThreads();
27799 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27800 wxPyEndAllowThreads(__tstate);
27801 if (PyErr_Occurred()) SWIG_fail;
27802 }
27803 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27804 return resultobj;
27805 fail:
27806 return NULL;
27807 }
27808
27809
27810 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27811 PyObject *resultobj = 0;
27812 wxDateTime *arg1 = (wxDateTime *) 0 ;
27813 wxTimeSpan *arg2 = 0 ;
27814 wxDateTime result;
27815 void *argp1 = 0 ;
27816 int res1 = 0 ;
27817 void *argp2 = 0 ;
27818 int res2 = 0 ;
27819
27820 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27822 if (!SWIG_IsOK(res1)) {
27823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27824 }
27825 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27826 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27827 if (!SWIG_IsOK(res2)) {
27828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27829 }
27830 if (!argp2) {
27831 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27832 }
27833 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27834 {
27835 PyThreadState* __tstate = wxPyBeginAllowThreads();
27836 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27837 wxPyEndAllowThreads(__tstate);
27838 if (PyErr_Occurred()) SWIG_fail;
27839 }
27840 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27841 return resultobj;
27842 fail:
27843 return NULL;
27844 }
27845
27846
27847 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27848 PyObject *resultobj = 0;
27849 wxDateTime *arg1 = (wxDateTime *) 0 ;
27850 wxDateSpan *arg2 = 0 ;
27851 wxDateTime result;
27852 void *argp1 = 0 ;
27853 int res1 = 0 ;
27854 void *argp2 = 0 ;
27855 int res2 = 0 ;
27856
27857 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27859 if (!SWIG_IsOK(res1)) {
27860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27861 }
27862 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27863 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27864 if (!SWIG_IsOK(res2)) {
27865 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27866 }
27867 if (!argp2) {
27868 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27869 }
27870 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27871 {
27872 PyThreadState* __tstate = wxPyBeginAllowThreads();
27873 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27874 wxPyEndAllowThreads(__tstate);
27875 if (PyErr_Occurred()) SWIG_fail;
27876 }
27877 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27878 return resultobj;
27879 fail:
27880 return NULL;
27881 }
27882
27883
27884 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27885 int argc;
27886 PyObject *argv[3];
27887
27888 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27889 --argc;
27890 if (argc == 2) {
27891 int _v = 0;
27892 {
27893 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27894 _v = SWIG_CheckState(res);
27895 }
27896 if (!_v) goto check_1;
27897 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27898 }
27899 check_1:
27900
27901 if (argc == 2) {
27902 int _v = 0;
27903 {
27904 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27905 _v = SWIG_CheckState(res);
27906 }
27907 if (!_v) goto check_2;
27908 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27909 }
27910 check_2:
27911
27912 if (argc == 2) {
27913 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27914 }
27915
27916 fail:
27917 Py_INCREF(Py_NotImplemented);
27918 return Py_NotImplemented;
27919 }
27920
27921
27922 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27923 PyObject *resultobj = 0;
27924 wxDateTime *arg1 = (wxDateTime *) 0 ;
27925 wxDateTime *arg2 = (wxDateTime *) 0 ;
27926 bool result;
27927 void *argp1 = 0 ;
27928 int res1 = 0 ;
27929 void *argp2 = 0 ;
27930 int res2 = 0 ;
27931 PyObject * obj0 = 0 ;
27932 PyObject * obj1 = 0 ;
27933 char * kwnames[] = {
27934 (char *) "self",(char *) "other", NULL
27935 };
27936
27937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27939 if (!SWIG_IsOK(res1)) {
27940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27941 }
27942 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27943 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27944 if (!SWIG_IsOK(res2)) {
27945 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27946 }
27947 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27948 {
27949 PyThreadState* __tstate = wxPyBeginAllowThreads();
27950 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27951 wxPyEndAllowThreads(__tstate);
27952 if (PyErr_Occurred()) SWIG_fail;
27953 }
27954 {
27955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27956 }
27957 return resultobj;
27958 fail:
27959 return NULL;
27960 }
27961
27962
27963 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27964 PyObject *resultobj = 0;
27965 wxDateTime *arg1 = (wxDateTime *) 0 ;
27966 wxDateTime *arg2 = (wxDateTime *) 0 ;
27967 bool result;
27968 void *argp1 = 0 ;
27969 int res1 = 0 ;
27970 void *argp2 = 0 ;
27971 int res2 = 0 ;
27972 PyObject * obj0 = 0 ;
27973 PyObject * obj1 = 0 ;
27974 char * kwnames[] = {
27975 (char *) "self",(char *) "other", NULL
27976 };
27977
27978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27980 if (!SWIG_IsOK(res1)) {
27981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27982 }
27983 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27984 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27985 if (!SWIG_IsOK(res2)) {
27986 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27987 }
27988 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27989 {
27990 PyThreadState* __tstate = wxPyBeginAllowThreads();
27991 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
27992 wxPyEndAllowThreads(__tstate);
27993 if (PyErr_Occurred()) SWIG_fail;
27994 }
27995 {
27996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27997 }
27998 return resultobj;
27999 fail:
28000 return NULL;
28001 }
28002
28003
28004 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28005 PyObject *resultobj = 0;
28006 wxDateTime *arg1 = (wxDateTime *) 0 ;
28007 wxDateTime *arg2 = (wxDateTime *) 0 ;
28008 bool result;
28009 void *argp1 = 0 ;
28010 int res1 = 0 ;
28011 void *argp2 = 0 ;
28012 int res2 = 0 ;
28013 PyObject * obj0 = 0 ;
28014 PyObject * obj1 = 0 ;
28015 char * kwnames[] = {
28016 (char *) "self",(char *) "other", NULL
28017 };
28018
28019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28021 if (!SWIG_IsOK(res1)) {
28022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28023 }
28024 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28025 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28026 if (!SWIG_IsOK(res2)) {
28027 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28028 }
28029 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28030 {
28031 PyThreadState* __tstate = wxPyBeginAllowThreads();
28032 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
28033 wxPyEndAllowThreads(__tstate);
28034 if (PyErr_Occurred()) SWIG_fail;
28035 }
28036 {
28037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28038 }
28039 return resultobj;
28040 fail:
28041 return NULL;
28042 }
28043
28044
28045 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28046 PyObject *resultobj = 0;
28047 wxDateTime *arg1 = (wxDateTime *) 0 ;
28048 wxDateTime *arg2 = (wxDateTime *) 0 ;
28049 bool result;
28050 void *argp1 = 0 ;
28051 int res1 = 0 ;
28052 void *argp2 = 0 ;
28053 int res2 = 0 ;
28054 PyObject * obj0 = 0 ;
28055 PyObject * obj1 = 0 ;
28056 char * kwnames[] = {
28057 (char *) "self",(char *) "other", NULL
28058 };
28059
28060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28062 if (!SWIG_IsOK(res1)) {
28063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28064 }
28065 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28066 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28067 if (!SWIG_IsOK(res2)) {
28068 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28069 }
28070 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28071 {
28072 PyThreadState* __tstate = wxPyBeginAllowThreads();
28073 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
28074 wxPyEndAllowThreads(__tstate);
28075 if (PyErr_Occurred()) SWIG_fail;
28076 }
28077 {
28078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28079 }
28080 return resultobj;
28081 fail:
28082 return NULL;
28083 }
28084
28085
28086 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28087 PyObject *resultobj = 0;
28088 wxDateTime *arg1 = (wxDateTime *) 0 ;
28089 wxDateTime *arg2 = (wxDateTime *) 0 ;
28090 bool result;
28091 void *argp1 = 0 ;
28092 int res1 = 0 ;
28093 void *argp2 = 0 ;
28094 int res2 = 0 ;
28095 PyObject * obj0 = 0 ;
28096 PyObject * obj1 = 0 ;
28097 char * kwnames[] = {
28098 (char *) "self",(char *) "other", NULL
28099 };
28100
28101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28103 if (!SWIG_IsOK(res1)) {
28104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28105 }
28106 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28107 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28108 if (!SWIG_IsOK(res2)) {
28109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28110 }
28111 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28112 {
28113 PyThreadState* __tstate = wxPyBeginAllowThreads();
28114 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28115 wxPyEndAllowThreads(__tstate);
28116 if (PyErr_Occurred()) SWIG_fail;
28117 }
28118 {
28119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28120 }
28121 return resultobj;
28122 fail:
28123 return NULL;
28124 }
28125
28126
28127 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28128 PyObject *resultobj = 0;
28129 wxDateTime *arg1 = (wxDateTime *) 0 ;
28130 wxDateTime *arg2 = (wxDateTime *) 0 ;
28131 bool result;
28132 void *argp1 = 0 ;
28133 int res1 = 0 ;
28134 void *argp2 = 0 ;
28135 int res2 = 0 ;
28136 PyObject * obj0 = 0 ;
28137 PyObject * obj1 = 0 ;
28138 char * kwnames[] = {
28139 (char *) "self",(char *) "other", NULL
28140 };
28141
28142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28144 if (!SWIG_IsOK(res1)) {
28145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28146 }
28147 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28148 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28149 if (!SWIG_IsOK(res2)) {
28150 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28151 }
28152 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28153 {
28154 PyThreadState* __tstate = wxPyBeginAllowThreads();
28155 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28156 wxPyEndAllowThreads(__tstate);
28157 if (PyErr_Occurred()) SWIG_fail;
28158 }
28159 {
28160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28161 }
28162 return resultobj;
28163 fail:
28164 return NULL;
28165 }
28166
28167
28168 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28169 PyObject *resultobj = 0;
28170 wxDateTime *arg1 = (wxDateTime *) 0 ;
28171 wxString *arg2 = 0 ;
28172 int result;
28173 void *argp1 = 0 ;
28174 int res1 = 0 ;
28175 bool temp2 = false ;
28176 PyObject * obj0 = 0 ;
28177 PyObject * obj1 = 0 ;
28178 char * kwnames[] = {
28179 (char *) "self",(char *) "date", NULL
28180 };
28181
28182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28184 if (!SWIG_IsOK(res1)) {
28185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28186 }
28187 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28188 {
28189 arg2 = wxString_in_helper(obj1);
28190 if (arg2 == NULL) SWIG_fail;
28191 temp2 = true;
28192 }
28193 {
28194 PyThreadState* __tstate = wxPyBeginAllowThreads();
28195 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28196 wxPyEndAllowThreads(__tstate);
28197 if (PyErr_Occurred()) SWIG_fail;
28198 }
28199 resultobj = SWIG_From_int(static_cast< int >(result));
28200 {
28201 if (temp2)
28202 delete arg2;
28203 }
28204 return resultobj;
28205 fail:
28206 {
28207 if (temp2)
28208 delete arg2;
28209 }
28210 return NULL;
28211 }
28212
28213
28214 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28215 PyObject *resultobj = 0;
28216 wxDateTime *arg1 = (wxDateTime *) 0 ;
28217 wxString *arg2 = 0 ;
28218 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28219 wxString *arg3 = (wxString *) &arg3_defvalue ;
28220 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28221 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28222 int result;
28223 void *argp1 = 0 ;
28224 int res1 = 0 ;
28225 bool temp2 = false ;
28226 bool temp3 = false ;
28227 void *argp4 = 0 ;
28228 int res4 = 0 ;
28229 PyObject * obj0 = 0 ;
28230 PyObject * obj1 = 0 ;
28231 PyObject * obj2 = 0 ;
28232 PyObject * obj3 = 0 ;
28233 char * kwnames[] = {
28234 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28235 };
28236
28237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28239 if (!SWIG_IsOK(res1)) {
28240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28241 }
28242 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28243 {
28244 arg2 = wxString_in_helper(obj1);
28245 if (arg2 == NULL) SWIG_fail;
28246 temp2 = true;
28247 }
28248 if (obj2) {
28249 {
28250 arg3 = wxString_in_helper(obj2);
28251 if (arg3 == NULL) SWIG_fail;
28252 temp3 = true;
28253 }
28254 }
28255 if (obj3) {
28256 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28257 if (!SWIG_IsOK(res4)) {
28258 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28259 }
28260 if (!argp4) {
28261 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28262 }
28263 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28264 }
28265 {
28266 PyThreadState* __tstate = wxPyBeginAllowThreads();
28267 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28268 wxPyEndAllowThreads(__tstate);
28269 if (PyErr_Occurred()) SWIG_fail;
28270 }
28271 resultobj = SWIG_From_int(static_cast< int >(result));
28272 {
28273 if (temp2)
28274 delete arg2;
28275 }
28276 {
28277 if (temp3)
28278 delete arg3;
28279 }
28280 return resultobj;
28281 fail:
28282 {
28283 if (temp2)
28284 delete arg2;
28285 }
28286 {
28287 if (temp3)
28288 delete arg3;
28289 }
28290 return NULL;
28291 }
28292
28293
28294 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28295 PyObject *resultobj = 0;
28296 wxDateTime *arg1 = (wxDateTime *) 0 ;
28297 wxString *arg2 = 0 ;
28298 int result;
28299 void *argp1 = 0 ;
28300 int res1 = 0 ;
28301 bool temp2 = false ;
28302 PyObject * obj0 = 0 ;
28303 PyObject * obj1 = 0 ;
28304 char * kwnames[] = {
28305 (char *) "self",(char *) "datetime", NULL
28306 };
28307
28308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28310 if (!SWIG_IsOK(res1)) {
28311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28312 }
28313 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28314 {
28315 arg2 = wxString_in_helper(obj1);
28316 if (arg2 == NULL) SWIG_fail;
28317 temp2 = true;
28318 }
28319 {
28320 PyThreadState* __tstate = wxPyBeginAllowThreads();
28321 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28322 wxPyEndAllowThreads(__tstate);
28323 if (PyErr_Occurred()) SWIG_fail;
28324 }
28325 resultobj = SWIG_From_int(static_cast< int >(result));
28326 {
28327 if (temp2)
28328 delete arg2;
28329 }
28330 return resultobj;
28331 fail:
28332 {
28333 if (temp2)
28334 delete arg2;
28335 }
28336 return NULL;
28337 }
28338
28339
28340 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28341 PyObject *resultobj = 0;
28342 wxDateTime *arg1 = (wxDateTime *) 0 ;
28343 wxString *arg2 = 0 ;
28344 int result;
28345 void *argp1 = 0 ;
28346 int res1 = 0 ;
28347 bool temp2 = false ;
28348 PyObject * obj0 = 0 ;
28349 PyObject * obj1 = 0 ;
28350 char * kwnames[] = {
28351 (char *) "self",(char *) "date", NULL
28352 };
28353
28354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28356 if (!SWIG_IsOK(res1)) {
28357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28358 }
28359 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28360 {
28361 arg2 = wxString_in_helper(obj1);
28362 if (arg2 == NULL) SWIG_fail;
28363 temp2 = true;
28364 }
28365 {
28366 PyThreadState* __tstate = wxPyBeginAllowThreads();
28367 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28368 wxPyEndAllowThreads(__tstate);
28369 if (PyErr_Occurred()) SWIG_fail;
28370 }
28371 resultobj = SWIG_From_int(static_cast< int >(result));
28372 {
28373 if (temp2)
28374 delete arg2;
28375 }
28376 return resultobj;
28377 fail:
28378 {
28379 if (temp2)
28380 delete arg2;
28381 }
28382 return NULL;
28383 }
28384
28385
28386 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28387 PyObject *resultobj = 0;
28388 wxDateTime *arg1 = (wxDateTime *) 0 ;
28389 wxString *arg2 = 0 ;
28390 int result;
28391 void *argp1 = 0 ;
28392 int res1 = 0 ;
28393 bool temp2 = false ;
28394 PyObject * obj0 = 0 ;
28395 PyObject * obj1 = 0 ;
28396 char * kwnames[] = {
28397 (char *) "self",(char *) "time", NULL
28398 };
28399
28400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28402 if (!SWIG_IsOK(res1)) {
28403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28404 }
28405 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28406 {
28407 arg2 = wxString_in_helper(obj1);
28408 if (arg2 == NULL) SWIG_fail;
28409 temp2 = true;
28410 }
28411 {
28412 PyThreadState* __tstate = wxPyBeginAllowThreads();
28413 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28414 wxPyEndAllowThreads(__tstate);
28415 if (PyErr_Occurred()) SWIG_fail;
28416 }
28417 resultobj = SWIG_From_int(static_cast< int >(result));
28418 {
28419 if (temp2)
28420 delete arg2;
28421 }
28422 return resultobj;
28423 fail:
28424 {
28425 if (temp2)
28426 delete arg2;
28427 }
28428 return NULL;
28429 }
28430
28431
28432 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28433 PyObject *resultobj = 0;
28434 wxDateTime *arg1 = (wxDateTime *) 0 ;
28435 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28436 wxString *arg2 = (wxString *) &arg2_defvalue ;
28437 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28438 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28439 wxString result;
28440 void *argp1 = 0 ;
28441 int res1 = 0 ;
28442 bool temp2 = false ;
28443 bool temp3 = false ;
28444 PyObject * obj0 = 0 ;
28445 PyObject * obj1 = 0 ;
28446 PyObject * obj2 = 0 ;
28447 char * kwnames[] = {
28448 (char *) "self",(char *) "format",(char *) "tz", NULL
28449 };
28450
28451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28453 if (!SWIG_IsOK(res1)) {
28454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28455 }
28456 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28457 if (obj1) {
28458 {
28459 arg2 = wxString_in_helper(obj1);
28460 if (arg2 == NULL) SWIG_fail;
28461 temp2 = true;
28462 }
28463 }
28464 if (obj2) {
28465 {
28466 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28467 temp3 = true;
28468 }
28469 }
28470 {
28471 PyThreadState* __tstate = wxPyBeginAllowThreads();
28472 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28473 wxPyEndAllowThreads(__tstate);
28474 if (PyErr_Occurred()) SWIG_fail;
28475 }
28476 {
28477 #if wxUSE_UNICODE
28478 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28479 #else
28480 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28481 #endif
28482 }
28483 {
28484 if (temp2)
28485 delete arg2;
28486 }
28487 {
28488 if (temp3) delete arg3;
28489 }
28490 return resultobj;
28491 fail:
28492 {
28493 if (temp2)
28494 delete arg2;
28495 }
28496 {
28497 if (temp3) delete arg3;
28498 }
28499 return NULL;
28500 }
28501
28502
28503 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28504 PyObject *resultobj = 0;
28505 wxDateTime *arg1 = (wxDateTime *) 0 ;
28506 wxString result;
28507 void *argp1 = 0 ;
28508 int res1 = 0 ;
28509 PyObject *swig_obj[1] ;
28510
28511 if (!args) SWIG_fail;
28512 swig_obj[0] = args;
28513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28514 if (!SWIG_IsOK(res1)) {
28515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28516 }
28517 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28518 {
28519 PyThreadState* __tstate = wxPyBeginAllowThreads();
28520 result = ((wxDateTime const *)arg1)->FormatDate();
28521 wxPyEndAllowThreads(__tstate);
28522 if (PyErr_Occurred()) SWIG_fail;
28523 }
28524 {
28525 #if wxUSE_UNICODE
28526 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28527 #else
28528 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28529 #endif
28530 }
28531 return resultobj;
28532 fail:
28533 return NULL;
28534 }
28535
28536
28537 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28538 PyObject *resultobj = 0;
28539 wxDateTime *arg1 = (wxDateTime *) 0 ;
28540 wxString result;
28541 void *argp1 = 0 ;
28542 int res1 = 0 ;
28543 PyObject *swig_obj[1] ;
28544
28545 if (!args) SWIG_fail;
28546 swig_obj[0] = args;
28547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28548 if (!SWIG_IsOK(res1)) {
28549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28550 }
28551 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28552 {
28553 PyThreadState* __tstate = wxPyBeginAllowThreads();
28554 result = ((wxDateTime const *)arg1)->FormatTime();
28555 wxPyEndAllowThreads(__tstate);
28556 if (PyErr_Occurred()) SWIG_fail;
28557 }
28558 {
28559 #if wxUSE_UNICODE
28560 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28561 #else
28562 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28563 #endif
28564 }
28565 return resultobj;
28566 fail:
28567 return NULL;
28568 }
28569
28570
28571 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28572 PyObject *resultobj = 0;
28573 wxDateTime *arg1 = (wxDateTime *) 0 ;
28574 wxString result;
28575 void *argp1 = 0 ;
28576 int res1 = 0 ;
28577 PyObject *swig_obj[1] ;
28578
28579 if (!args) SWIG_fail;
28580 swig_obj[0] = args;
28581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28582 if (!SWIG_IsOK(res1)) {
28583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28584 }
28585 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28586 {
28587 PyThreadState* __tstate = wxPyBeginAllowThreads();
28588 result = ((wxDateTime const *)arg1)->FormatISODate();
28589 wxPyEndAllowThreads(__tstate);
28590 if (PyErr_Occurred()) SWIG_fail;
28591 }
28592 {
28593 #if wxUSE_UNICODE
28594 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28595 #else
28596 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28597 #endif
28598 }
28599 return resultobj;
28600 fail:
28601 return NULL;
28602 }
28603
28604
28605 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28606 PyObject *resultobj = 0;
28607 wxDateTime *arg1 = (wxDateTime *) 0 ;
28608 wxString result;
28609 void *argp1 = 0 ;
28610 int res1 = 0 ;
28611 PyObject *swig_obj[1] ;
28612
28613 if (!args) SWIG_fail;
28614 swig_obj[0] = args;
28615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28616 if (!SWIG_IsOK(res1)) {
28617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28618 }
28619 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28620 {
28621 PyThreadState* __tstate = wxPyBeginAllowThreads();
28622 result = ((wxDateTime const *)arg1)->FormatISOTime();
28623 wxPyEndAllowThreads(__tstate);
28624 if (PyErr_Occurred()) SWIG_fail;
28625 }
28626 {
28627 #if wxUSE_UNICODE
28628 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28629 #else
28630 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28631 #endif
28632 }
28633 return resultobj;
28634 fail:
28635 return NULL;
28636 }
28637
28638
28639 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28640 PyObject *obj;
28641 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28642 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28643 return SWIG_Py_Void();
28644 }
28645
28646 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28647 return SWIG_Python_InitShadowInstance(args);
28648 }
28649
28650 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28651 PyObject *resultobj = 0;
28652 long arg1 ;
28653 wxTimeSpan result;
28654 long val1 ;
28655 int ecode1 = 0 ;
28656 PyObject * obj0 = 0 ;
28657 char * kwnames[] = {
28658 (char *) "ms", NULL
28659 };
28660
28661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28662 ecode1 = SWIG_AsVal_long(obj0, &val1);
28663 if (!SWIG_IsOK(ecode1)) {
28664 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28665 }
28666 arg1 = static_cast< long >(val1);
28667 {
28668 PyThreadState* __tstate = wxPyBeginAllowThreads();
28669 result = wxTimeSpan::Milliseconds(arg1);
28670 wxPyEndAllowThreads(__tstate);
28671 if (PyErr_Occurred()) SWIG_fail;
28672 }
28673 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28674 return resultobj;
28675 fail:
28676 return NULL;
28677 }
28678
28679
28680 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28681 PyObject *resultobj = 0;
28682 wxTimeSpan result;
28683
28684 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28685 {
28686 PyThreadState* __tstate = wxPyBeginAllowThreads();
28687 result = wxTimeSpan::Millisecond();
28688 wxPyEndAllowThreads(__tstate);
28689 if (PyErr_Occurred()) SWIG_fail;
28690 }
28691 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28692 return resultobj;
28693 fail:
28694 return NULL;
28695 }
28696
28697
28698 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28699 PyObject *resultobj = 0;
28700 long arg1 ;
28701 wxTimeSpan result;
28702 long val1 ;
28703 int ecode1 = 0 ;
28704 PyObject * obj0 = 0 ;
28705 char * kwnames[] = {
28706 (char *) "sec", NULL
28707 };
28708
28709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28710 ecode1 = SWIG_AsVal_long(obj0, &val1);
28711 if (!SWIG_IsOK(ecode1)) {
28712 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28713 }
28714 arg1 = static_cast< long >(val1);
28715 {
28716 PyThreadState* __tstate = wxPyBeginAllowThreads();
28717 result = wxTimeSpan::Seconds(arg1);
28718 wxPyEndAllowThreads(__tstate);
28719 if (PyErr_Occurred()) SWIG_fail;
28720 }
28721 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28722 return resultobj;
28723 fail:
28724 return NULL;
28725 }
28726
28727
28728 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28729 PyObject *resultobj = 0;
28730 wxTimeSpan result;
28731
28732 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28733 {
28734 PyThreadState* __tstate = wxPyBeginAllowThreads();
28735 result = wxTimeSpan::Second();
28736 wxPyEndAllowThreads(__tstate);
28737 if (PyErr_Occurred()) SWIG_fail;
28738 }
28739 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28740 return resultobj;
28741 fail:
28742 return NULL;
28743 }
28744
28745
28746 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28747 PyObject *resultobj = 0;
28748 long arg1 ;
28749 wxTimeSpan result;
28750 long val1 ;
28751 int ecode1 = 0 ;
28752 PyObject * obj0 = 0 ;
28753 char * kwnames[] = {
28754 (char *) "min", NULL
28755 };
28756
28757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28758 ecode1 = SWIG_AsVal_long(obj0, &val1);
28759 if (!SWIG_IsOK(ecode1)) {
28760 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28761 }
28762 arg1 = static_cast< long >(val1);
28763 {
28764 PyThreadState* __tstate = wxPyBeginAllowThreads();
28765 result = wxTimeSpan::Minutes(arg1);
28766 wxPyEndAllowThreads(__tstate);
28767 if (PyErr_Occurred()) SWIG_fail;
28768 }
28769 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28770 return resultobj;
28771 fail:
28772 return NULL;
28773 }
28774
28775
28776 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28777 PyObject *resultobj = 0;
28778 wxTimeSpan result;
28779
28780 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28781 {
28782 PyThreadState* __tstate = wxPyBeginAllowThreads();
28783 result = wxTimeSpan::Minute();
28784 wxPyEndAllowThreads(__tstate);
28785 if (PyErr_Occurred()) SWIG_fail;
28786 }
28787 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28788 return resultobj;
28789 fail:
28790 return NULL;
28791 }
28792
28793
28794 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28795 PyObject *resultobj = 0;
28796 long arg1 ;
28797 wxTimeSpan result;
28798 long val1 ;
28799 int ecode1 = 0 ;
28800 PyObject * obj0 = 0 ;
28801 char * kwnames[] = {
28802 (char *) "hours", NULL
28803 };
28804
28805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28806 ecode1 = SWIG_AsVal_long(obj0, &val1);
28807 if (!SWIG_IsOK(ecode1)) {
28808 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28809 }
28810 arg1 = static_cast< long >(val1);
28811 {
28812 PyThreadState* __tstate = wxPyBeginAllowThreads();
28813 result = wxTimeSpan::Hours(arg1);
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28818 return resultobj;
28819 fail:
28820 return NULL;
28821 }
28822
28823
28824 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28825 PyObject *resultobj = 0;
28826 wxTimeSpan result;
28827
28828 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28829 {
28830 PyThreadState* __tstate = wxPyBeginAllowThreads();
28831 result = wxTimeSpan::Hour();
28832 wxPyEndAllowThreads(__tstate);
28833 if (PyErr_Occurred()) SWIG_fail;
28834 }
28835 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28836 return resultobj;
28837 fail:
28838 return NULL;
28839 }
28840
28841
28842 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28843 PyObject *resultobj = 0;
28844 long arg1 ;
28845 wxTimeSpan result;
28846 long val1 ;
28847 int ecode1 = 0 ;
28848 PyObject * obj0 = 0 ;
28849 char * kwnames[] = {
28850 (char *) "days", NULL
28851 };
28852
28853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28854 ecode1 = SWIG_AsVal_long(obj0, &val1);
28855 if (!SWIG_IsOK(ecode1)) {
28856 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28857 }
28858 arg1 = static_cast< long >(val1);
28859 {
28860 PyThreadState* __tstate = wxPyBeginAllowThreads();
28861 result = wxTimeSpan::Days(arg1);
28862 wxPyEndAllowThreads(__tstate);
28863 if (PyErr_Occurred()) SWIG_fail;
28864 }
28865 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28866 return resultobj;
28867 fail:
28868 return NULL;
28869 }
28870
28871
28872 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28873 PyObject *resultobj = 0;
28874 wxTimeSpan result;
28875
28876 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28877 {
28878 PyThreadState* __tstate = wxPyBeginAllowThreads();
28879 result = wxTimeSpan::Day();
28880 wxPyEndAllowThreads(__tstate);
28881 if (PyErr_Occurred()) SWIG_fail;
28882 }
28883 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28884 return resultobj;
28885 fail:
28886 return NULL;
28887 }
28888
28889
28890 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28891 PyObject *resultobj = 0;
28892 long arg1 ;
28893 wxTimeSpan result;
28894 long val1 ;
28895 int ecode1 = 0 ;
28896 PyObject * obj0 = 0 ;
28897 char * kwnames[] = {
28898 (char *) "days", NULL
28899 };
28900
28901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28902 ecode1 = SWIG_AsVal_long(obj0, &val1);
28903 if (!SWIG_IsOK(ecode1)) {
28904 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28905 }
28906 arg1 = static_cast< long >(val1);
28907 {
28908 PyThreadState* __tstate = wxPyBeginAllowThreads();
28909 result = wxTimeSpan::Weeks(arg1);
28910 wxPyEndAllowThreads(__tstate);
28911 if (PyErr_Occurred()) SWIG_fail;
28912 }
28913 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28914 return resultobj;
28915 fail:
28916 return NULL;
28917 }
28918
28919
28920 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28921 PyObject *resultobj = 0;
28922 wxTimeSpan result;
28923
28924 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28925 {
28926 PyThreadState* __tstate = wxPyBeginAllowThreads();
28927 result = wxTimeSpan::Week();
28928 wxPyEndAllowThreads(__tstate);
28929 if (PyErr_Occurred()) SWIG_fail;
28930 }
28931 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28932 return resultobj;
28933 fail:
28934 return NULL;
28935 }
28936
28937
28938 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28939 PyObject *resultobj = 0;
28940 long arg1 = (long) 0 ;
28941 long arg2 = (long) 0 ;
28942 long arg3 = (long) 0 ;
28943 long arg4 = (long) 0 ;
28944 wxTimeSpan *result = 0 ;
28945 long val1 ;
28946 int ecode1 = 0 ;
28947 long val2 ;
28948 int ecode2 = 0 ;
28949 long val3 ;
28950 int ecode3 = 0 ;
28951 long val4 ;
28952 int ecode4 = 0 ;
28953 PyObject * obj0 = 0 ;
28954 PyObject * obj1 = 0 ;
28955 PyObject * obj2 = 0 ;
28956 PyObject * obj3 = 0 ;
28957 char * kwnames[] = {
28958 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28959 };
28960
28961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28962 if (obj0) {
28963 ecode1 = SWIG_AsVal_long(obj0, &val1);
28964 if (!SWIG_IsOK(ecode1)) {
28965 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28966 }
28967 arg1 = static_cast< long >(val1);
28968 }
28969 if (obj1) {
28970 ecode2 = SWIG_AsVal_long(obj1, &val2);
28971 if (!SWIG_IsOK(ecode2)) {
28972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28973 }
28974 arg2 = static_cast< long >(val2);
28975 }
28976 if (obj2) {
28977 ecode3 = SWIG_AsVal_long(obj2, &val3);
28978 if (!SWIG_IsOK(ecode3)) {
28979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28980 }
28981 arg3 = static_cast< long >(val3);
28982 }
28983 if (obj3) {
28984 ecode4 = SWIG_AsVal_long(obj3, &val4);
28985 if (!SWIG_IsOK(ecode4)) {
28986 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28987 }
28988 arg4 = static_cast< long >(val4);
28989 }
28990 {
28991 PyThreadState* __tstate = wxPyBeginAllowThreads();
28992 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
28993 wxPyEndAllowThreads(__tstate);
28994 if (PyErr_Occurred()) SWIG_fail;
28995 }
28996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
28997 return resultobj;
28998 fail:
28999 return NULL;
29000 }
29001
29002
29003 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29004 PyObject *resultobj = 0;
29005 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29006 void *argp1 = 0 ;
29007 int res1 = 0 ;
29008 PyObject *swig_obj[1] ;
29009
29010 if (!args) SWIG_fail;
29011 swig_obj[0] = args;
29012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29013 if (!SWIG_IsOK(res1)) {
29014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29015 }
29016 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29017 {
29018 PyThreadState* __tstate = wxPyBeginAllowThreads();
29019 delete arg1;
29020
29021 wxPyEndAllowThreads(__tstate);
29022 if (PyErr_Occurred()) SWIG_fail;
29023 }
29024 resultobj = SWIG_Py_Void();
29025 return resultobj;
29026 fail:
29027 return NULL;
29028 }
29029
29030
29031 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29032 PyObject *resultobj = 0;
29033 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29034 wxTimeSpan *arg2 = 0 ;
29035 wxTimeSpan *result = 0 ;
29036 void *argp1 = 0 ;
29037 int res1 = 0 ;
29038 void *argp2 = 0 ;
29039 int res2 = 0 ;
29040 PyObject * obj0 = 0 ;
29041 PyObject * obj1 = 0 ;
29042 char * kwnames[] = {
29043 (char *) "self",(char *) "diff", NULL
29044 };
29045
29046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29048 if (!SWIG_IsOK(res1)) {
29049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29050 }
29051 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29052 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29053 if (!SWIG_IsOK(res2)) {
29054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29055 }
29056 if (!argp2) {
29057 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29058 }
29059 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29060 {
29061 PyThreadState* __tstate = wxPyBeginAllowThreads();
29062 {
29063 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
29064 result = (wxTimeSpan *) &_result_ref;
29065 }
29066 wxPyEndAllowThreads(__tstate);
29067 if (PyErr_Occurred()) SWIG_fail;
29068 }
29069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29070 return resultobj;
29071 fail:
29072 return NULL;
29073 }
29074
29075
29076 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29077 PyObject *resultobj = 0;
29078 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29079 wxTimeSpan *arg2 = 0 ;
29080 wxTimeSpan *result = 0 ;
29081 void *argp1 = 0 ;
29082 int res1 = 0 ;
29083 void *argp2 = 0 ;
29084 int res2 = 0 ;
29085 PyObject * obj0 = 0 ;
29086 PyObject * obj1 = 0 ;
29087 char * kwnames[] = {
29088 (char *) "self",(char *) "diff", NULL
29089 };
29090
29091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29093 if (!SWIG_IsOK(res1)) {
29094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29095 }
29096 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29097 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29098 if (!SWIG_IsOK(res2)) {
29099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29100 }
29101 if (!argp2) {
29102 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29103 }
29104 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29105 {
29106 PyThreadState* __tstate = wxPyBeginAllowThreads();
29107 {
29108 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29109 result = (wxTimeSpan *) &_result_ref;
29110 }
29111 wxPyEndAllowThreads(__tstate);
29112 if (PyErr_Occurred()) SWIG_fail;
29113 }
29114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29115 return resultobj;
29116 fail:
29117 return NULL;
29118 }
29119
29120
29121 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29122 PyObject *resultobj = 0;
29123 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29124 int arg2 ;
29125 wxTimeSpan *result = 0 ;
29126 void *argp1 = 0 ;
29127 int res1 = 0 ;
29128 int val2 ;
29129 int ecode2 = 0 ;
29130 PyObject * obj0 = 0 ;
29131 PyObject * obj1 = 0 ;
29132 char * kwnames[] = {
29133 (char *) "self",(char *) "n", NULL
29134 };
29135
29136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29138 if (!SWIG_IsOK(res1)) {
29139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29140 }
29141 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29142 ecode2 = SWIG_AsVal_int(obj1, &val2);
29143 if (!SWIG_IsOK(ecode2)) {
29144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29145 }
29146 arg2 = static_cast< int >(val2);
29147 {
29148 PyThreadState* __tstate = wxPyBeginAllowThreads();
29149 {
29150 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29151 result = (wxTimeSpan *) &_result_ref;
29152 }
29153 wxPyEndAllowThreads(__tstate);
29154 if (PyErr_Occurred()) SWIG_fail;
29155 }
29156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29157 return resultobj;
29158 fail:
29159 return NULL;
29160 }
29161
29162
29163 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29164 PyObject *resultobj = 0;
29165 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29166 wxTimeSpan *result = 0 ;
29167 void *argp1 = 0 ;
29168 int res1 = 0 ;
29169 PyObject *swig_obj[1] ;
29170
29171 if (!args) SWIG_fail;
29172 swig_obj[0] = args;
29173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29174 if (!SWIG_IsOK(res1)) {
29175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29176 }
29177 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29178 {
29179 PyThreadState* __tstate = wxPyBeginAllowThreads();
29180 {
29181 wxTimeSpan &_result_ref = (arg1)->Neg();
29182 result = (wxTimeSpan *) &_result_ref;
29183 }
29184 wxPyEndAllowThreads(__tstate);
29185 if (PyErr_Occurred()) SWIG_fail;
29186 }
29187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29188 return resultobj;
29189 fail:
29190 return NULL;
29191 }
29192
29193
29194 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29195 PyObject *resultobj = 0;
29196 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29197 wxTimeSpan result;
29198 void *argp1 = 0 ;
29199 int res1 = 0 ;
29200 PyObject *swig_obj[1] ;
29201
29202 if (!args) SWIG_fail;
29203 swig_obj[0] = args;
29204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29205 if (!SWIG_IsOK(res1)) {
29206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29207 }
29208 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29209 {
29210 PyThreadState* __tstate = wxPyBeginAllowThreads();
29211 result = ((wxTimeSpan const *)arg1)->Abs();
29212 wxPyEndAllowThreads(__tstate);
29213 if (PyErr_Occurred()) SWIG_fail;
29214 }
29215 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29216 return resultobj;
29217 fail:
29218 return NULL;
29219 }
29220
29221
29222 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29223 PyObject *resultobj = 0;
29224 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29225 wxTimeSpan *arg2 = 0 ;
29226 wxTimeSpan *result = 0 ;
29227 void *argp1 = 0 ;
29228 int res1 = 0 ;
29229 void *argp2 = 0 ;
29230 int res2 = 0 ;
29231 PyObject * obj0 = 0 ;
29232 PyObject * obj1 = 0 ;
29233 char * kwnames[] = {
29234 (char *) "self",(char *) "diff", NULL
29235 };
29236
29237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29239 if (!SWIG_IsOK(res1)) {
29240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29241 }
29242 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29243 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29244 if (!SWIG_IsOK(res2)) {
29245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29246 }
29247 if (!argp2) {
29248 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29249 }
29250 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29251 {
29252 PyThreadState* __tstate = wxPyBeginAllowThreads();
29253 {
29254 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29255 result = (wxTimeSpan *) &_result_ref;
29256 }
29257 wxPyEndAllowThreads(__tstate);
29258 if (PyErr_Occurred()) SWIG_fail;
29259 }
29260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29261 return resultobj;
29262 fail:
29263 return NULL;
29264 }
29265
29266
29267 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29268 PyObject *resultobj = 0;
29269 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29270 wxTimeSpan *arg2 = 0 ;
29271 wxTimeSpan *result = 0 ;
29272 void *argp1 = 0 ;
29273 int res1 = 0 ;
29274 void *argp2 = 0 ;
29275 int res2 = 0 ;
29276 PyObject * obj0 = 0 ;
29277 PyObject * obj1 = 0 ;
29278 char * kwnames[] = {
29279 (char *) "self",(char *) "diff", NULL
29280 };
29281
29282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29284 if (!SWIG_IsOK(res1)) {
29285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29286 }
29287 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29288 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29289 if (!SWIG_IsOK(res2)) {
29290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29291 }
29292 if (!argp2) {
29293 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29294 }
29295 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29296 {
29297 PyThreadState* __tstate = wxPyBeginAllowThreads();
29298 {
29299 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29300 result = (wxTimeSpan *) &_result_ref;
29301 }
29302 wxPyEndAllowThreads(__tstate);
29303 if (PyErr_Occurred()) SWIG_fail;
29304 }
29305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29306 return resultobj;
29307 fail:
29308 return NULL;
29309 }
29310
29311
29312 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29313 PyObject *resultobj = 0;
29314 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29315 int arg2 ;
29316 wxTimeSpan *result = 0 ;
29317 void *argp1 = 0 ;
29318 int res1 = 0 ;
29319 int val2 ;
29320 int ecode2 = 0 ;
29321 PyObject * obj0 = 0 ;
29322 PyObject * obj1 = 0 ;
29323 char * kwnames[] = {
29324 (char *) "self",(char *) "n", NULL
29325 };
29326
29327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29329 if (!SWIG_IsOK(res1)) {
29330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29331 }
29332 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29333 ecode2 = SWIG_AsVal_int(obj1, &val2);
29334 if (!SWIG_IsOK(ecode2)) {
29335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29336 }
29337 arg2 = static_cast< int >(val2);
29338 {
29339 PyThreadState* __tstate = wxPyBeginAllowThreads();
29340 {
29341 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29342 result = (wxTimeSpan *) &_result_ref;
29343 }
29344 wxPyEndAllowThreads(__tstate);
29345 if (PyErr_Occurred()) SWIG_fail;
29346 }
29347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29348 return resultobj;
29349 fail:
29350 return NULL;
29351 }
29352
29353
29354 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29355 PyObject *resultobj = 0;
29356 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29357 wxTimeSpan *result = 0 ;
29358 void *argp1 = 0 ;
29359 int res1 = 0 ;
29360 PyObject *swig_obj[1] ;
29361
29362 if (!args) SWIG_fail;
29363 swig_obj[0] = args;
29364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29365 if (!SWIG_IsOK(res1)) {
29366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29367 }
29368 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29369 {
29370 PyThreadState* __tstate = wxPyBeginAllowThreads();
29371 {
29372 wxTimeSpan &_result_ref = (arg1)->operator -();
29373 result = (wxTimeSpan *) &_result_ref;
29374 }
29375 wxPyEndAllowThreads(__tstate);
29376 if (PyErr_Occurred()) SWIG_fail;
29377 }
29378 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29379 return resultobj;
29380 fail:
29381 return NULL;
29382 }
29383
29384
29385 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29386 PyObject *resultobj = 0;
29387 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29388 wxTimeSpan *arg2 = 0 ;
29389 wxTimeSpan result;
29390 void *argp1 = 0 ;
29391 int res1 = 0 ;
29392 void *argp2 = 0 ;
29393 int res2 = 0 ;
29394 PyObject * obj0 = 0 ;
29395 PyObject * obj1 = 0 ;
29396 char * kwnames[] = {
29397 (char *) "self",(char *) "other", NULL
29398 };
29399
29400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29402 if (!SWIG_IsOK(res1)) {
29403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29404 }
29405 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29406 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29407 if (!SWIG_IsOK(res2)) {
29408 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29409 }
29410 if (!argp2) {
29411 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29412 }
29413 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29414 {
29415 PyThreadState* __tstate = wxPyBeginAllowThreads();
29416 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29417 wxPyEndAllowThreads(__tstate);
29418 if (PyErr_Occurred()) SWIG_fail;
29419 }
29420 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29421 return resultobj;
29422 fail:
29423 return NULL;
29424 }
29425
29426
29427 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29428 PyObject *resultobj = 0;
29429 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29430 wxTimeSpan *arg2 = 0 ;
29431 wxTimeSpan result;
29432 void *argp1 = 0 ;
29433 int res1 = 0 ;
29434 void *argp2 = 0 ;
29435 int res2 = 0 ;
29436 PyObject * obj0 = 0 ;
29437 PyObject * obj1 = 0 ;
29438 char * kwnames[] = {
29439 (char *) "self",(char *) "other", NULL
29440 };
29441
29442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29444 if (!SWIG_IsOK(res1)) {
29445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29446 }
29447 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29448 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29449 if (!SWIG_IsOK(res2)) {
29450 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29451 }
29452 if (!argp2) {
29453 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29454 }
29455 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29456 {
29457 PyThreadState* __tstate = wxPyBeginAllowThreads();
29458 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29459 wxPyEndAllowThreads(__tstate);
29460 if (PyErr_Occurred()) SWIG_fail;
29461 }
29462 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29463 return resultobj;
29464 fail:
29465 return NULL;
29466 }
29467
29468
29469 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29470 PyObject *resultobj = 0;
29471 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29472 int arg2 ;
29473 wxTimeSpan result;
29474 void *argp1 = 0 ;
29475 int res1 = 0 ;
29476 int val2 ;
29477 int ecode2 = 0 ;
29478 PyObject * obj0 = 0 ;
29479 PyObject * obj1 = 0 ;
29480 char * kwnames[] = {
29481 (char *) "self",(char *) "n", NULL
29482 };
29483
29484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29486 if (!SWIG_IsOK(res1)) {
29487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29488 }
29489 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29490 ecode2 = SWIG_AsVal_int(obj1, &val2);
29491 if (!SWIG_IsOK(ecode2)) {
29492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29493 }
29494 arg2 = static_cast< int >(val2);
29495 {
29496 PyThreadState* __tstate = wxPyBeginAllowThreads();
29497 result = wxTimeSpan___mul__(arg1,arg2);
29498 wxPyEndAllowThreads(__tstate);
29499 if (PyErr_Occurred()) SWIG_fail;
29500 }
29501 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29502 return resultobj;
29503 fail:
29504 return NULL;
29505 }
29506
29507
29508 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29509 PyObject *resultobj = 0;
29510 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29511 int arg2 ;
29512 wxTimeSpan result;
29513 void *argp1 = 0 ;
29514 int res1 = 0 ;
29515 int val2 ;
29516 int ecode2 = 0 ;
29517 PyObject * obj0 = 0 ;
29518 PyObject * obj1 = 0 ;
29519 char * kwnames[] = {
29520 (char *) "self",(char *) "n", NULL
29521 };
29522
29523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29525 if (!SWIG_IsOK(res1)) {
29526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29527 }
29528 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29529 ecode2 = SWIG_AsVal_int(obj1, &val2);
29530 if (!SWIG_IsOK(ecode2)) {
29531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29532 }
29533 arg2 = static_cast< int >(val2);
29534 {
29535 PyThreadState* __tstate = wxPyBeginAllowThreads();
29536 result = wxTimeSpan___rmul__(arg1,arg2);
29537 wxPyEndAllowThreads(__tstate);
29538 if (PyErr_Occurred()) SWIG_fail;
29539 }
29540 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29541 return resultobj;
29542 fail:
29543 return NULL;
29544 }
29545
29546
29547 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29548 PyObject *resultobj = 0;
29549 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29550 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29551 bool result;
29552 void *argp1 = 0 ;
29553 int res1 = 0 ;
29554 void *argp2 = 0 ;
29555 int res2 = 0 ;
29556 PyObject * obj0 = 0 ;
29557 PyObject * obj1 = 0 ;
29558 char * kwnames[] = {
29559 (char *) "self",(char *) "other", NULL
29560 };
29561
29562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29564 if (!SWIG_IsOK(res1)) {
29565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29566 }
29567 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29568 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29569 if (!SWIG_IsOK(res2)) {
29570 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29571 }
29572 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29573 {
29574 PyThreadState* __tstate = wxPyBeginAllowThreads();
29575 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29576 wxPyEndAllowThreads(__tstate);
29577 if (PyErr_Occurred()) SWIG_fail;
29578 }
29579 {
29580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29581 }
29582 return resultobj;
29583 fail:
29584 return NULL;
29585 }
29586
29587
29588 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29589 PyObject *resultobj = 0;
29590 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29591 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29592 bool result;
29593 void *argp1 = 0 ;
29594 int res1 = 0 ;
29595 void *argp2 = 0 ;
29596 int res2 = 0 ;
29597 PyObject * obj0 = 0 ;
29598 PyObject * obj1 = 0 ;
29599 char * kwnames[] = {
29600 (char *) "self",(char *) "other", NULL
29601 };
29602
29603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29605 if (!SWIG_IsOK(res1)) {
29606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29607 }
29608 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29609 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29610 if (!SWIG_IsOK(res2)) {
29611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29612 }
29613 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29614 {
29615 PyThreadState* __tstate = wxPyBeginAllowThreads();
29616 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29617 wxPyEndAllowThreads(__tstate);
29618 if (PyErr_Occurred()) SWIG_fail;
29619 }
29620 {
29621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29622 }
29623 return resultobj;
29624 fail:
29625 return NULL;
29626 }
29627
29628
29629 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29630 PyObject *resultobj = 0;
29631 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29632 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29633 bool result;
29634 void *argp1 = 0 ;
29635 int res1 = 0 ;
29636 void *argp2 = 0 ;
29637 int res2 = 0 ;
29638 PyObject * obj0 = 0 ;
29639 PyObject * obj1 = 0 ;
29640 char * kwnames[] = {
29641 (char *) "self",(char *) "other", NULL
29642 };
29643
29644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29646 if (!SWIG_IsOK(res1)) {
29647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29648 }
29649 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29650 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29651 if (!SWIG_IsOK(res2)) {
29652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29653 }
29654 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29655 {
29656 PyThreadState* __tstate = wxPyBeginAllowThreads();
29657 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29658 wxPyEndAllowThreads(__tstate);
29659 if (PyErr_Occurred()) SWIG_fail;
29660 }
29661 {
29662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29663 }
29664 return resultobj;
29665 fail:
29666 return NULL;
29667 }
29668
29669
29670 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29671 PyObject *resultobj = 0;
29672 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29673 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29674 bool result;
29675 void *argp1 = 0 ;
29676 int res1 = 0 ;
29677 void *argp2 = 0 ;
29678 int res2 = 0 ;
29679 PyObject * obj0 = 0 ;
29680 PyObject * obj1 = 0 ;
29681 char * kwnames[] = {
29682 (char *) "self",(char *) "other", NULL
29683 };
29684
29685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29687 if (!SWIG_IsOK(res1)) {
29688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29689 }
29690 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29691 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29692 if (!SWIG_IsOK(res2)) {
29693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29694 }
29695 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29696 {
29697 PyThreadState* __tstate = wxPyBeginAllowThreads();
29698 result = (bool)wxTimeSpan___ge__(arg1,(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___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29712 PyObject *resultobj = 0;
29713 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29714 wxTimeSpan *arg2 = (wxTimeSpan *) 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 *) "other", NULL
29724 };
29725
29726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",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___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
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___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29735 }
29736 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29737 {
29738 PyThreadState* __tstate = wxPyBeginAllowThreads();
29739 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29740 wxPyEndAllowThreads(__tstate);
29741 if (PyErr_Occurred()) SWIG_fail;
29742 }
29743 {
29744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29745 }
29746 return resultobj;
29747 fail:
29748 return NULL;
29749 }
29750
29751
29752 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29753 PyObject *resultobj = 0;
29754 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29755 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29756 bool result;
29757 void *argp1 = 0 ;
29758 int res1 = 0 ;
29759 void *argp2 = 0 ;
29760 int res2 = 0 ;
29761 PyObject * obj0 = 0 ;
29762 PyObject * obj1 = 0 ;
29763 char * kwnames[] = {
29764 (char *) "self",(char *) "other", NULL
29765 };
29766
29767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29769 if (!SWIG_IsOK(res1)) {
29770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29771 }
29772 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29773 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29774 if (!SWIG_IsOK(res2)) {
29775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29776 }
29777 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29778 {
29779 PyThreadState* __tstate = wxPyBeginAllowThreads();
29780 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29781 wxPyEndAllowThreads(__tstate);
29782 if (PyErr_Occurred()) SWIG_fail;
29783 }
29784 {
29785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29786 }
29787 return resultobj;
29788 fail:
29789 return NULL;
29790 }
29791
29792
29793 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29794 PyObject *resultobj = 0;
29795 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29796 bool result;
29797 void *argp1 = 0 ;
29798 int res1 = 0 ;
29799 PyObject *swig_obj[1] ;
29800
29801 if (!args) SWIG_fail;
29802 swig_obj[0] = args;
29803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29804 if (!SWIG_IsOK(res1)) {
29805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29806 }
29807 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29808 {
29809 PyThreadState* __tstate = wxPyBeginAllowThreads();
29810 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29811 wxPyEndAllowThreads(__tstate);
29812 if (PyErr_Occurred()) SWIG_fail;
29813 }
29814 {
29815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29816 }
29817 return resultobj;
29818 fail:
29819 return NULL;
29820 }
29821
29822
29823 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29824 PyObject *resultobj = 0;
29825 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29826 bool result;
29827 void *argp1 = 0 ;
29828 int res1 = 0 ;
29829 PyObject *swig_obj[1] ;
29830
29831 if (!args) SWIG_fail;
29832 swig_obj[0] = args;
29833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29834 if (!SWIG_IsOK(res1)) {
29835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29836 }
29837 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29838 {
29839 PyThreadState* __tstate = wxPyBeginAllowThreads();
29840 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29841 wxPyEndAllowThreads(__tstate);
29842 if (PyErr_Occurred()) SWIG_fail;
29843 }
29844 {
29845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29846 }
29847 return resultobj;
29848 fail:
29849 return NULL;
29850 }
29851
29852
29853 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29854 PyObject *resultobj = 0;
29855 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29856 bool result;
29857 void *argp1 = 0 ;
29858 int res1 = 0 ;
29859 PyObject *swig_obj[1] ;
29860
29861 if (!args) SWIG_fail;
29862 swig_obj[0] = args;
29863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29864 if (!SWIG_IsOK(res1)) {
29865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29866 }
29867 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29868 {
29869 PyThreadState* __tstate = wxPyBeginAllowThreads();
29870 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29871 wxPyEndAllowThreads(__tstate);
29872 if (PyErr_Occurred()) SWIG_fail;
29873 }
29874 {
29875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29876 }
29877 return resultobj;
29878 fail:
29879 return NULL;
29880 }
29881
29882
29883 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29884 PyObject *resultobj = 0;
29885 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29886 wxTimeSpan *arg2 = 0 ;
29887 bool result;
29888 void *argp1 = 0 ;
29889 int res1 = 0 ;
29890 void *argp2 = 0 ;
29891 int res2 = 0 ;
29892 PyObject * obj0 = 0 ;
29893 PyObject * obj1 = 0 ;
29894 char * kwnames[] = {
29895 (char *) "self",(char *) "ts", NULL
29896 };
29897
29898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29900 if (!SWIG_IsOK(res1)) {
29901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29902 }
29903 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29904 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29905 if (!SWIG_IsOK(res2)) {
29906 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29907 }
29908 if (!argp2) {
29909 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29910 }
29911 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29912 {
29913 PyThreadState* __tstate = wxPyBeginAllowThreads();
29914 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29915 wxPyEndAllowThreads(__tstate);
29916 if (PyErr_Occurred()) SWIG_fail;
29917 }
29918 {
29919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29920 }
29921 return resultobj;
29922 fail:
29923 return NULL;
29924 }
29925
29926
29927 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29928 PyObject *resultobj = 0;
29929 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29930 wxTimeSpan *arg2 = 0 ;
29931 bool result;
29932 void *argp1 = 0 ;
29933 int res1 = 0 ;
29934 void *argp2 = 0 ;
29935 int res2 = 0 ;
29936 PyObject * obj0 = 0 ;
29937 PyObject * obj1 = 0 ;
29938 char * kwnames[] = {
29939 (char *) "self",(char *) "ts", NULL
29940 };
29941
29942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29944 if (!SWIG_IsOK(res1)) {
29945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29946 }
29947 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29948 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29949 if (!SWIG_IsOK(res2)) {
29950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29951 }
29952 if (!argp2) {
29953 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29954 }
29955 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29956 {
29957 PyThreadState* __tstate = wxPyBeginAllowThreads();
29958 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29959 wxPyEndAllowThreads(__tstate);
29960 if (PyErr_Occurred()) SWIG_fail;
29961 }
29962 {
29963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29964 }
29965 return resultobj;
29966 fail:
29967 return NULL;
29968 }
29969
29970
29971 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29972 PyObject *resultobj = 0;
29973 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29974 wxTimeSpan *arg2 = 0 ;
29975 bool result;
29976 void *argp1 = 0 ;
29977 int res1 = 0 ;
29978 void *argp2 = 0 ;
29979 int res2 = 0 ;
29980 PyObject * obj0 = 0 ;
29981 PyObject * obj1 = 0 ;
29982 char * kwnames[] = {
29983 (char *) "self",(char *) "t", NULL
29984 };
29985
29986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29988 if (!SWIG_IsOK(res1)) {
29989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29990 }
29991 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29992 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29993 if (!SWIG_IsOK(res2)) {
29994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29995 }
29996 if (!argp2) {
29997 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29998 }
29999 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
30000 {
30001 PyThreadState* __tstate = wxPyBeginAllowThreads();
30002 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
30003 wxPyEndAllowThreads(__tstate);
30004 if (PyErr_Occurred()) SWIG_fail;
30005 }
30006 {
30007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30008 }
30009 return resultobj;
30010 fail:
30011 return NULL;
30012 }
30013
30014
30015 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30016 PyObject *resultobj = 0;
30017 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30018 int result;
30019 void *argp1 = 0 ;
30020 int res1 = 0 ;
30021 PyObject *swig_obj[1] ;
30022
30023 if (!args) SWIG_fail;
30024 swig_obj[0] = args;
30025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30026 if (!SWIG_IsOK(res1)) {
30027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30028 }
30029 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30030 {
30031 PyThreadState* __tstate = wxPyBeginAllowThreads();
30032 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
30033 wxPyEndAllowThreads(__tstate);
30034 if (PyErr_Occurred()) SWIG_fail;
30035 }
30036 resultobj = SWIG_From_int(static_cast< int >(result));
30037 return resultobj;
30038 fail:
30039 return NULL;
30040 }
30041
30042
30043 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30044 PyObject *resultobj = 0;
30045 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30046 int result;
30047 void *argp1 = 0 ;
30048 int res1 = 0 ;
30049 PyObject *swig_obj[1] ;
30050
30051 if (!args) SWIG_fail;
30052 swig_obj[0] = args;
30053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30054 if (!SWIG_IsOK(res1)) {
30055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30056 }
30057 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30058 {
30059 PyThreadState* __tstate = wxPyBeginAllowThreads();
30060 result = (int)((wxTimeSpan const *)arg1)->GetDays();
30061 wxPyEndAllowThreads(__tstate);
30062 if (PyErr_Occurred()) SWIG_fail;
30063 }
30064 resultobj = SWIG_From_int(static_cast< int >(result));
30065 return resultobj;
30066 fail:
30067 return NULL;
30068 }
30069
30070
30071 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30072 PyObject *resultobj = 0;
30073 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30074 int result;
30075 void *argp1 = 0 ;
30076 int res1 = 0 ;
30077 PyObject *swig_obj[1] ;
30078
30079 if (!args) SWIG_fail;
30080 swig_obj[0] = args;
30081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30082 if (!SWIG_IsOK(res1)) {
30083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30084 }
30085 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30086 {
30087 PyThreadState* __tstate = wxPyBeginAllowThreads();
30088 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30089 wxPyEndAllowThreads(__tstate);
30090 if (PyErr_Occurred()) SWIG_fail;
30091 }
30092 resultobj = SWIG_From_int(static_cast< int >(result));
30093 return resultobj;
30094 fail:
30095 return NULL;
30096 }
30097
30098
30099 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30100 PyObject *resultobj = 0;
30101 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30102 int result;
30103 void *argp1 = 0 ;
30104 int res1 = 0 ;
30105 PyObject *swig_obj[1] ;
30106
30107 if (!args) SWIG_fail;
30108 swig_obj[0] = args;
30109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30110 if (!SWIG_IsOK(res1)) {
30111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30112 }
30113 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30114 {
30115 PyThreadState* __tstate = wxPyBeginAllowThreads();
30116 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30117 wxPyEndAllowThreads(__tstate);
30118 if (PyErr_Occurred()) SWIG_fail;
30119 }
30120 resultobj = SWIG_From_int(static_cast< int >(result));
30121 return resultobj;
30122 fail:
30123 return NULL;
30124 }
30125
30126
30127 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30128 PyObject *resultobj = 0;
30129 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30130 wxLongLong result;
30131 void *argp1 = 0 ;
30132 int res1 = 0 ;
30133 PyObject *swig_obj[1] ;
30134
30135 if (!args) SWIG_fail;
30136 swig_obj[0] = args;
30137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30138 if (!SWIG_IsOK(res1)) {
30139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30140 }
30141 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30142 {
30143 PyThreadState* __tstate = wxPyBeginAllowThreads();
30144 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30145 wxPyEndAllowThreads(__tstate);
30146 if (PyErr_Occurred()) SWIG_fail;
30147 }
30148 {
30149 PyObject *hi, *lo, *shifter, *shifted;
30150 hi = PyLong_FromLong( (&result)->GetHi() );
30151 lo = PyLong_FromLong( (&result)->GetLo() );
30152 shifter = PyLong_FromLong(32);
30153 shifted = PyNumber_Lshift(hi, shifter);
30154 resultobj = PyNumber_Or(shifted, lo);
30155 Py_DECREF(hi);
30156 Py_DECREF(lo);
30157 Py_DECREF(shifter);
30158 Py_DECREF(shifted);
30159 }
30160 return resultobj;
30161 fail:
30162 return NULL;
30163 }
30164
30165
30166 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30167 PyObject *resultobj = 0;
30168 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30169 wxLongLong result;
30170 void *argp1 = 0 ;
30171 int res1 = 0 ;
30172 PyObject *swig_obj[1] ;
30173
30174 if (!args) SWIG_fail;
30175 swig_obj[0] = args;
30176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30177 if (!SWIG_IsOK(res1)) {
30178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30179 }
30180 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30181 {
30182 PyThreadState* __tstate = wxPyBeginAllowThreads();
30183 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30184 wxPyEndAllowThreads(__tstate);
30185 if (PyErr_Occurred()) SWIG_fail;
30186 }
30187 {
30188 PyObject *hi, *lo, *shifter, *shifted;
30189 hi = PyLong_FromLong( (&result)->GetHi() );
30190 lo = PyLong_FromLong( (&result)->GetLo() );
30191 shifter = PyLong_FromLong(32);
30192 shifted = PyNumber_Lshift(hi, shifter);
30193 resultobj = PyNumber_Or(shifted, lo);
30194 Py_DECREF(hi);
30195 Py_DECREF(lo);
30196 Py_DECREF(shifter);
30197 Py_DECREF(shifted);
30198 }
30199 return resultobj;
30200 fail:
30201 return NULL;
30202 }
30203
30204
30205 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30206 PyObject *resultobj = 0;
30207 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30208 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30209 wxString *arg2 = (wxString *) &arg2_defvalue ;
30210 wxString result;
30211 void *argp1 = 0 ;
30212 int res1 = 0 ;
30213 bool temp2 = false ;
30214 PyObject * obj0 = 0 ;
30215 PyObject * obj1 = 0 ;
30216 char * kwnames[] = {
30217 (char *) "self",(char *) "format", NULL
30218 };
30219
30220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30222 if (!SWIG_IsOK(res1)) {
30223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30224 }
30225 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30226 if (obj1) {
30227 {
30228 arg2 = wxString_in_helper(obj1);
30229 if (arg2 == NULL) SWIG_fail;
30230 temp2 = true;
30231 }
30232 }
30233 {
30234 PyThreadState* __tstate = wxPyBeginAllowThreads();
30235 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30236 wxPyEndAllowThreads(__tstate);
30237 if (PyErr_Occurred()) SWIG_fail;
30238 }
30239 {
30240 #if wxUSE_UNICODE
30241 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30242 #else
30243 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30244 #endif
30245 }
30246 {
30247 if (temp2)
30248 delete arg2;
30249 }
30250 return resultobj;
30251 fail:
30252 {
30253 if (temp2)
30254 delete arg2;
30255 }
30256 return NULL;
30257 }
30258
30259
30260 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30261 PyObject *obj;
30262 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30263 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30264 return SWIG_Py_Void();
30265 }
30266
30267 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30268 return SWIG_Python_InitShadowInstance(args);
30269 }
30270
30271 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30272 PyObject *resultobj = 0;
30273 int arg1 = (int) 0 ;
30274 int arg2 = (int) 0 ;
30275 int arg3 = (int) 0 ;
30276 int arg4 = (int) 0 ;
30277 wxDateSpan *result = 0 ;
30278 int val1 ;
30279 int ecode1 = 0 ;
30280 int val2 ;
30281 int ecode2 = 0 ;
30282 int val3 ;
30283 int ecode3 = 0 ;
30284 int val4 ;
30285 int ecode4 = 0 ;
30286 PyObject * obj0 = 0 ;
30287 PyObject * obj1 = 0 ;
30288 PyObject * obj2 = 0 ;
30289 PyObject * obj3 = 0 ;
30290 char * kwnames[] = {
30291 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30292 };
30293
30294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30295 if (obj0) {
30296 ecode1 = SWIG_AsVal_int(obj0, &val1);
30297 if (!SWIG_IsOK(ecode1)) {
30298 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30299 }
30300 arg1 = static_cast< int >(val1);
30301 }
30302 if (obj1) {
30303 ecode2 = SWIG_AsVal_int(obj1, &val2);
30304 if (!SWIG_IsOK(ecode2)) {
30305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30306 }
30307 arg2 = static_cast< int >(val2);
30308 }
30309 if (obj2) {
30310 ecode3 = SWIG_AsVal_int(obj2, &val3);
30311 if (!SWIG_IsOK(ecode3)) {
30312 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30313 }
30314 arg3 = static_cast< int >(val3);
30315 }
30316 if (obj3) {
30317 ecode4 = SWIG_AsVal_int(obj3, &val4);
30318 if (!SWIG_IsOK(ecode4)) {
30319 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30320 }
30321 arg4 = static_cast< int >(val4);
30322 }
30323 {
30324 PyThreadState* __tstate = wxPyBeginAllowThreads();
30325 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30326 wxPyEndAllowThreads(__tstate);
30327 if (PyErr_Occurred()) SWIG_fail;
30328 }
30329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30330 return resultobj;
30331 fail:
30332 return NULL;
30333 }
30334
30335
30336 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30337 PyObject *resultobj = 0;
30338 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30339 void *argp1 = 0 ;
30340 int res1 = 0 ;
30341 PyObject *swig_obj[1] ;
30342
30343 if (!args) SWIG_fail;
30344 swig_obj[0] = args;
30345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30346 if (!SWIG_IsOK(res1)) {
30347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30348 }
30349 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30350 {
30351 PyThreadState* __tstate = wxPyBeginAllowThreads();
30352 delete arg1;
30353
30354 wxPyEndAllowThreads(__tstate);
30355 if (PyErr_Occurred()) SWIG_fail;
30356 }
30357 resultobj = SWIG_Py_Void();
30358 return resultobj;
30359 fail:
30360 return NULL;
30361 }
30362
30363
30364 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30365 PyObject *resultobj = 0;
30366 int arg1 ;
30367 wxDateSpan result;
30368 int val1 ;
30369 int ecode1 = 0 ;
30370 PyObject * obj0 = 0 ;
30371 char * kwnames[] = {
30372 (char *) "days", NULL
30373 };
30374
30375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30376 ecode1 = SWIG_AsVal_int(obj0, &val1);
30377 if (!SWIG_IsOK(ecode1)) {
30378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30379 }
30380 arg1 = static_cast< int >(val1);
30381 {
30382 PyThreadState* __tstate = wxPyBeginAllowThreads();
30383 result = wxDateSpan::Days(arg1);
30384 wxPyEndAllowThreads(__tstate);
30385 if (PyErr_Occurred()) SWIG_fail;
30386 }
30387 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30388 return resultobj;
30389 fail:
30390 return NULL;
30391 }
30392
30393
30394 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30395 PyObject *resultobj = 0;
30396 wxDateSpan result;
30397
30398 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30399 {
30400 PyThreadState* __tstate = wxPyBeginAllowThreads();
30401 result = wxDateSpan::Day();
30402 wxPyEndAllowThreads(__tstate);
30403 if (PyErr_Occurred()) SWIG_fail;
30404 }
30405 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30406 return resultobj;
30407 fail:
30408 return NULL;
30409 }
30410
30411
30412 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30413 PyObject *resultobj = 0;
30414 int arg1 ;
30415 wxDateSpan result;
30416 int val1 ;
30417 int ecode1 = 0 ;
30418 PyObject * obj0 = 0 ;
30419 char * kwnames[] = {
30420 (char *) "weeks", NULL
30421 };
30422
30423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30424 ecode1 = SWIG_AsVal_int(obj0, &val1);
30425 if (!SWIG_IsOK(ecode1)) {
30426 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30427 }
30428 arg1 = static_cast< int >(val1);
30429 {
30430 PyThreadState* __tstate = wxPyBeginAllowThreads();
30431 result = wxDateSpan::Weeks(arg1);
30432 wxPyEndAllowThreads(__tstate);
30433 if (PyErr_Occurred()) SWIG_fail;
30434 }
30435 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30436 return resultobj;
30437 fail:
30438 return NULL;
30439 }
30440
30441
30442 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30443 PyObject *resultobj = 0;
30444 wxDateSpan result;
30445
30446 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30447 {
30448 PyThreadState* __tstate = wxPyBeginAllowThreads();
30449 result = wxDateSpan::Week();
30450 wxPyEndAllowThreads(__tstate);
30451 if (PyErr_Occurred()) SWIG_fail;
30452 }
30453 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30454 return resultobj;
30455 fail:
30456 return NULL;
30457 }
30458
30459
30460 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30461 PyObject *resultobj = 0;
30462 int arg1 ;
30463 wxDateSpan result;
30464 int val1 ;
30465 int ecode1 = 0 ;
30466 PyObject * obj0 = 0 ;
30467 char * kwnames[] = {
30468 (char *) "mon", NULL
30469 };
30470
30471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30472 ecode1 = SWIG_AsVal_int(obj0, &val1);
30473 if (!SWIG_IsOK(ecode1)) {
30474 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30475 }
30476 arg1 = static_cast< int >(val1);
30477 {
30478 PyThreadState* __tstate = wxPyBeginAllowThreads();
30479 result = wxDateSpan::Months(arg1);
30480 wxPyEndAllowThreads(__tstate);
30481 if (PyErr_Occurred()) SWIG_fail;
30482 }
30483 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30484 return resultobj;
30485 fail:
30486 return NULL;
30487 }
30488
30489
30490 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30491 PyObject *resultobj = 0;
30492 wxDateSpan result;
30493
30494 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30495 {
30496 PyThreadState* __tstate = wxPyBeginAllowThreads();
30497 result = wxDateSpan::Month();
30498 wxPyEndAllowThreads(__tstate);
30499 if (PyErr_Occurred()) SWIG_fail;
30500 }
30501 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30502 return resultobj;
30503 fail:
30504 return NULL;
30505 }
30506
30507
30508 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30509 PyObject *resultobj = 0;
30510 int arg1 ;
30511 wxDateSpan result;
30512 int val1 ;
30513 int ecode1 = 0 ;
30514 PyObject * obj0 = 0 ;
30515 char * kwnames[] = {
30516 (char *) "years", NULL
30517 };
30518
30519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30520 ecode1 = SWIG_AsVal_int(obj0, &val1);
30521 if (!SWIG_IsOK(ecode1)) {
30522 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30523 }
30524 arg1 = static_cast< int >(val1);
30525 {
30526 PyThreadState* __tstate = wxPyBeginAllowThreads();
30527 result = wxDateSpan::Years(arg1);
30528 wxPyEndAllowThreads(__tstate);
30529 if (PyErr_Occurred()) SWIG_fail;
30530 }
30531 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30532 return resultobj;
30533 fail:
30534 return NULL;
30535 }
30536
30537
30538 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30539 PyObject *resultobj = 0;
30540 wxDateSpan result;
30541
30542 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30543 {
30544 PyThreadState* __tstate = wxPyBeginAllowThreads();
30545 result = wxDateSpan::Year();
30546 wxPyEndAllowThreads(__tstate);
30547 if (PyErr_Occurred()) SWIG_fail;
30548 }
30549 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30550 return resultobj;
30551 fail:
30552 return NULL;
30553 }
30554
30555
30556 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30557 PyObject *resultobj = 0;
30558 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30559 int arg2 ;
30560 wxDateSpan *result = 0 ;
30561 void *argp1 = 0 ;
30562 int res1 = 0 ;
30563 int val2 ;
30564 int ecode2 = 0 ;
30565 PyObject * obj0 = 0 ;
30566 PyObject * obj1 = 0 ;
30567 char * kwnames[] = {
30568 (char *) "self",(char *) "n", NULL
30569 };
30570
30571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30573 if (!SWIG_IsOK(res1)) {
30574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30575 }
30576 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30577 ecode2 = SWIG_AsVal_int(obj1, &val2);
30578 if (!SWIG_IsOK(ecode2)) {
30579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30580 }
30581 arg2 = static_cast< int >(val2);
30582 {
30583 PyThreadState* __tstate = wxPyBeginAllowThreads();
30584 {
30585 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30586 result = (wxDateSpan *) &_result_ref;
30587 }
30588 wxPyEndAllowThreads(__tstate);
30589 if (PyErr_Occurred()) SWIG_fail;
30590 }
30591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30592 return resultobj;
30593 fail:
30594 return NULL;
30595 }
30596
30597
30598 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30599 PyObject *resultobj = 0;
30600 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30601 int arg2 ;
30602 wxDateSpan *result = 0 ;
30603 void *argp1 = 0 ;
30604 int res1 = 0 ;
30605 int val2 ;
30606 int ecode2 = 0 ;
30607 PyObject * obj0 = 0 ;
30608 PyObject * obj1 = 0 ;
30609 char * kwnames[] = {
30610 (char *) "self",(char *) "n", NULL
30611 };
30612
30613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30615 if (!SWIG_IsOK(res1)) {
30616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30617 }
30618 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30619 ecode2 = SWIG_AsVal_int(obj1, &val2);
30620 if (!SWIG_IsOK(ecode2)) {
30621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30622 }
30623 arg2 = static_cast< int >(val2);
30624 {
30625 PyThreadState* __tstate = wxPyBeginAllowThreads();
30626 {
30627 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30628 result = (wxDateSpan *) &_result_ref;
30629 }
30630 wxPyEndAllowThreads(__tstate);
30631 if (PyErr_Occurred()) SWIG_fail;
30632 }
30633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30634 return resultobj;
30635 fail:
30636 return NULL;
30637 }
30638
30639
30640 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30641 PyObject *resultobj = 0;
30642 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30643 int arg2 ;
30644 wxDateSpan *result = 0 ;
30645 void *argp1 = 0 ;
30646 int res1 = 0 ;
30647 int val2 ;
30648 int ecode2 = 0 ;
30649 PyObject * obj0 = 0 ;
30650 PyObject * obj1 = 0 ;
30651 char * kwnames[] = {
30652 (char *) "self",(char *) "n", NULL
30653 };
30654
30655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30657 if (!SWIG_IsOK(res1)) {
30658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30659 }
30660 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30661 ecode2 = SWIG_AsVal_int(obj1, &val2);
30662 if (!SWIG_IsOK(ecode2)) {
30663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30664 }
30665 arg2 = static_cast< int >(val2);
30666 {
30667 PyThreadState* __tstate = wxPyBeginAllowThreads();
30668 {
30669 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30670 result = (wxDateSpan *) &_result_ref;
30671 }
30672 wxPyEndAllowThreads(__tstate);
30673 if (PyErr_Occurred()) SWIG_fail;
30674 }
30675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30676 return resultobj;
30677 fail:
30678 return NULL;
30679 }
30680
30681
30682 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30683 PyObject *resultobj = 0;
30684 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30685 int arg2 ;
30686 wxDateSpan *result = 0 ;
30687 void *argp1 = 0 ;
30688 int res1 = 0 ;
30689 int val2 ;
30690 int ecode2 = 0 ;
30691 PyObject * obj0 = 0 ;
30692 PyObject * obj1 = 0 ;
30693 char * kwnames[] = {
30694 (char *) "self",(char *) "n", NULL
30695 };
30696
30697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30699 if (!SWIG_IsOK(res1)) {
30700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30701 }
30702 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30703 ecode2 = SWIG_AsVal_int(obj1, &val2);
30704 if (!SWIG_IsOK(ecode2)) {
30705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30706 }
30707 arg2 = static_cast< int >(val2);
30708 {
30709 PyThreadState* __tstate = wxPyBeginAllowThreads();
30710 {
30711 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30712 result = (wxDateSpan *) &_result_ref;
30713 }
30714 wxPyEndAllowThreads(__tstate);
30715 if (PyErr_Occurred()) SWIG_fail;
30716 }
30717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30718 return resultobj;
30719 fail:
30720 return NULL;
30721 }
30722
30723
30724 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30725 PyObject *resultobj = 0;
30726 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30727 int result;
30728 void *argp1 = 0 ;
30729 int res1 = 0 ;
30730 PyObject *swig_obj[1] ;
30731
30732 if (!args) SWIG_fail;
30733 swig_obj[0] = args;
30734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30735 if (!SWIG_IsOK(res1)) {
30736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30737 }
30738 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30739 {
30740 PyThreadState* __tstate = wxPyBeginAllowThreads();
30741 result = (int)((wxDateSpan const *)arg1)->GetYears();
30742 wxPyEndAllowThreads(__tstate);
30743 if (PyErr_Occurred()) SWIG_fail;
30744 }
30745 resultobj = SWIG_From_int(static_cast< int >(result));
30746 return resultobj;
30747 fail:
30748 return NULL;
30749 }
30750
30751
30752 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30753 PyObject *resultobj = 0;
30754 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30755 int result;
30756 void *argp1 = 0 ;
30757 int res1 = 0 ;
30758 PyObject *swig_obj[1] ;
30759
30760 if (!args) SWIG_fail;
30761 swig_obj[0] = args;
30762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30763 if (!SWIG_IsOK(res1)) {
30764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30765 }
30766 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30767 {
30768 PyThreadState* __tstate = wxPyBeginAllowThreads();
30769 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30770 wxPyEndAllowThreads(__tstate);
30771 if (PyErr_Occurred()) SWIG_fail;
30772 }
30773 resultobj = SWIG_From_int(static_cast< int >(result));
30774 return resultobj;
30775 fail:
30776 return NULL;
30777 }
30778
30779
30780 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30781 PyObject *resultobj = 0;
30782 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30783 int result;
30784 void *argp1 = 0 ;
30785 int res1 = 0 ;
30786 PyObject *swig_obj[1] ;
30787
30788 if (!args) SWIG_fail;
30789 swig_obj[0] = args;
30790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30791 if (!SWIG_IsOK(res1)) {
30792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30793 }
30794 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30795 {
30796 PyThreadState* __tstate = wxPyBeginAllowThreads();
30797 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30798 wxPyEndAllowThreads(__tstate);
30799 if (PyErr_Occurred()) SWIG_fail;
30800 }
30801 resultobj = SWIG_From_int(static_cast< int >(result));
30802 return resultobj;
30803 fail:
30804 return NULL;
30805 }
30806
30807
30808 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30809 PyObject *resultobj = 0;
30810 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30811 int result;
30812 void *argp1 = 0 ;
30813 int res1 = 0 ;
30814 PyObject *swig_obj[1] ;
30815
30816 if (!args) SWIG_fail;
30817 swig_obj[0] = args;
30818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30819 if (!SWIG_IsOK(res1)) {
30820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30821 }
30822 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30823 {
30824 PyThreadState* __tstate = wxPyBeginAllowThreads();
30825 result = (int)((wxDateSpan const *)arg1)->GetDays();
30826 wxPyEndAllowThreads(__tstate);
30827 if (PyErr_Occurred()) SWIG_fail;
30828 }
30829 resultobj = SWIG_From_int(static_cast< int >(result));
30830 return resultobj;
30831 fail:
30832 return NULL;
30833 }
30834
30835
30836 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30837 PyObject *resultobj = 0;
30838 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30839 int result;
30840 void *argp1 = 0 ;
30841 int res1 = 0 ;
30842 PyObject *swig_obj[1] ;
30843
30844 if (!args) SWIG_fail;
30845 swig_obj[0] = args;
30846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30847 if (!SWIG_IsOK(res1)) {
30848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30849 }
30850 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30851 {
30852 PyThreadState* __tstate = wxPyBeginAllowThreads();
30853 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30854 wxPyEndAllowThreads(__tstate);
30855 if (PyErr_Occurred()) SWIG_fail;
30856 }
30857 resultobj = SWIG_From_int(static_cast< int >(result));
30858 return resultobj;
30859 fail:
30860 return NULL;
30861 }
30862
30863
30864 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30865 PyObject *resultobj = 0;
30866 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30867 wxDateSpan *arg2 = 0 ;
30868 wxDateSpan *result = 0 ;
30869 void *argp1 = 0 ;
30870 int res1 = 0 ;
30871 void *argp2 = 0 ;
30872 int res2 = 0 ;
30873 PyObject * obj0 = 0 ;
30874 PyObject * obj1 = 0 ;
30875 char * kwnames[] = {
30876 (char *) "self",(char *) "other", NULL
30877 };
30878
30879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30881 if (!SWIG_IsOK(res1)) {
30882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30883 }
30884 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30885 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30886 if (!SWIG_IsOK(res2)) {
30887 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30888 }
30889 if (!argp2) {
30890 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30891 }
30892 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30893 {
30894 PyThreadState* __tstate = wxPyBeginAllowThreads();
30895 {
30896 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30897 result = (wxDateSpan *) &_result_ref;
30898 }
30899 wxPyEndAllowThreads(__tstate);
30900 if (PyErr_Occurred()) SWIG_fail;
30901 }
30902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30903 return resultobj;
30904 fail:
30905 return NULL;
30906 }
30907
30908
30909 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30910 PyObject *resultobj = 0;
30911 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30912 wxDateSpan *arg2 = 0 ;
30913 wxDateSpan *result = 0 ;
30914 void *argp1 = 0 ;
30915 int res1 = 0 ;
30916 void *argp2 = 0 ;
30917 int res2 = 0 ;
30918 PyObject * obj0 = 0 ;
30919 PyObject * obj1 = 0 ;
30920 char * kwnames[] = {
30921 (char *) "self",(char *) "other", NULL
30922 };
30923
30924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30926 if (!SWIG_IsOK(res1)) {
30927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30928 }
30929 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30930 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30931 if (!SWIG_IsOK(res2)) {
30932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30933 }
30934 if (!argp2) {
30935 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30936 }
30937 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30938 {
30939 PyThreadState* __tstate = wxPyBeginAllowThreads();
30940 {
30941 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30942 result = (wxDateSpan *) &_result_ref;
30943 }
30944 wxPyEndAllowThreads(__tstate);
30945 if (PyErr_Occurred()) SWIG_fail;
30946 }
30947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30948 return resultobj;
30949 fail:
30950 return NULL;
30951 }
30952
30953
30954 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30955 PyObject *resultobj = 0;
30956 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30957 wxDateSpan *result = 0 ;
30958 void *argp1 = 0 ;
30959 int res1 = 0 ;
30960 PyObject *swig_obj[1] ;
30961
30962 if (!args) SWIG_fail;
30963 swig_obj[0] = args;
30964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30965 if (!SWIG_IsOK(res1)) {
30966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30967 }
30968 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30969 {
30970 PyThreadState* __tstate = wxPyBeginAllowThreads();
30971 {
30972 wxDateSpan &_result_ref = (arg1)->Neg();
30973 result = (wxDateSpan *) &_result_ref;
30974 }
30975 wxPyEndAllowThreads(__tstate);
30976 if (PyErr_Occurred()) SWIG_fail;
30977 }
30978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30979 return resultobj;
30980 fail:
30981 return NULL;
30982 }
30983
30984
30985 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30986 PyObject *resultobj = 0;
30987 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30988 int arg2 ;
30989 wxDateSpan *result = 0 ;
30990 void *argp1 = 0 ;
30991 int res1 = 0 ;
30992 int val2 ;
30993 int ecode2 = 0 ;
30994 PyObject * obj0 = 0 ;
30995 PyObject * obj1 = 0 ;
30996 char * kwnames[] = {
30997 (char *) "self",(char *) "factor", NULL
30998 };
30999
31000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
31001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31002 if (!SWIG_IsOK(res1)) {
31003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31004 }
31005 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31006 ecode2 = SWIG_AsVal_int(obj1, &val2);
31007 if (!SWIG_IsOK(ecode2)) {
31008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
31009 }
31010 arg2 = static_cast< int >(val2);
31011 {
31012 PyThreadState* __tstate = wxPyBeginAllowThreads();
31013 {
31014 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
31015 result = (wxDateSpan *) &_result_ref;
31016 }
31017 wxPyEndAllowThreads(__tstate);
31018 if (PyErr_Occurred()) SWIG_fail;
31019 }
31020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31021 return resultobj;
31022 fail:
31023 return NULL;
31024 }
31025
31026
31027 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31028 PyObject *resultobj = 0;
31029 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31030 wxDateSpan *arg2 = 0 ;
31031 wxDateSpan *result = 0 ;
31032 void *argp1 = 0 ;
31033 int res1 = 0 ;
31034 void *argp2 = 0 ;
31035 int res2 = 0 ;
31036 PyObject * obj0 = 0 ;
31037 PyObject * obj1 = 0 ;
31038 char * kwnames[] = {
31039 (char *) "self",(char *) "other", NULL
31040 };
31041
31042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
31043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31044 if (!SWIG_IsOK(res1)) {
31045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31046 }
31047 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31048 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31049 if (!SWIG_IsOK(res2)) {
31050 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31051 }
31052 if (!argp2) {
31053 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31054 }
31055 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31056 {
31057 PyThreadState* __tstate = wxPyBeginAllowThreads();
31058 {
31059 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
31060 result = (wxDateSpan *) &_result_ref;
31061 }
31062 wxPyEndAllowThreads(__tstate);
31063 if (PyErr_Occurred()) SWIG_fail;
31064 }
31065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31066 return resultobj;
31067 fail:
31068 return NULL;
31069 }
31070
31071
31072 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31073 PyObject *resultobj = 0;
31074 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31075 wxDateSpan *arg2 = 0 ;
31076 wxDateSpan *result = 0 ;
31077 void *argp1 = 0 ;
31078 int res1 = 0 ;
31079 void *argp2 = 0 ;
31080 int res2 = 0 ;
31081 PyObject * obj0 = 0 ;
31082 PyObject * obj1 = 0 ;
31083 char * kwnames[] = {
31084 (char *) "self",(char *) "other", NULL
31085 };
31086
31087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31089 if (!SWIG_IsOK(res1)) {
31090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31091 }
31092 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31093 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31094 if (!SWIG_IsOK(res2)) {
31095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31096 }
31097 if (!argp2) {
31098 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31099 }
31100 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31101 {
31102 PyThreadState* __tstate = wxPyBeginAllowThreads();
31103 {
31104 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31105 result = (wxDateSpan *) &_result_ref;
31106 }
31107 wxPyEndAllowThreads(__tstate);
31108 if (PyErr_Occurred()) SWIG_fail;
31109 }
31110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31111 return resultobj;
31112 fail:
31113 return NULL;
31114 }
31115
31116
31117 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31118 PyObject *resultobj = 0;
31119 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31120 wxDateSpan *result = 0 ;
31121 void *argp1 = 0 ;
31122 int res1 = 0 ;
31123 PyObject *swig_obj[1] ;
31124
31125 if (!args) SWIG_fail;
31126 swig_obj[0] = args;
31127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31128 if (!SWIG_IsOK(res1)) {
31129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31130 }
31131 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31132 {
31133 PyThreadState* __tstate = wxPyBeginAllowThreads();
31134 {
31135 wxDateSpan &_result_ref = (arg1)->operator -();
31136 result = (wxDateSpan *) &_result_ref;
31137 }
31138 wxPyEndAllowThreads(__tstate);
31139 if (PyErr_Occurred()) SWIG_fail;
31140 }
31141 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31142 return resultobj;
31143 fail:
31144 return NULL;
31145 }
31146
31147
31148 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31149 PyObject *resultobj = 0;
31150 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31151 int arg2 ;
31152 wxDateSpan *result = 0 ;
31153 void *argp1 = 0 ;
31154 int res1 = 0 ;
31155 int val2 ;
31156 int ecode2 = 0 ;
31157 PyObject * obj0 = 0 ;
31158 PyObject * obj1 = 0 ;
31159 char * kwnames[] = {
31160 (char *) "self",(char *) "factor", NULL
31161 };
31162
31163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31165 if (!SWIG_IsOK(res1)) {
31166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31167 }
31168 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31169 ecode2 = SWIG_AsVal_int(obj1, &val2);
31170 if (!SWIG_IsOK(ecode2)) {
31171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31172 }
31173 arg2 = static_cast< int >(val2);
31174 {
31175 PyThreadState* __tstate = wxPyBeginAllowThreads();
31176 {
31177 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31178 result = (wxDateSpan *) &_result_ref;
31179 }
31180 wxPyEndAllowThreads(__tstate);
31181 if (PyErr_Occurred()) SWIG_fail;
31182 }
31183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31184 return resultobj;
31185 fail:
31186 return NULL;
31187 }
31188
31189
31190 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31191 PyObject *resultobj = 0;
31192 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31193 wxDateSpan *arg2 = 0 ;
31194 wxDateSpan result;
31195 void *argp1 = 0 ;
31196 int res1 = 0 ;
31197 void *argp2 = 0 ;
31198 int res2 = 0 ;
31199 PyObject * obj0 = 0 ;
31200 PyObject * obj1 = 0 ;
31201 char * kwnames[] = {
31202 (char *) "self",(char *) "other", NULL
31203 };
31204
31205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31207 if (!SWIG_IsOK(res1)) {
31208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31209 }
31210 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31211 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31212 if (!SWIG_IsOK(res2)) {
31213 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31214 }
31215 if (!argp2) {
31216 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31217 }
31218 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31219 {
31220 PyThreadState* __tstate = wxPyBeginAllowThreads();
31221 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31222 wxPyEndAllowThreads(__tstate);
31223 if (PyErr_Occurred()) SWIG_fail;
31224 }
31225 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31226 return resultobj;
31227 fail:
31228 return NULL;
31229 }
31230
31231
31232 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31233 PyObject *resultobj = 0;
31234 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31235 wxDateSpan *arg2 = 0 ;
31236 wxDateSpan result;
31237 void *argp1 = 0 ;
31238 int res1 = 0 ;
31239 void *argp2 = 0 ;
31240 int res2 = 0 ;
31241 PyObject * obj0 = 0 ;
31242 PyObject * obj1 = 0 ;
31243 char * kwnames[] = {
31244 (char *) "self",(char *) "other", NULL
31245 };
31246
31247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31249 if (!SWIG_IsOK(res1)) {
31250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31251 }
31252 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31253 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31254 if (!SWIG_IsOK(res2)) {
31255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31256 }
31257 if (!argp2) {
31258 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31259 }
31260 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31261 {
31262 PyThreadState* __tstate = wxPyBeginAllowThreads();
31263 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31264 wxPyEndAllowThreads(__tstate);
31265 if (PyErr_Occurred()) SWIG_fail;
31266 }
31267 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31268 return resultobj;
31269 fail:
31270 return NULL;
31271 }
31272
31273
31274 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31275 PyObject *resultobj = 0;
31276 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31277 int arg2 ;
31278 wxDateSpan result;
31279 void *argp1 = 0 ;
31280 int res1 = 0 ;
31281 int val2 ;
31282 int ecode2 = 0 ;
31283 PyObject * obj0 = 0 ;
31284 PyObject * obj1 = 0 ;
31285 char * kwnames[] = {
31286 (char *) "self",(char *) "n", NULL
31287 };
31288
31289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31291 if (!SWIG_IsOK(res1)) {
31292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31293 }
31294 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31295 ecode2 = SWIG_AsVal_int(obj1, &val2);
31296 if (!SWIG_IsOK(ecode2)) {
31297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31298 }
31299 arg2 = static_cast< int >(val2);
31300 {
31301 PyThreadState* __tstate = wxPyBeginAllowThreads();
31302 result = wxDateSpan___mul__(arg1,arg2);
31303 wxPyEndAllowThreads(__tstate);
31304 if (PyErr_Occurred()) SWIG_fail;
31305 }
31306 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31307 return resultobj;
31308 fail:
31309 return NULL;
31310 }
31311
31312
31313 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31314 PyObject *resultobj = 0;
31315 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31316 int arg2 ;
31317 wxDateSpan result;
31318 void *argp1 = 0 ;
31319 int res1 = 0 ;
31320 int val2 ;
31321 int ecode2 = 0 ;
31322 PyObject * obj0 = 0 ;
31323 PyObject * obj1 = 0 ;
31324 char * kwnames[] = {
31325 (char *) "self",(char *) "n", NULL
31326 };
31327
31328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31330 if (!SWIG_IsOK(res1)) {
31331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31332 }
31333 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31334 ecode2 = SWIG_AsVal_int(obj1, &val2);
31335 if (!SWIG_IsOK(ecode2)) {
31336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31337 }
31338 arg2 = static_cast< int >(val2);
31339 {
31340 PyThreadState* __tstate = wxPyBeginAllowThreads();
31341 result = wxDateSpan___rmul__(arg1,arg2);
31342 wxPyEndAllowThreads(__tstate);
31343 if (PyErr_Occurred()) SWIG_fail;
31344 }
31345 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31346 return resultobj;
31347 fail:
31348 return NULL;
31349 }
31350
31351
31352 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31353 PyObject *resultobj = 0;
31354 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31355 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31356 bool result;
31357 void *argp1 = 0 ;
31358 int res1 = 0 ;
31359 void *argp2 = 0 ;
31360 int res2 = 0 ;
31361 PyObject * obj0 = 0 ;
31362 PyObject * obj1 = 0 ;
31363 char * kwnames[] = {
31364 (char *) "self",(char *) "other", NULL
31365 };
31366
31367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31369 if (!SWIG_IsOK(res1)) {
31370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31371 }
31372 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31373 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31374 if (!SWIG_IsOK(res2)) {
31375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31376 }
31377 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31378 {
31379 PyThreadState* __tstate = wxPyBeginAllowThreads();
31380 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31381 wxPyEndAllowThreads(__tstate);
31382 if (PyErr_Occurred()) SWIG_fail;
31383 }
31384 {
31385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31386 }
31387 return resultobj;
31388 fail:
31389 return NULL;
31390 }
31391
31392
31393 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31394 PyObject *resultobj = 0;
31395 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31396 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31397 bool result;
31398 void *argp1 = 0 ;
31399 int res1 = 0 ;
31400 void *argp2 = 0 ;
31401 int res2 = 0 ;
31402 PyObject * obj0 = 0 ;
31403 PyObject * obj1 = 0 ;
31404 char * kwnames[] = {
31405 (char *) "self",(char *) "other", NULL
31406 };
31407
31408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31410 if (!SWIG_IsOK(res1)) {
31411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31412 }
31413 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31414 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31415 if (!SWIG_IsOK(res2)) {
31416 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31417 }
31418 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31419 {
31420 PyThreadState* __tstate = wxPyBeginAllowThreads();
31421 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31422 wxPyEndAllowThreads(__tstate);
31423 if (PyErr_Occurred()) SWIG_fail;
31424 }
31425 {
31426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31427 }
31428 return resultobj;
31429 fail:
31430 return NULL;
31431 }
31432
31433
31434 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31435 PyObject *obj;
31436 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31437 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31438 return SWIG_Py_Void();
31439 }
31440
31441 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31442 return SWIG_Python_InitShadowInstance(args);
31443 }
31444
31445 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31446 PyObject *resultobj = 0;
31447 long result;
31448
31449 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31450 {
31451 PyThreadState* __tstate = wxPyBeginAllowThreads();
31452 result = (long)wxGetLocalTime();
31453 wxPyEndAllowThreads(__tstate);
31454 if (PyErr_Occurred()) SWIG_fail;
31455 }
31456 resultobj = SWIG_From_long(static_cast< long >(result));
31457 return resultobj;
31458 fail:
31459 return NULL;
31460 }
31461
31462
31463 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31464 PyObject *resultobj = 0;
31465 long result;
31466
31467 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31468 {
31469 PyThreadState* __tstate = wxPyBeginAllowThreads();
31470 result = (long)wxGetUTCTime();
31471 wxPyEndAllowThreads(__tstate);
31472 if (PyErr_Occurred()) SWIG_fail;
31473 }
31474 resultobj = SWIG_From_long(static_cast< long >(result));
31475 return resultobj;
31476 fail:
31477 return NULL;
31478 }
31479
31480
31481 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31482 PyObject *resultobj = 0;
31483 long result;
31484
31485 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31486 {
31487 PyThreadState* __tstate = wxPyBeginAllowThreads();
31488 result = (long)wxGetCurrentTime();
31489 wxPyEndAllowThreads(__tstate);
31490 if (PyErr_Occurred()) SWIG_fail;
31491 }
31492 resultobj = SWIG_From_long(static_cast< long >(result));
31493 return resultobj;
31494 fail:
31495 return NULL;
31496 }
31497
31498
31499 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31500 PyObject *resultobj = 0;
31501 wxLongLong result;
31502
31503 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31504 {
31505 PyThreadState* __tstate = wxPyBeginAllowThreads();
31506 result = wxGetLocalTimeMillis();
31507 wxPyEndAllowThreads(__tstate);
31508 if (PyErr_Occurred()) SWIG_fail;
31509 }
31510 {
31511 PyObject *hi, *lo, *shifter, *shifted;
31512 hi = PyLong_FromLong( (&result)->GetHi() );
31513 lo = PyLong_FromLong( (&result)->GetLo() );
31514 shifter = PyLong_FromLong(32);
31515 shifted = PyNumber_Lshift(hi, shifter);
31516 resultobj = PyNumber_Or(shifted, lo);
31517 Py_DECREF(hi);
31518 Py_DECREF(lo);
31519 Py_DECREF(shifter);
31520 Py_DECREF(shifted);
31521 }
31522 return resultobj;
31523 fail:
31524 return NULL;
31525 }
31526
31527
31528 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31529 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31530 return 1;
31531 }
31532
31533
31534 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31535 PyObject *pyobj = 0;
31536
31537 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31538 return pyobj;
31539 }
31540
31541
31542 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31543 PyObject *resultobj = 0;
31544 wxDataFormatId arg1 ;
31545 wxDataFormat *result = 0 ;
31546 int val1 ;
31547 int ecode1 = 0 ;
31548 PyObject * obj0 = 0 ;
31549 char * kwnames[] = {
31550 (char *) "type", NULL
31551 };
31552
31553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31554 ecode1 = SWIG_AsVal_int(obj0, &val1);
31555 if (!SWIG_IsOK(ecode1)) {
31556 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31557 }
31558 arg1 = static_cast< wxDataFormatId >(val1);
31559 {
31560 PyThreadState* __tstate = wxPyBeginAllowThreads();
31561 result = (wxDataFormat *)new wxDataFormat(arg1);
31562 wxPyEndAllowThreads(__tstate);
31563 if (PyErr_Occurred()) SWIG_fail;
31564 }
31565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31566 return resultobj;
31567 fail:
31568 return NULL;
31569 }
31570
31571
31572 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31573 PyObject *resultobj = 0;
31574 wxString *arg1 = 0 ;
31575 wxDataFormat *result = 0 ;
31576 bool temp1 = false ;
31577 PyObject * obj0 = 0 ;
31578 char * kwnames[] = {
31579 (char *) "format", NULL
31580 };
31581
31582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31583 {
31584 arg1 = wxString_in_helper(obj0);
31585 if (arg1 == NULL) SWIG_fail;
31586 temp1 = true;
31587 }
31588 {
31589 PyThreadState* __tstate = wxPyBeginAllowThreads();
31590 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31591 wxPyEndAllowThreads(__tstate);
31592 if (PyErr_Occurred()) SWIG_fail;
31593 }
31594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31595 {
31596 if (temp1)
31597 delete arg1;
31598 }
31599 return resultobj;
31600 fail:
31601 {
31602 if (temp1)
31603 delete arg1;
31604 }
31605 return NULL;
31606 }
31607
31608
31609 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31610 PyObject *resultobj = 0;
31611 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31612 void *argp1 = 0 ;
31613 int res1 = 0 ;
31614 PyObject *swig_obj[1] ;
31615
31616 if (!args) SWIG_fail;
31617 swig_obj[0] = args;
31618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31619 if (!SWIG_IsOK(res1)) {
31620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31621 }
31622 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31623 {
31624 PyThreadState* __tstate = wxPyBeginAllowThreads();
31625 delete arg1;
31626
31627 wxPyEndAllowThreads(__tstate);
31628 if (PyErr_Occurred()) SWIG_fail;
31629 }
31630 resultobj = SWIG_Py_Void();
31631 return resultobj;
31632 fail:
31633 return NULL;
31634 }
31635
31636
31637 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31638 PyObject *resultobj = 0;
31639 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31640 wxDataFormatId arg2 ;
31641 bool result;
31642 void *argp1 = 0 ;
31643 int res1 = 0 ;
31644 int val2 ;
31645 int ecode2 = 0 ;
31646
31647 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31649 if (!SWIG_IsOK(res1)) {
31650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31651 }
31652 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31653 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31654 if (!SWIG_IsOK(ecode2)) {
31655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31656 }
31657 arg2 = static_cast< wxDataFormatId >(val2);
31658 {
31659 PyThreadState* __tstate = wxPyBeginAllowThreads();
31660 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31661 wxPyEndAllowThreads(__tstate);
31662 if (PyErr_Occurred()) SWIG_fail;
31663 }
31664 {
31665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31666 }
31667 return resultobj;
31668 fail:
31669 return NULL;
31670 }
31671
31672
31673 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31674 PyObject *resultobj = 0;
31675 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31676 wxDataFormatId arg2 ;
31677 bool result;
31678 void *argp1 = 0 ;
31679 int res1 = 0 ;
31680 int val2 ;
31681 int ecode2 = 0 ;
31682
31683 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31685 if (!SWIG_IsOK(res1)) {
31686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31687 }
31688 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31689 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31690 if (!SWIG_IsOK(ecode2)) {
31691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31692 }
31693 arg2 = static_cast< wxDataFormatId >(val2);
31694 {
31695 PyThreadState* __tstate = wxPyBeginAllowThreads();
31696 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31697 wxPyEndAllowThreads(__tstate);
31698 if (PyErr_Occurred()) SWIG_fail;
31699 }
31700 {
31701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31702 }
31703 return resultobj;
31704 fail:
31705 return NULL;
31706 }
31707
31708
31709 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31710 PyObject *resultobj = 0;
31711 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31712 wxDataFormat *arg2 = 0 ;
31713 bool result;
31714 void *argp1 = 0 ;
31715 int res1 = 0 ;
31716 void *argp2 = 0 ;
31717 int res2 = 0 ;
31718
31719 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31721 if (!SWIG_IsOK(res1)) {
31722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31723 }
31724 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31725 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31726 if (!SWIG_IsOK(res2)) {
31727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31728 }
31729 if (!argp2) {
31730 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31731 }
31732 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31733 {
31734 PyThreadState* __tstate = wxPyBeginAllowThreads();
31735 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31736 wxPyEndAllowThreads(__tstate);
31737 if (PyErr_Occurred()) SWIG_fail;
31738 }
31739 {
31740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31741 }
31742 return resultobj;
31743 fail:
31744 return NULL;
31745 }
31746
31747
31748 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31749 int argc;
31750 PyObject *argv[3];
31751
31752 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31753 --argc;
31754 if (argc == 2) {
31755 int _v = 0;
31756 {
31757 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31758 _v = SWIG_CheckState(res);
31759 }
31760 if (!_v) goto check_1;
31761 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31762 }
31763 check_1:
31764
31765 if (argc == 2) {
31766 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31767 }
31768
31769 fail:
31770 Py_INCREF(Py_NotImplemented);
31771 return Py_NotImplemented;
31772 }
31773
31774
31775 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31776 PyObject *resultobj = 0;
31777 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31778 wxDataFormat *arg2 = 0 ;
31779 bool result;
31780 void *argp1 = 0 ;
31781 int res1 = 0 ;
31782 void *argp2 = 0 ;
31783 int res2 = 0 ;
31784
31785 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31787 if (!SWIG_IsOK(res1)) {
31788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31789 }
31790 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31791 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31792 if (!SWIG_IsOK(res2)) {
31793 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31794 }
31795 if (!argp2) {
31796 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31797 }
31798 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31799 {
31800 PyThreadState* __tstate = wxPyBeginAllowThreads();
31801 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31802 wxPyEndAllowThreads(__tstate);
31803 if (PyErr_Occurred()) SWIG_fail;
31804 }
31805 {
31806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31807 }
31808 return resultobj;
31809 fail:
31810 return NULL;
31811 }
31812
31813
31814 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31815 int argc;
31816 PyObject *argv[3];
31817
31818 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31819 --argc;
31820 if (argc == 2) {
31821 int _v = 0;
31822 {
31823 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31824 _v = SWIG_CheckState(res);
31825 }
31826 if (!_v) goto check_1;
31827 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31828 }
31829 check_1:
31830
31831 if (argc == 2) {
31832 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31833 }
31834
31835 fail:
31836 Py_INCREF(Py_NotImplemented);
31837 return Py_NotImplemented;
31838 }
31839
31840
31841 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31842 PyObject *resultobj = 0;
31843 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31844 wxDataFormatId arg2 ;
31845 void *argp1 = 0 ;
31846 int res1 = 0 ;
31847 int val2 ;
31848 int ecode2 = 0 ;
31849 PyObject * obj0 = 0 ;
31850 PyObject * obj1 = 0 ;
31851 char * kwnames[] = {
31852 (char *) "self",(char *) "format", NULL
31853 };
31854
31855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31857 if (!SWIG_IsOK(res1)) {
31858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31859 }
31860 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31861 ecode2 = SWIG_AsVal_int(obj1, &val2);
31862 if (!SWIG_IsOK(ecode2)) {
31863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31864 }
31865 arg2 = static_cast< wxDataFormatId >(val2);
31866 {
31867 PyThreadState* __tstate = wxPyBeginAllowThreads();
31868 (arg1)->SetType(arg2);
31869 wxPyEndAllowThreads(__tstate);
31870 if (PyErr_Occurred()) SWIG_fail;
31871 }
31872 resultobj = SWIG_Py_Void();
31873 return resultobj;
31874 fail:
31875 return NULL;
31876 }
31877
31878
31879 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31880 PyObject *resultobj = 0;
31881 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31882 wxDataFormatId result;
31883 void *argp1 = 0 ;
31884 int res1 = 0 ;
31885 PyObject *swig_obj[1] ;
31886
31887 if (!args) SWIG_fail;
31888 swig_obj[0] = args;
31889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31890 if (!SWIG_IsOK(res1)) {
31891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31892 }
31893 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31894 {
31895 PyThreadState* __tstate = wxPyBeginAllowThreads();
31896 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31897 wxPyEndAllowThreads(__tstate);
31898 if (PyErr_Occurred()) SWIG_fail;
31899 }
31900 resultobj = SWIG_From_int(static_cast< int >(result));
31901 return resultobj;
31902 fail:
31903 return NULL;
31904 }
31905
31906
31907 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31908 PyObject *resultobj = 0;
31909 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31910 wxString result;
31911 void *argp1 = 0 ;
31912 int res1 = 0 ;
31913 PyObject *swig_obj[1] ;
31914
31915 if (!args) SWIG_fail;
31916 swig_obj[0] = args;
31917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31918 if (!SWIG_IsOK(res1)) {
31919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31920 }
31921 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31922 {
31923 PyThreadState* __tstate = wxPyBeginAllowThreads();
31924 result = ((wxDataFormat const *)arg1)->GetId();
31925 wxPyEndAllowThreads(__tstate);
31926 if (PyErr_Occurred()) SWIG_fail;
31927 }
31928 {
31929 #if wxUSE_UNICODE
31930 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31931 #else
31932 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31933 #endif
31934 }
31935 return resultobj;
31936 fail:
31937 return NULL;
31938 }
31939
31940
31941 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31942 PyObject *resultobj = 0;
31943 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31944 wxString *arg2 = 0 ;
31945 void *argp1 = 0 ;
31946 int res1 = 0 ;
31947 bool temp2 = false ;
31948 PyObject * obj0 = 0 ;
31949 PyObject * obj1 = 0 ;
31950 char * kwnames[] = {
31951 (char *) "self",(char *) "format", NULL
31952 };
31953
31954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31956 if (!SWIG_IsOK(res1)) {
31957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31958 }
31959 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31960 {
31961 arg2 = wxString_in_helper(obj1);
31962 if (arg2 == NULL) SWIG_fail;
31963 temp2 = true;
31964 }
31965 {
31966 PyThreadState* __tstate = wxPyBeginAllowThreads();
31967 (arg1)->SetId((wxString const &)*arg2);
31968 wxPyEndAllowThreads(__tstate);
31969 if (PyErr_Occurred()) SWIG_fail;
31970 }
31971 resultobj = SWIG_Py_Void();
31972 {
31973 if (temp2)
31974 delete arg2;
31975 }
31976 return resultobj;
31977 fail:
31978 {
31979 if (temp2)
31980 delete arg2;
31981 }
31982 return NULL;
31983 }
31984
31985
31986 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31987 PyObject *obj;
31988 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31989 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
31990 return SWIG_Py_Void();
31991 }
31992
31993 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31994 return SWIG_Python_InitShadowInstance(args);
31995 }
31996
31997 SWIGINTERN int FormatInvalid_set(PyObject *) {
31998 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
31999 return 1;
32000 }
32001
32002
32003 SWIGINTERN PyObject *FormatInvalid_get(void) {
32004 PyObject *pyobj = 0;
32005
32006 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
32007 return pyobj;
32008 }
32009
32010
32011 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32012 PyObject *resultobj = 0;
32013 wxDataObject *arg1 = (wxDataObject *) 0 ;
32014 void *argp1 = 0 ;
32015 int res1 = 0 ;
32016 PyObject *swig_obj[1] ;
32017
32018 if (!args) SWIG_fail;
32019 swig_obj[0] = args;
32020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32021 if (!SWIG_IsOK(res1)) {
32022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
32023 }
32024 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32025 {
32026 PyThreadState* __tstate = wxPyBeginAllowThreads();
32027 delete arg1;
32028
32029 wxPyEndAllowThreads(__tstate);
32030 if (PyErr_Occurred()) SWIG_fail;
32031 }
32032 resultobj = SWIG_Py_Void();
32033 return resultobj;
32034 fail:
32035 return NULL;
32036 }
32037
32038
32039 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32040 PyObject *resultobj = 0;
32041 wxDataObject *arg1 = (wxDataObject *) 0 ;
32042 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32043 SwigValueWrapper<wxDataFormat > result;
32044 void *argp1 = 0 ;
32045 int res1 = 0 ;
32046 int val2 ;
32047 int ecode2 = 0 ;
32048 PyObject * obj0 = 0 ;
32049 PyObject * obj1 = 0 ;
32050 char * kwnames[] = {
32051 (char *) "self",(char *) "dir", NULL
32052 };
32053
32054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32056 if (!SWIG_IsOK(res1)) {
32057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32058 }
32059 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32060 if (obj1) {
32061 ecode2 = SWIG_AsVal_int(obj1, &val2);
32062 if (!SWIG_IsOK(ecode2)) {
32063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32064 }
32065 arg2 = static_cast< wxDataObject::Direction >(val2);
32066 }
32067 {
32068 PyThreadState* __tstate = wxPyBeginAllowThreads();
32069 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
32070 wxPyEndAllowThreads(__tstate);
32071 if (PyErr_Occurred()) SWIG_fail;
32072 }
32073 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32074 return resultobj;
32075 fail:
32076 return NULL;
32077 }
32078
32079
32080 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32081 PyObject *resultobj = 0;
32082 wxDataObject *arg1 = (wxDataObject *) 0 ;
32083 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32084 size_t result;
32085 void *argp1 = 0 ;
32086 int res1 = 0 ;
32087 int val2 ;
32088 int ecode2 = 0 ;
32089 PyObject * obj0 = 0 ;
32090 PyObject * obj1 = 0 ;
32091 char * kwnames[] = {
32092 (char *) "self",(char *) "dir", NULL
32093 };
32094
32095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32097 if (!SWIG_IsOK(res1)) {
32098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32099 }
32100 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32101 if (obj1) {
32102 ecode2 = SWIG_AsVal_int(obj1, &val2);
32103 if (!SWIG_IsOK(ecode2)) {
32104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32105 }
32106 arg2 = static_cast< wxDataObject::Direction >(val2);
32107 }
32108 {
32109 PyThreadState* __tstate = wxPyBeginAllowThreads();
32110 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32111 wxPyEndAllowThreads(__tstate);
32112 if (PyErr_Occurred()) SWIG_fail;
32113 }
32114 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32115 return resultobj;
32116 fail:
32117 return NULL;
32118 }
32119
32120
32121 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32122 PyObject *resultobj = 0;
32123 wxDataObject *arg1 = (wxDataObject *) 0 ;
32124 wxDataFormat *arg2 = 0 ;
32125 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32126 bool result;
32127 void *argp1 = 0 ;
32128 int res1 = 0 ;
32129 void *argp2 = 0 ;
32130 int res2 = 0 ;
32131 int val3 ;
32132 int ecode3 = 0 ;
32133 PyObject * obj0 = 0 ;
32134 PyObject * obj1 = 0 ;
32135 PyObject * obj2 = 0 ;
32136 char * kwnames[] = {
32137 (char *) "self",(char *) "format",(char *) "dir", NULL
32138 };
32139
32140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32142 if (!SWIG_IsOK(res1)) {
32143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32144 }
32145 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32146 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32147 if (!SWIG_IsOK(res2)) {
32148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32149 }
32150 if (!argp2) {
32151 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32152 }
32153 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32154 if (obj2) {
32155 ecode3 = SWIG_AsVal_int(obj2, &val3);
32156 if (!SWIG_IsOK(ecode3)) {
32157 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32158 }
32159 arg3 = static_cast< wxDataObject::Direction >(val3);
32160 }
32161 {
32162 PyThreadState* __tstate = wxPyBeginAllowThreads();
32163 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32164 wxPyEndAllowThreads(__tstate);
32165 if (PyErr_Occurred()) SWIG_fail;
32166 }
32167 {
32168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32169 }
32170 return resultobj;
32171 fail:
32172 return NULL;
32173 }
32174
32175
32176 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32177 PyObject *resultobj = 0;
32178 wxDataObject *arg1 = (wxDataObject *) 0 ;
32179 wxDataFormat *arg2 = 0 ;
32180 size_t result;
32181 void *argp1 = 0 ;
32182 int res1 = 0 ;
32183 void *argp2 = 0 ;
32184 int res2 = 0 ;
32185 PyObject * obj0 = 0 ;
32186 PyObject * obj1 = 0 ;
32187 char * kwnames[] = {
32188 (char *) "self",(char *) "format", NULL
32189 };
32190
32191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32193 if (!SWIG_IsOK(res1)) {
32194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32195 }
32196 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32197 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32198 if (!SWIG_IsOK(res2)) {
32199 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32200 }
32201 if (!argp2) {
32202 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32203 }
32204 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32205 {
32206 PyThreadState* __tstate = wxPyBeginAllowThreads();
32207 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32208 wxPyEndAllowThreads(__tstate);
32209 if (PyErr_Occurred()) SWIG_fail;
32210 }
32211 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32212 return resultobj;
32213 fail:
32214 return NULL;
32215 }
32216
32217
32218 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32219 PyObject *resultobj = 0;
32220 wxDataObject *arg1 = (wxDataObject *) 0 ;
32221 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32222 PyObject *result = 0 ;
32223 void *argp1 = 0 ;
32224 int res1 = 0 ;
32225 int val2 ;
32226 int ecode2 = 0 ;
32227 PyObject * obj0 = 0 ;
32228 PyObject * obj1 = 0 ;
32229 char * kwnames[] = {
32230 (char *) "self",(char *) "dir", NULL
32231 };
32232
32233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32235 if (!SWIG_IsOK(res1)) {
32236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32237 }
32238 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32239 if (obj1) {
32240 ecode2 = SWIG_AsVal_int(obj1, &val2);
32241 if (!SWIG_IsOK(ecode2)) {
32242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32243 }
32244 arg2 = static_cast< wxDataObject::Direction >(val2);
32245 }
32246 {
32247 PyThreadState* __tstate = wxPyBeginAllowThreads();
32248 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
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_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32260 PyObject *resultobj = 0;
32261 wxDataObject *arg1 = (wxDataObject *) 0 ;
32262 wxDataFormat *arg2 = 0 ;
32263 PyObject *result = 0 ;
32264 void *argp1 = 0 ;
32265 int res1 = 0 ;
32266 void *argp2 = 0 ;
32267 int res2 = 0 ;
32268 PyObject * obj0 = 0 ;
32269 PyObject * obj1 = 0 ;
32270 char * kwnames[] = {
32271 (char *) "self",(char *) "format", NULL
32272 };
32273
32274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32276 if (!SWIG_IsOK(res1)) {
32277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32278 }
32279 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32280 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32281 if (!SWIG_IsOK(res2)) {
32282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32283 }
32284 if (!argp2) {
32285 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32286 }
32287 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32288 {
32289 PyThreadState* __tstate = wxPyBeginAllowThreads();
32290 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32291 wxPyEndAllowThreads(__tstate);
32292 if (PyErr_Occurred()) SWIG_fail;
32293 }
32294 resultobj = result;
32295 return resultobj;
32296 fail:
32297 return NULL;
32298 }
32299
32300
32301 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32302 PyObject *resultobj = 0;
32303 wxDataObject *arg1 = (wxDataObject *) 0 ;
32304 wxDataFormat *arg2 = 0 ;
32305 PyObject *arg3 = (PyObject *) 0 ;
32306 bool result;
32307 void *argp1 = 0 ;
32308 int res1 = 0 ;
32309 void *argp2 = 0 ;
32310 int res2 = 0 ;
32311 PyObject * obj0 = 0 ;
32312 PyObject * obj1 = 0 ;
32313 PyObject * obj2 = 0 ;
32314 char * kwnames[] = {
32315 (char *) "self",(char *) "format",(char *) "data", NULL
32316 };
32317
32318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32320 if (!SWIG_IsOK(res1)) {
32321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32322 }
32323 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32324 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32325 if (!SWIG_IsOK(res2)) {
32326 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32327 }
32328 if (!argp2) {
32329 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32330 }
32331 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32332 arg3 = obj2;
32333 {
32334 PyThreadState* __tstate = wxPyBeginAllowThreads();
32335 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32336 wxPyEndAllowThreads(__tstate);
32337 if (PyErr_Occurred()) SWIG_fail;
32338 }
32339 {
32340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32341 }
32342 return resultobj;
32343 fail:
32344 return NULL;
32345 }
32346
32347
32348 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32349 PyObject *obj;
32350 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32351 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32352 return SWIG_Py_Void();
32353 }
32354
32355 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32356 PyObject *resultobj = 0;
32357 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32358 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32359 wxDataObjectSimple *result = 0 ;
32360 void *argp1 = 0 ;
32361 int res1 = 0 ;
32362 PyObject * obj0 = 0 ;
32363 char * kwnames[] = {
32364 (char *) "format", NULL
32365 };
32366
32367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32368 if (obj0) {
32369 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32370 if (!SWIG_IsOK(res1)) {
32371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32372 }
32373 if (!argp1) {
32374 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32375 }
32376 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32377 }
32378 {
32379 PyThreadState* __tstate = wxPyBeginAllowThreads();
32380 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32381 wxPyEndAllowThreads(__tstate);
32382 if (PyErr_Occurred()) SWIG_fail;
32383 }
32384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32385 return resultobj;
32386 fail:
32387 return NULL;
32388 }
32389
32390
32391 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32392 PyObject *resultobj = 0;
32393 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32394 wxDataFormat *result = 0 ;
32395 void *argp1 = 0 ;
32396 int res1 = 0 ;
32397 PyObject *swig_obj[1] ;
32398
32399 if (!args) SWIG_fail;
32400 swig_obj[0] = args;
32401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32402 if (!SWIG_IsOK(res1)) {
32403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32404 }
32405 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32406 {
32407 PyThreadState* __tstate = wxPyBeginAllowThreads();
32408 {
32409 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32410 result = (wxDataFormat *) &_result_ref;
32411 }
32412 wxPyEndAllowThreads(__tstate);
32413 if (PyErr_Occurred()) SWIG_fail;
32414 }
32415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32416 return resultobj;
32417 fail:
32418 return NULL;
32419 }
32420
32421
32422 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32423 PyObject *resultobj = 0;
32424 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32425 wxDataFormat *arg2 = 0 ;
32426 void *argp1 = 0 ;
32427 int res1 = 0 ;
32428 void *argp2 = 0 ;
32429 int res2 = 0 ;
32430 PyObject * obj0 = 0 ;
32431 PyObject * obj1 = 0 ;
32432 char * kwnames[] = {
32433 (char *) "self",(char *) "format", NULL
32434 };
32435
32436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32438 if (!SWIG_IsOK(res1)) {
32439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32440 }
32441 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32442 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32443 if (!SWIG_IsOK(res2)) {
32444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32445 }
32446 if (!argp2) {
32447 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32448 }
32449 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32450 {
32451 PyThreadState* __tstate = wxPyBeginAllowThreads();
32452 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32453 wxPyEndAllowThreads(__tstate);
32454 if (PyErr_Occurred()) SWIG_fail;
32455 }
32456 resultobj = SWIG_Py_Void();
32457 return resultobj;
32458 fail:
32459 return NULL;
32460 }
32461
32462
32463 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32464 PyObject *resultobj = 0;
32465 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32466 size_t result;
32467 void *argp1 = 0 ;
32468 int res1 = 0 ;
32469 PyObject *swig_obj[1] ;
32470
32471 if (!args) SWIG_fail;
32472 swig_obj[0] = args;
32473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32474 if (!SWIG_IsOK(res1)) {
32475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32476 }
32477 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32478 {
32479 PyThreadState* __tstate = wxPyBeginAllowThreads();
32480 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32481 wxPyEndAllowThreads(__tstate);
32482 if (PyErr_Occurred()) SWIG_fail;
32483 }
32484 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32485 return resultobj;
32486 fail:
32487 return NULL;
32488 }
32489
32490
32491 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32492 PyObject *resultobj = 0;
32493 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32494 PyObject *result = 0 ;
32495 void *argp1 = 0 ;
32496 int res1 = 0 ;
32497 PyObject *swig_obj[1] ;
32498
32499 if (!args) SWIG_fail;
32500 swig_obj[0] = args;
32501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32502 if (!SWIG_IsOK(res1)) {
32503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32504 }
32505 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32506 {
32507 PyThreadState* __tstate = wxPyBeginAllowThreads();
32508 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32509 wxPyEndAllowThreads(__tstate);
32510 if (PyErr_Occurred()) SWIG_fail;
32511 }
32512 resultobj = result;
32513 return resultobj;
32514 fail:
32515 return NULL;
32516 }
32517
32518
32519 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32520 PyObject *resultobj = 0;
32521 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32522 PyObject *arg2 = (PyObject *) 0 ;
32523 bool result;
32524 void *argp1 = 0 ;
32525 int res1 = 0 ;
32526 PyObject * obj0 = 0 ;
32527 PyObject * obj1 = 0 ;
32528 char * kwnames[] = {
32529 (char *) "self",(char *) "data", NULL
32530 };
32531
32532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32534 if (!SWIG_IsOK(res1)) {
32535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32536 }
32537 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32538 arg2 = obj1;
32539 {
32540 PyThreadState* __tstate = wxPyBeginAllowThreads();
32541 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32542 wxPyEndAllowThreads(__tstate);
32543 if (PyErr_Occurred()) SWIG_fail;
32544 }
32545 {
32546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32547 }
32548 return resultobj;
32549 fail:
32550 return NULL;
32551 }
32552
32553
32554 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32555 PyObject *obj;
32556 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32557 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32558 return SWIG_Py_Void();
32559 }
32560
32561 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32562 return SWIG_Python_InitShadowInstance(args);
32563 }
32564
32565 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32566 PyObject *resultobj = 0;
32567 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32568 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32569 wxPyDataObjectSimple *result = 0 ;
32570 void *argp1 = 0 ;
32571 int res1 = 0 ;
32572 PyObject * obj0 = 0 ;
32573 char * kwnames[] = {
32574 (char *) "format", NULL
32575 };
32576
32577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32578 if (obj0) {
32579 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32580 if (!SWIG_IsOK(res1)) {
32581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32582 }
32583 if (!argp1) {
32584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32585 }
32586 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32587 }
32588 {
32589 PyThreadState* __tstate = wxPyBeginAllowThreads();
32590 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32591 wxPyEndAllowThreads(__tstate);
32592 if (PyErr_Occurred()) SWIG_fail;
32593 }
32594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32595 return resultobj;
32596 fail:
32597 return NULL;
32598 }
32599
32600
32601 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32602 PyObject *resultobj = 0;
32603 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32604 PyObject *arg2 = (PyObject *) 0 ;
32605 PyObject *arg3 = (PyObject *) 0 ;
32606 void *argp1 = 0 ;
32607 int res1 = 0 ;
32608 PyObject * obj0 = 0 ;
32609 PyObject * obj1 = 0 ;
32610 PyObject * obj2 = 0 ;
32611 char * kwnames[] = {
32612 (char *) "self",(char *) "self",(char *) "_class", NULL
32613 };
32614
32615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32617 if (!SWIG_IsOK(res1)) {
32618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32619 }
32620 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32621 arg2 = obj1;
32622 arg3 = obj2;
32623 {
32624 PyThreadState* __tstate = wxPyBeginAllowThreads();
32625 (arg1)->_setCallbackInfo(arg2,arg3);
32626 wxPyEndAllowThreads(__tstate);
32627 if (PyErr_Occurred()) SWIG_fail;
32628 }
32629 resultobj = SWIG_Py_Void();
32630 return resultobj;
32631 fail:
32632 return NULL;
32633 }
32634
32635
32636 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32637 PyObject *obj;
32638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32639 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32640 return SWIG_Py_Void();
32641 }
32642
32643 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32644 return SWIG_Python_InitShadowInstance(args);
32645 }
32646
32647 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32648 PyObject *resultobj = 0;
32649 wxDataObjectComposite *result = 0 ;
32650
32651 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32652 {
32653 PyThreadState* __tstate = wxPyBeginAllowThreads();
32654 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32655 wxPyEndAllowThreads(__tstate);
32656 if (PyErr_Occurred()) SWIG_fail;
32657 }
32658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32659 return resultobj;
32660 fail:
32661 return NULL;
32662 }
32663
32664
32665 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32666 PyObject *resultobj = 0;
32667 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32668 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32669 bool arg3 = (bool) false ;
32670 void *argp1 = 0 ;
32671 int res1 = 0 ;
32672 int res2 = 0 ;
32673 bool val3 ;
32674 int ecode3 = 0 ;
32675 PyObject * obj0 = 0 ;
32676 PyObject * obj1 = 0 ;
32677 PyObject * obj2 = 0 ;
32678 char * kwnames[] = {
32679 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32680 };
32681
32682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32684 if (!SWIG_IsOK(res1)) {
32685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32686 }
32687 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32688 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32689 if (!SWIG_IsOK(res2)) {
32690 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32691 }
32692 if (obj2) {
32693 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32694 if (!SWIG_IsOK(ecode3)) {
32695 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32696 }
32697 arg3 = static_cast< bool >(val3);
32698 }
32699 {
32700 PyThreadState* __tstate = wxPyBeginAllowThreads();
32701 (arg1)->Add(arg2,arg3);
32702 wxPyEndAllowThreads(__tstate);
32703 if (PyErr_Occurred()) SWIG_fail;
32704 }
32705 resultobj = SWIG_Py_Void();
32706 return resultobj;
32707 fail:
32708 return NULL;
32709 }
32710
32711
32712 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32713 PyObject *resultobj = 0;
32714 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32715 SwigValueWrapper<wxDataFormat > result;
32716 void *argp1 = 0 ;
32717 int res1 = 0 ;
32718 PyObject *swig_obj[1] ;
32719
32720 if (!args) SWIG_fail;
32721 swig_obj[0] = args;
32722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32723 if (!SWIG_IsOK(res1)) {
32724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32725 }
32726 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32727 {
32728 PyThreadState* __tstate = wxPyBeginAllowThreads();
32729 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32730 wxPyEndAllowThreads(__tstate);
32731 if (PyErr_Occurred()) SWIG_fail;
32732 }
32733 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32734 return resultobj;
32735 fail:
32736 return NULL;
32737 }
32738
32739
32740 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32741 PyObject *obj;
32742 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32743 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32744 return SWIG_Py_Void();
32745 }
32746
32747 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32748 return SWIG_Python_InitShadowInstance(args);
32749 }
32750
32751 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32752 PyObject *resultobj = 0;
32753 wxString const &arg1_defvalue = wxPyEmptyString ;
32754 wxString *arg1 = (wxString *) &arg1_defvalue ;
32755 wxTextDataObject *result = 0 ;
32756 bool temp1 = false ;
32757 PyObject * obj0 = 0 ;
32758 char * kwnames[] = {
32759 (char *) "text", NULL
32760 };
32761
32762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32763 if (obj0) {
32764 {
32765 arg1 = wxString_in_helper(obj0);
32766 if (arg1 == NULL) SWIG_fail;
32767 temp1 = true;
32768 }
32769 }
32770 {
32771 PyThreadState* __tstate = wxPyBeginAllowThreads();
32772 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32773 wxPyEndAllowThreads(__tstate);
32774 if (PyErr_Occurred()) SWIG_fail;
32775 }
32776 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32777 {
32778 if (temp1)
32779 delete arg1;
32780 }
32781 return resultobj;
32782 fail:
32783 {
32784 if (temp1)
32785 delete arg1;
32786 }
32787 return NULL;
32788 }
32789
32790
32791 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32792 PyObject *resultobj = 0;
32793 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32794 size_t result;
32795 void *argp1 = 0 ;
32796 int res1 = 0 ;
32797 PyObject *swig_obj[1] ;
32798
32799 if (!args) SWIG_fail;
32800 swig_obj[0] = args;
32801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32802 if (!SWIG_IsOK(res1)) {
32803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32804 }
32805 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32806 {
32807 PyThreadState* __tstate = wxPyBeginAllowThreads();
32808 result = (size_t)(arg1)->GetTextLength();
32809 wxPyEndAllowThreads(__tstate);
32810 if (PyErr_Occurred()) SWIG_fail;
32811 }
32812 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32813 return resultobj;
32814 fail:
32815 return NULL;
32816 }
32817
32818
32819 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32820 PyObject *resultobj = 0;
32821 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32822 wxString result;
32823 void *argp1 = 0 ;
32824 int res1 = 0 ;
32825 PyObject *swig_obj[1] ;
32826
32827 if (!args) SWIG_fail;
32828 swig_obj[0] = args;
32829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32830 if (!SWIG_IsOK(res1)) {
32831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32832 }
32833 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32834 {
32835 PyThreadState* __tstate = wxPyBeginAllowThreads();
32836 result = (arg1)->GetText();
32837 wxPyEndAllowThreads(__tstate);
32838 if (PyErr_Occurred()) SWIG_fail;
32839 }
32840 {
32841 #if wxUSE_UNICODE
32842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32843 #else
32844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32845 #endif
32846 }
32847 return resultobj;
32848 fail:
32849 return NULL;
32850 }
32851
32852
32853 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32854 PyObject *resultobj = 0;
32855 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32856 wxString *arg2 = 0 ;
32857 void *argp1 = 0 ;
32858 int res1 = 0 ;
32859 bool temp2 = false ;
32860 PyObject * obj0 = 0 ;
32861 PyObject * obj1 = 0 ;
32862 char * kwnames[] = {
32863 (char *) "self",(char *) "text", NULL
32864 };
32865
32866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32868 if (!SWIG_IsOK(res1)) {
32869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32870 }
32871 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32872 {
32873 arg2 = wxString_in_helper(obj1);
32874 if (arg2 == NULL) SWIG_fail;
32875 temp2 = true;
32876 }
32877 {
32878 PyThreadState* __tstate = wxPyBeginAllowThreads();
32879 (arg1)->SetText((wxString const &)*arg2);
32880 wxPyEndAllowThreads(__tstate);
32881 if (PyErr_Occurred()) SWIG_fail;
32882 }
32883 resultobj = SWIG_Py_Void();
32884 {
32885 if (temp2)
32886 delete arg2;
32887 }
32888 return resultobj;
32889 fail:
32890 {
32891 if (temp2)
32892 delete arg2;
32893 }
32894 return NULL;
32895 }
32896
32897
32898 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32899 PyObject *obj;
32900 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32901 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32902 return SWIG_Py_Void();
32903 }
32904
32905 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32906 return SWIG_Python_InitShadowInstance(args);
32907 }
32908
32909 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32910 PyObject *resultobj = 0;
32911 wxString const &arg1_defvalue = wxPyEmptyString ;
32912 wxString *arg1 = (wxString *) &arg1_defvalue ;
32913 wxPyTextDataObject *result = 0 ;
32914 bool temp1 = false ;
32915 PyObject * obj0 = 0 ;
32916 char * kwnames[] = {
32917 (char *) "text", NULL
32918 };
32919
32920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32921 if (obj0) {
32922 {
32923 arg1 = wxString_in_helper(obj0);
32924 if (arg1 == NULL) SWIG_fail;
32925 temp1 = true;
32926 }
32927 }
32928 {
32929 PyThreadState* __tstate = wxPyBeginAllowThreads();
32930 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32931 wxPyEndAllowThreads(__tstate);
32932 if (PyErr_Occurred()) SWIG_fail;
32933 }
32934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32935 {
32936 if (temp1)
32937 delete arg1;
32938 }
32939 return resultobj;
32940 fail:
32941 {
32942 if (temp1)
32943 delete arg1;
32944 }
32945 return NULL;
32946 }
32947
32948
32949 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32950 PyObject *resultobj = 0;
32951 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32952 PyObject *arg2 = (PyObject *) 0 ;
32953 PyObject *arg3 = (PyObject *) 0 ;
32954 void *argp1 = 0 ;
32955 int res1 = 0 ;
32956 PyObject * obj0 = 0 ;
32957 PyObject * obj1 = 0 ;
32958 PyObject * obj2 = 0 ;
32959 char * kwnames[] = {
32960 (char *) "self",(char *) "self",(char *) "_class", NULL
32961 };
32962
32963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32965 if (!SWIG_IsOK(res1)) {
32966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32967 }
32968 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32969 arg2 = obj1;
32970 arg3 = obj2;
32971 {
32972 PyThreadState* __tstate = wxPyBeginAllowThreads();
32973 (arg1)->_setCallbackInfo(arg2,arg3);
32974 wxPyEndAllowThreads(__tstate);
32975 if (PyErr_Occurred()) SWIG_fail;
32976 }
32977 resultobj = SWIG_Py_Void();
32978 return resultobj;
32979 fail:
32980 return NULL;
32981 }
32982
32983
32984 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32985 PyObject *obj;
32986 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32987 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32988 return SWIG_Py_Void();
32989 }
32990
32991 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32992 return SWIG_Python_InitShadowInstance(args);
32993 }
32994
32995 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32996 PyObject *resultobj = 0;
32997 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32998 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32999 wxBitmapDataObject *result = 0 ;
33000 void *argp1 = 0 ;
33001 int res1 = 0 ;
33002 PyObject * obj0 = 0 ;
33003 char * kwnames[] = {
33004 (char *) "bitmap", NULL
33005 };
33006
33007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
33008 if (obj0) {
33009 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33010 if (!SWIG_IsOK(res1)) {
33011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33012 }
33013 if (!argp1) {
33014 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33015 }
33016 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33017 }
33018 {
33019 PyThreadState* __tstate = wxPyBeginAllowThreads();
33020 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
33021 wxPyEndAllowThreads(__tstate);
33022 if (PyErr_Occurred()) SWIG_fail;
33023 }
33024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
33025 return resultobj;
33026 fail:
33027 return NULL;
33028 }
33029
33030
33031 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33032 PyObject *resultobj = 0;
33033 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33034 wxBitmap result;
33035 void *argp1 = 0 ;
33036 int res1 = 0 ;
33037 PyObject *swig_obj[1] ;
33038
33039 if (!args) SWIG_fail;
33040 swig_obj[0] = args;
33041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33042 if (!SWIG_IsOK(res1)) {
33043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
33044 }
33045 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33046 {
33047 PyThreadState* __tstate = wxPyBeginAllowThreads();
33048 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
33049 wxPyEndAllowThreads(__tstate);
33050 if (PyErr_Occurred()) SWIG_fail;
33051 }
33052 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
33053 return resultobj;
33054 fail:
33055 return NULL;
33056 }
33057
33058
33059 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33060 PyObject *resultobj = 0;
33061 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33062 wxBitmap *arg2 = 0 ;
33063 void *argp1 = 0 ;
33064 int res1 = 0 ;
33065 void *argp2 = 0 ;
33066 int res2 = 0 ;
33067 PyObject * obj0 = 0 ;
33068 PyObject * obj1 = 0 ;
33069 char * kwnames[] = {
33070 (char *) "self",(char *) "bitmap", NULL
33071 };
33072
33073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
33074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33075 if (!SWIG_IsOK(res1)) {
33076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
33077 }
33078 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33079 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
33080 if (!SWIG_IsOK(res2)) {
33081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33082 }
33083 if (!argp2) {
33084 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33085 }
33086 arg2 = reinterpret_cast< wxBitmap * >(argp2);
33087 {
33088 PyThreadState* __tstate = wxPyBeginAllowThreads();
33089 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33090 wxPyEndAllowThreads(__tstate);
33091 if (PyErr_Occurred()) SWIG_fail;
33092 }
33093 resultobj = SWIG_Py_Void();
33094 return resultobj;
33095 fail:
33096 return NULL;
33097 }
33098
33099
33100 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33101 PyObject *obj;
33102 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33103 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33104 return SWIG_Py_Void();
33105 }
33106
33107 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33108 return SWIG_Python_InitShadowInstance(args);
33109 }
33110
33111 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33112 PyObject *resultobj = 0;
33113 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33114 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33115 wxPyBitmapDataObject *result = 0 ;
33116 void *argp1 = 0 ;
33117 int res1 = 0 ;
33118 PyObject * obj0 = 0 ;
33119 char * kwnames[] = {
33120 (char *) "bitmap", NULL
33121 };
33122
33123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33124 if (obj0) {
33125 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33126 if (!SWIG_IsOK(res1)) {
33127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33128 }
33129 if (!argp1) {
33130 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33131 }
33132 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33133 }
33134 {
33135 PyThreadState* __tstate = wxPyBeginAllowThreads();
33136 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33137 wxPyEndAllowThreads(__tstate);
33138 if (PyErr_Occurred()) SWIG_fail;
33139 }
33140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33141 return resultobj;
33142 fail:
33143 return NULL;
33144 }
33145
33146
33147 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33148 PyObject *resultobj = 0;
33149 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33150 PyObject *arg2 = (PyObject *) 0 ;
33151 PyObject *arg3 = (PyObject *) 0 ;
33152 void *argp1 = 0 ;
33153 int res1 = 0 ;
33154 PyObject * obj0 = 0 ;
33155 PyObject * obj1 = 0 ;
33156 PyObject * obj2 = 0 ;
33157 char * kwnames[] = {
33158 (char *) "self",(char *) "self",(char *) "_class", NULL
33159 };
33160
33161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33163 if (!SWIG_IsOK(res1)) {
33164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33165 }
33166 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33167 arg2 = obj1;
33168 arg3 = obj2;
33169 {
33170 PyThreadState* __tstate = wxPyBeginAllowThreads();
33171 (arg1)->_setCallbackInfo(arg2,arg3);
33172 wxPyEndAllowThreads(__tstate);
33173 if (PyErr_Occurred()) SWIG_fail;
33174 }
33175 resultobj = SWIG_Py_Void();
33176 return resultobj;
33177 fail:
33178 return NULL;
33179 }
33180
33181
33182 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33183 PyObject *obj;
33184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33185 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33186 return SWIG_Py_Void();
33187 }
33188
33189 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33190 return SWIG_Python_InitShadowInstance(args);
33191 }
33192
33193 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33194 PyObject *resultobj = 0;
33195 wxFileDataObject *result = 0 ;
33196
33197 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33198 {
33199 PyThreadState* __tstate = wxPyBeginAllowThreads();
33200 result = (wxFileDataObject *)new wxFileDataObject();
33201 wxPyEndAllowThreads(__tstate);
33202 if (PyErr_Occurred()) SWIG_fail;
33203 }
33204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33205 return resultobj;
33206 fail:
33207 return NULL;
33208 }
33209
33210
33211 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33212 PyObject *resultobj = 0;
33213 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33214 wxArrayString *result = 0 ;
33215 void *argp1 = 0 ;
33216 int res1 = 0 ;
33217 PyObject *swig_obj[1] ;
33218
33219 if (!args) SWIG_fail;
33220 swig_obj[0] = args;
33221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33222 if (!SWIG_IsOK(res1)) {
33223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33224 }
33225 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33226 {
33227 PyThreadState* __tstate = wxPyBeginAllowThreads();
33228 {
33229 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33230 result = (wxArrayString *) &_result_ref;
33231 }
33232 wxPyEndAllowThreads(__tstate);
33233 if (PyErr_Occurred()) SWIG_fail;
33234 }
33235 {
33236 resultobj = wxArrayString2PyList_helper(*result);
33237 }
33238 return resultobj;
33239 fail:
33240 return NULL;
33241 }
33242
33243
33244 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33245 PyObject *resultobj = 0;
33246 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33247 wxString *arg2 = 0 ;
33248 void *argp1 = 0 ;
33249 int res1 = 0 ;
33250 bool temp2 = false ;
33251 PyObject * obj0 = 0 ;
33252 PyObject * obj1 = 0 ;
33253 char * kwnames[] = {
33254 (char *) "self",(char *) "filename", NULL
33255 };
33256
33257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33259 if (!SWIG_IsOK(res1)) {
33260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33261 }
33262 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33263 {
33264 arg2 = wxString_in_helper(obj1);
33265 if (arg2 == NULL) SWIG_fail;
33266 temp2 = true;
33267 }
33268 {
33269 PyThreadState* __tstate = wxPyBeginAllowThreads();
33270 (arg1)->AddFile((wxString const &)*arg2);
33271 wxPyEndAllowThreads(__tstate);
33272 if (PyErr_Occurred()) SWIG_fail;
33273 }
33274 resultobj = SWIG_Py_Void();
33275 {
33276 if (temp2)
33277 delete arg2;
33278 }
33279 return resultobj;
33280 fail:
33281 {
33282 if (temp2)
33283 delete arg2;
33284 }
33285 return NULL;
33286 }
33287
33288
33289 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33290 PyObject *obj;
33291 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33292 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33293 return SWIG_Py_Void();
33294 }
33295
33296 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33297 return SWIG_Python_InitShadowInstance(args);
33298 }
33299
33300 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33301 PyObject *resultobj = 0;
33302 wxDataFormat *arg1 = 0 ;
33303 wxCustomDataObject *result = 0 ;
33304 void *argp1 = 0 ;
33305 int res1 = 0 ;
33306
33307 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33309 if (!SWIG_IsOK(res1)) {
33310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33311 }
33312 if (!argp1) {
33313 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33314 }
33315 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33316 {
33317 PyThreadState* __tstate = wxPyBeginAllowThreads();
33318 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33319 wxPyEndAllowThreads(__tstate);
33320 if (PyErr_Occurred()) SWIG_fail;
33321 }
33322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33323 return resultobj;
33324 fail:
33325 return NULL;
33326 }
33327
33328
33329 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33330 PyObject *resultobj = 0;
33331 wxString *arg1 = 0 ;
33332 wxCustomDataObject *result = 0 ;
33333 bool temp1 = false ;
33334
33335 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33336 {
33337 arg1 = wxString_in_helper(swig_obj[0]);
33338 if (arg1 == NULL) SWIG_fail;
33339 temp1 = true;
33340 }
33341 {
33342 PyThreadState* __tstate = wxPyBeginAllowThreads();
33343 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33344 wxPyEndAllowThreads(__tstate);
33345 if (PyErr_Occurred()) SWIG_fail;
33346 }
33347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33348 {
33349 if (temp1)
33350 delete arg1;
33351 }
33352 return resultobj;
33353 fail:
33354 {
33355 if (temp1)
33356 delete arg1;
33357 }
33358 return NULL;
33359 }
33360
33361
33362 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33363 PyObject *resultobj = 0;
33364 wxCustomDataObject *result = 0 ;
33365
33366 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33367 {
33368 PyThreadState* __tstate = wxPyBeginAllowThreads();
33369 result = (wxCustomDataObject *)new wxCustomDataObject();
33370 wxPyEndAllowThreads(__tstate);
33371 if (PyErr_Occurred()) SWIG_fail;
33372 }
33373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33374 return resultobj;
33375 fail:
33376 return NULL;
33377 }
33378
33379
33380 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33381 int argc;
33382 PyObject *argv[2];
33383
33384 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33385 --argc;
33386 if (argc == 0) {
33387 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33388 }
33389 if (argc == 1) {
33390 int _v = 0;
33391 {
33392 {
33393 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33394 }
33395 }
33396 if (!_v) goto check_2;
33397 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33398 }
33399 check_2:
33400
33401 if (argc == 1) {
33402 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33403 }
33404
33405 fail:
33406 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33407 return NULL;
33408 }
33409
33410
33411 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33412 PyObject *resultobj = 0;
33413 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33414 PyObject *arg2 = (PyObject *) 0 ;
33415 bool result;
33416 void *argp1 = 0 ;
33417 int res1 = 0 ;
33418 PyObject * obj0 = 0 ;
33419 PyObject * obj1 = 0 ;
33420 char * kwnames[] = {
33421 (char *) "self",(char *) "data", NULL
33422 };
33423
33424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33426 if (!SWIG_IsOK(res1)) {
33427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33428 }
33429 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33430 arg2 = obj1;
33431 {
33432 PyThreadState* __tstate = wxPyBeginAllowThreads();
33433 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33434 wxPyEndAllowThreads(__tstate);
33435 if (PyErr_Occurred()) SWIG_fail;
33436 }
33437 {
33438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33439 }
33440 return resultobj;
33441 fail:
33442 return NULL;
33443 }
33444
33445
33446 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33447 PyObject *resultobj = 0;
33448 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33449 size_t result;
33450 void *argp1 = 0 ;
33451 int res1 = 0 ;
33452 PyObject *swig_obj[1] ;
33453
33454 if (!args) SWIG_fail;
33455 swig_obj[0] = args;
33456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33457 if (!SWIG_IsOK(res1)) {
33458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33459 }
33460 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33461 {
33462 PyThreadState* __tstate = wxPyBeginAllowThreads();
33463 result = (size_t)(arg1)->GetSize();
33464 wxPyEndAllowThreads(__tstate);
33465 if (PyErr_Occurred()) SWIG_fail;
33466 }
33467 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33468 return resultobj;
33469 fail:
33470 return NULL;
33471 }
33472
33473
33474 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33475 PyObject *resultobj = 0;
33476 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33477 PyObject *result = 0 ;
33478 void *argp1 = 0 ;
33479 int res1 = 0 ;
33480 PyObject *swig_obj[1] ;
33481
33482 if (!args) SWIG_fail;
33483 swig_obj[0] = args;
33484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33485 if (!SWIG_IsOK(res1)) {
33486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33487 }
33488 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33489 {
33490 PyThreadState* __tstate = wxPyBeginAllowThreads();
33491 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33492 wxPyEndAllowThreads(__tstate);
33493 if (PyErr_Occurred()) SWIG_fail;
33494 }
33495 resultobj = result;
33496 return resultobj;
33497 fail:
33498 return NULL;
33499 }
33500
33501
33502 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33503 PyObject *obj;
33504 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33505 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33506 return SWIG_Py_Void();
33507 }
33508
33509 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33510 return SWIG_Python_InitShadowInstance(args);
33511 }
33512
33513 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33514 PyObject *resultobj = 0;
33515 wxString const &arg1_defvalue = wxPyEmptyString ;
33516 wxString *arg1 = (wxString *) &arg1_defvalue ;
33517 wxURLDataObject *result = 0 ;
33518 bool temp1 = false ;
33519 PyObject * obj0 = 0 ;
33520 char * kwnames[] = {
33521 (char *) "url", NULL
33522 };
33523
33524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33525 if (obj0) {
33526 {
33527 arg1 = wxString_in_helper(obj0);
33528 if (arg1 == NULL) SWIG_fail;
33529 temp1 = true;
33530 }
33531 }
33532 {
33533 PyThreadState* __tstate = wxPyBeginAllowThreads();
33534 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33535 wxPyEndAllowThreads(__tstate);
33536 if (PyErr_Occurred()) SWIG_fail;
33537 }
33538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33539 {
33540 if (temp1)
33541 delete arg1;
33542 }
33543 return resultobj;
33544 fail:
33545 {
33546 if (temp1)
33547 delete arg1;
33548 }
33549 return NULL;
33550 }
33551
33552
33553 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33554 PyObject *resultobj = 0;
33555 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33556 wxString result;
33557 void *argp1 = 0 ;
33558 int res1 = 0 ;
33559 PyObject *swig_obj[1] ;
33560
33561 if (!args) SWIG_fail;
33562 swig_obj[0] = args;
33563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33564 if (!SWIG_IsOK(res1)) {
33565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33566 }
33567 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33568 {
33569 PyThreadState* __tstate = wxPyBeginAllowThreads();
33570 result = (arg1)->GetURL();
33571 wxPyEndAllowThreads(__tstate);
33572 if (PyErr_Occurred()) SWIG_fail;
33573 }
33574 {
33575 #if wxUSE_UNICODE
33576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33577 #else
33578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33579 #endif
33580 }
33581 return resultobj;
33582 fail:
33583 return NULL;
33584 }
33585
33586
33587 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33588 PyObject *resultobj = 0;
33589 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33590 wxString *arg2 = 0 ;
33591 void *argp1 = 0 ;
33592 int res1 = 0 ;
33593 bool temp2 = false ;
33594 PyObject * obj0 = 0 ;
33595 PyObject * obj1 = 0 ;
33596 char * kwnames[] = {
33597 (char *) "self",(char *) "url", NULL
33598 };
33599
33600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33602 if (!SWIG_IsOK(res1)) {
33603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33604 }
33605 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33606 {
33607 arg2 = wxString_in_helper(obj1);
33608 if (arg2 == NULL) SWIG_fail;
33609 temp2 = true;
33610 }
33611 {
33612 PyThreadState* __tstate = wxPyBeginAllowThreads();
33613 (arg1)->SetURL((wxString const &)*arg2);
33614 wxPyEndAllowThreads(__tstate);
33615 if (PyErr_Occurred()) SWIG_fail;
33616 }
33617 resultobj = SWIG_Py_Void();
33618 {
33619 if (temp2)
33620 delete arg2;
33621 }
33622 return resultobj;
33623 fail:
33624 {
33625 if (temp2)
33626 delete arg2;
33627 }
33628 return NULL;
33629 }
33630
33631
33632 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33633 PyObject *obj;
33634 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33635 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33636 return SWIG_Py_Void();
33637 }
33638
33639 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33640 return SWIG_Python_InitShadowInstance(args);
33641 }
33642
33643 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33644 PyObject *resultobj = 0;
33645 wxMetafileDataObject *result = 0 ;
33646
33647 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33648 {
33649 PyThreadState* __tstate = wxPyBeginAllowThreads();
33650 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33651 wxPyEndAllowThreads(__tstate);
33652 if (PyErr_Occurred()) SWIG_fail;
33653 }
33654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33655 return resultobj;
33656 fail:
33657 return NULL;
33658 }
33659
33660
33661 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33662 PyObject *obj;
33663 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33664 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33665 return SWIG_Py_Void();
33666 }
33667
33668 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33669 return SWIG_Python_InitShadowInstance(args);
33670 }
33671
33672 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33673 PyObject *resultobj = 0;
33674 wxDragResult arg1 ;
33675 bool result;
33676 int val1 ;
33677 int ecode1 = 0 ;
33678 PyObject * obj0 = 0 ;
33679 char * kwnames[] = {
33680 (char *) "res", NULL
33681 };
33682
33683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33684 ecode1 = SWIG_AsVal_int(obj0, &val1);
33685 if (!SWIG_IsOK(ecode1)) {
33686 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33687 }
33688 arg1 = static_cast< wxDragResult >(val1);
33689 {
33690 PyThreadState* __tstate = wxPyBeginAllowThreads();
33691 result = (bool)wxIsDragResultOk(arg1);
33692 wxPyEndAllowThreads(__tstate);
33693 if (PyErr_Occurred()) SWIG_fail;
33694 }
33695 {
33696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33697 }
33698 return resultobj;
33699 fail:
33700 return NULL;
33701 }
33702
33703
33704 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33705 PyObject *resultobj = 0;
33706 wxWindow *arg1 = (wxWindow *) 0 ;
33707 wxIcon const &arg2_defvalue = wxNullIcon ;
33708 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
33709 wxIcon const &arg3_defvalue = wxNullIcon ;
33710 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
33711 wxIcon const &arg4_defvalue = wxNullIcon ;
33712 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
33713 wxPyDropSource *result = 0 ;
33714 void *argp1 = 0 ;
33715 int res1 = 0 ;
33716 void *argp2 = 0 ;
33717 int res2 = 0 ;
33718 void *argp3 = 0 ;
33719 int res3 = 0 ;
33720 void *argp4 = 0 ;
33721 int res4 = 0 ;
33722 PyObject * obj0 = 0 ;
33723 PyObject * obj1 = 0 ;
33724 PyObject * obj2 = 0 ;
33725 PyObject * obj3 = 0 ;
33726 char * kwnames[] = {
33727 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33728 };
33729
33730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33732 if (!SWIG_IsOK(res1)) {
33733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33734 }
33735 arg1 = reinterpret_cast< wxWindow * >(argp1);
33736 if (obj1) {
33737 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
33738 if (!SWIG_IsOK(res2)) {
33739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33740 }
33741 if (!argp2) {
33742 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33743 }
33744 arg2 = reinterpret_cast< wxIcon * >(argp2);
33745 }
33746 if (obj2) {
33747 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
33748 if (!SWIG_IsOK(res3)) {
33749 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33750 }
33751 if (!argp3) {
33752 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33753 }
33754 arg3 = reinterpret_cast< wxIcon * >(argp3);
33755 }
33756 if (obj3) {
33757 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
33758 if (!SWIG_IsOK(res4)) {
33759 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33760 }
33761 if (!argp4) {
33762 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33763 }
33764 arg4 = reinterpret_cast< wxIcon * >(argp4);
33765 }
33766 {
33767 PyThreadState* __tstate = wxPyBeginAllowThreads();
33768 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
33769 wxPyEndAllowThreads(__tstate);
33770 if (PyErr_Occurred()) SWIG_fail;
33771 }
33772 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33773 return resultobj;
33774 fail:
33775 return NULL;
33776 }
33777
33778
33779 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33780 PyObject *resultobj = 0;
33781 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33782 PyObject *arg2 = (PyObject *) 0 ;
33783 PyObject *arg3 = (PyObject *) 0 ;
33784 int arg4 ;
33785 void *argp1 = 0 ;
33786 int res1 = 0 ;
33787 int val4 ;
33788 int ecode4 = 0 ;
33789 PyObject * obj0 = 0 ;
33790 PyObject * obj1 = 0 ;
33791 PyObject * obj2 = 0 ;
33792 PyObject * obj3 = 0 ;
33793 char * kwnames[] = {
33794 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33795 };
33796
33797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33799 if (!SWIG_IsOK(res1)) {
33800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33801 }
33802 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33803 arg2 = obj1;
33804 arg3 = obj2;
33805 ecode4 = SWIG_AsVal_int(obj3, &val4);
33806 if (!SWIG_IsOK(ecode4)) {
33807 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33808 }
33809 arg4 = static_cast< int >(val4);
33810 {
33811 PyThreadState* __tstate = wxPyBeginAllowThreads();
33812 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33813 wxPyEndAllowThreads(__tstate);
33814 if (PyErr_Occurred()) SWIG_fail;
33815 }
33816 resultobj = SWIG_Py_Void();
33817 return resultobj;
33818 fail:
33819 return NULL;
33820 }
33821
33822
33823 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33824 PyObject *resultobj = 0;
33825 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33826 void *argp1 = 0 ;
33827 int res1 = 0 ;
33828 PyObject *swig_obj[1] ;
33829
33830 if (!args) SWIG_fail;
33831 swig_obj[0] = args;
33832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33833 if (!SWIG_IsOK(res1)) {
33834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33835 }
33836 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33837 {
33838 PyThreadState* __tstate = wxPyBeginAllowThreads();
33839 delete arg1;
33840
33841 wxPyEndAllowThreads(__tstate);
33842 if (PyErr_Occurred()) SWIG_fail;
33843 }
33844 resultobj = SWIG_Py_Void();
33845 return resultobj;
33846 fail:
33847 return NULL;
33848 }
33849
33850
33851 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33852 PyObject *resultobj = 0;
33853 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33854 wxDataObject *arg2 = 0 ;
33855 void *argp1 = 0 ;
33856 int res1 = 0 ;
33857 void *argp2 = 0 ;
33858 int res2 = 0 ;
33859 PyObject * obj0 = 0 ;
33860 PyObject * obj1 = 0 ;
33861 char * kwnames[] = {
33862 (char *) "self",(char *) "data", NULL
33863 };
33864
33865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33867 if (!SWIG_IsOK(res1)) {
33868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33869 }
33870 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33871 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33872 if (!SWIG_IsOK(res2)) {
33873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33874 }
33875 if (!argp2) {
33876 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33877 }
33878 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33879 {
33880 PyThreadState* __tstate = wxPyBeginAllowThreads();
33881 (arg1)->SetData(*arg2);
33882 wxPyEndAllowThreads(__tstate);
33883 if (PyErr_Occurred()) SWIG_fail;
33884 }
33885 resultobj = SWIG_Py_Void();
33886 return resultobj;
33887 fail:
33888 return NULL;
33889 }
33890
33891
33892 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33893 PyObject *resultobj = 0;
33894 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33895 wxDataObject *result = 0 ;
33896 void *argp1 = 0 ;
33897 int res1 = 0 ;
33898 PyObject *swig_obj[1] ;
33899
33900 if (!args) SWIG_fail;
33901 swig_obj[0] = args;
33902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33903 if (!SWIG_IsOK(res1)) {
33904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33905 }
33906 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33907 {
33908 PyThreadState* __tstate = wxPyBeginAllowThreads();
33909 result = (wxDataObject *)(arg1)->GetDataObject();
33910 wxPyEndAllowThreads(__tstate);
33911 if (PyErr_Occurred()) SWIG_fail;
33912 }
33913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33914 return resultobj;
33915 fail:
33916 return NULL;
33917 }
33918
33919
33920 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33921 PyObject *resultobj = 0;
33922 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33923 wxDragResult arg2 ;
33924 wxCursor *arg3 = 0 ;
33925 void *argp1 = 0 ;
33926 int res1 = 0 ;
33927 int val2 ;
33928 int ecode2 = 0 ;
33929 void *argp3 = 0 ;
33930 int res3 = 0 ;
33931 PyObject * obj0 = 0 ;
33932 PyObject * obj1 = 0 ;
33933 PyObject * obj2 = 0 ;
33934 char * kwnames[] = {
33935 (char *) "self",(char *) "res",(char *) "cursor", NULL
33936 };
33937
33938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33940 if (!SWIG_IsOK(res1)) {
33941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33942 }
33943 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33944 ecode2 = SWIG_AsVal_int(obj1, &val2);
33945 if (!SWIG_IsOK(ecode2)) {
33946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
33947 }
33948 arg2 = static_cast< wxDragResult >(val2);
33949 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33950 if (!SWIG_IsOK(res3)) {
33951 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33952 }
33953 if (!argp3) {
33954 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33955 }
33956 arg3 = reinterpret_cast< wxCursor * >(argp3);
33957 {
33958 PyThreadState* __tstate = wxPyBeginAllowThreads();
33959 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
33960 wxPyEndAllowThreads(__tstate);
33961 if (PyErr_Occurred()) SWIG_fail;
33962 }
33963 resultobj = SWIG_Py_Void();
33964 return resultobj;
33965 fail:
33966 return NULL;
33967 }
33968
33969
33970 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33971 PyObject *resultobj = 0;
33972 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33973 int arg2 = (int) wxDrag_CopyOnly ;
33974 wxDragResult result;
33975 void *argp1 = 0 ;
33976 int res1 = 0 ;
33977 int val2 ;
33978 int ecode2 = 0 ;
33979 PyObject * obj0 = 0 ;
33980 PyObject * obj1 = 0 ;
33981 char * kwnames[] = {
33982 (char *) "self",(char *) "flags", NULL
33983 };
33984
33985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
33986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33987 if (!SWIG_IsOK(res1)) {
33988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33989 }
33990 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33991 if (obj1) {
33992 ecode2 = SWIG_AsVal_int(obj1, &val2);
33993 if (!SWIG_IsOK(ecode2)) {
33994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
33995 }
33996 arg2 = static_cast< int >(val2);
33997 }
33998 {
33999 PyThreadState* __tstate = wxPyBeginAllowThreads();
34000 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
34001 wxPyEndAllowThreads(__tstate);
34002 if (PyErr_Occurred()) SWIG_fail;
34003 }
34004 resultobj = SWIG_From_int(static_cast< int >(result));
34005 return resultobj;
34006 fail:
34007 return NULL;
34008 }
34009
34010
34011 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34012 PyObject *resultobj = 0;
34013 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34014 wxDragResult arg2 ;
34015 bool result;
34016 void *argp1 = 0 ;
34017 int res1 = 0 ;
34018 int val2 ;
34019 int ecode2 = 0 ;
34020 PyObject * obj0 = 0 ;
34021 PyObject * obj1 = 0 ;
34022 char * kwnames[] = {
34023 (char *) "self",(char *) "effect", NULL
34024 };
34025
34026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34028 if (!SWIG_IsOK(res1)) {
34029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34030 }
34031 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34032 ecode2 = SWIG_AsVal_int(obj1, &val2);
34033 if (!SWIG_IsOK(ecode2)) {
34034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34035 }
34036 arg2 = static_cast< wxDragResult >(val2);
34037 {
34038 PyThreadState* __tstate = wxPyBeginAllowThreads();
34039 result = (bool)(arg1)->GiveFeedback(arg2);
34040 wxPyEndAllowThreads(__tstate);
34041 if (PyErr_Occurred()) SWIG_fail;
34042 }
34043 {
34044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34045 }
34046 return resultobj;
34047 fail:
34048 return NULL;
34049 }
34050
34051
34052 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34053 PyObject *obj;
34054 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34055 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34056 return SWIG_Py_Void();
34057 }
34058
34059 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34060 return SWIG_Python_InitShadowInstance(args);
34061 }
34062
34063 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34064 PyObject *resultobj = 0;
34065 wxDataObject *arg1 = (wxDataObject *) NULL ;
34066 wxPyDropTarget *result = 0 ;
34067 int res1 = 0 ;
34068 PyObject * obj0 = 0 ;
34069 char * kwnames[] = {
34070 (char *) "dataObject", NULL
34071 };
34072
34073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34074 if (obj0) {
34075 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34076 if (!SWIG_IsOK(res1)) {
34077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34078 }
34079 }
34080 {
34081 PyThreadState* __tstate = wxPyBeginAllowThreads();
34082 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34083 wxPyEndAllowThreads(__tstate);
34084 if (PyErr_Occurred()) SWIG_fail;
34085 }
34086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34087 return resultobj;
34088 fail:
34089 return NULL;
34090 }
34091
34092
34093 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34094 PyObject *resultobj = 0;
34095 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34096 PyObject *arg2 = (PyObject *) 0 ;
34097 PyObject *arg3 = (PyObject *) 0 ;
34098 void *argp1 = 0 ;
34099 int res1 = 0 ;
34100 PyObject * obj0 = 0 ;
34101 PyObject * obj1 = 0 ;
34102 PyObject * obj2 = 0 ;
34103 char * kwnames[] = {
34104 (char *) "self",(char *) "self",(char *) "_class", NULL
34105 };
34106
34107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34109 if (!SWIG_IsOK(res1)) {
34110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34111 }
34112 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34113 arg2 = obj1;
34114 arg3 = obj2;
34115 {
34116 PyThreadState* __tstate = wxPyBeginAllowThreads();
34117 (arg1)->_setCallbackInfo(arg2,arg3);
34118 wxPyEndAllowThreads(__tstate);
34119 if (PyErr_Occurred()) SWIG_fail;
34120 }
34121 resultobj = SWIG_Py_Void();
34122 return resultobj;
34123 fail:
34124 return NULL;
34125 }
34126
34127
34128 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34129 PyObject *resultobj = 0;
34130 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34131 void *argp1 = 0 ;
34132 int res1 = 0 ;
34133 PyObject *swig_obj[1] ;
34134
34135 if (!args) SWIG_fail;
34136 swig_obj[0] = args;
34137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34138 if (!SWIG_IsOK(res1)) {
34139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34140 }
34141 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34142 {
34143 PyThreadState* __tstate = wxPyBeginAllowThreads();
34144 delete arg1;
34145
34146 wxPyEndAllowThreads(__tstate);
34147 if (PyErr_Occurred()) SWIG_fail;
34148 }
34149 resultobj = SWIG_Py_Void();
34150 return resultobj;
34151 fail:
34152 return NULL;
34153 }
34154
34155
34156 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34157 PyObject *resultobj = 0;
34158 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34159 wxDataObject *result = 0 ;
34160 void *argp1 = 0 ;
34161 int res1 = 0 ;
34162 PyObject *swig_obj[1] ;
34163
34164 if (!args) SWIG_fail;
34165 swig_obj[0] = args;
34166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34167 if (!SWIG_IsOK(res1)) {
34168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34169 }
34170 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34171 {
34172 PyThreadState* __tstate = wxPyBeginAllowThreads();
34173 result = (wxDataObject *)(arg1)->GetDataObject();
34174 wxPyEndAllowThreads(__tstate);
34175 if (PyErr_Occurred()) SWIG_fail;
34176 }
34177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34178 return resultobj;
34179 fail:
34180 return NULL;
34181 }
34182
34183
34184 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34185 PyObject *resultobj = 0;
34186 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34187 wxDataObject *arg2 = (wxDataObject *) 0 ;
34188 void *argp1 = 0 ;
34189 int res1 = 0 ;
34190 int res2 = 0 ;
34191 PyObject * obj0 = 0 ;
34192 PyObject * obj1 = 0 ;
34193 char * kwnames[] = {
34194 (char *) "self",(char *) "dataObject", NULL
34195 };
34196
34197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34199 if (!SWIG_IsOK(res1)) {
34200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34201 }
34202 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34203 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34204 if (!SWIG_IsOK(res2)) {
34205 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34206 }
34207 {
34208 PyThreadState* __tstate = wxPyBeginAllowThreads();
34209 (arg1)->SetDataObject(arg2);
34210 wxPyEndAllowThreads(__tstate);
34211 if (PyErr_Occurred()) SWIG_fail;
34212 }
34213 resultobj = SWIG_Py_Void();
34214 return resultobj;
34215 fail:
34216 return NULL;
34217 }
34218
34219
34220 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34221 PyObject *resultobj = 0;
34222 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34223 int arg2 ;
34224 int arg3 ;
34225 wxDragResult arg4 ;
34226 wxDragResult result;
34227 void *argp1 = 0 ;
34228 int res1 = 0 ;
34229 int val2 ;
34230 int ecode2 = 0 ;
34231 int val3 ;
34232 int ecode3 = 0 ;
34233 int val4 ;
34234 int ecode4 = 0 ;
34235 PyObject * obj0 = 0 ;
34236 PyObject * obj1 = 0 ;
34237 PyObject * obj2 = 0 ;
34238 PyObject * obj3 = 0 ;
34239 char * kwnames[] = {
34240 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34241 };
34242
34243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34245 if (!SWIG_IsOK(res1)) {
34246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34247 }
34248 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34249 ecode2 = SWIG_AsVal_int(obj1, &val2);
34250 if (!SWIG_IsOK(ecode2)) {
34251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34252 }
34253 arg2 = static_cast< int >(val2);
34254 ecode3 = SWIG_AsVal_int(obj2, &val3);
34255 if (!SWIG_IsOK(ecode3)) {
34256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34257 }
34258 arg3 = static_cast< int >(val3);
34259 ecode4 = SWIG_AsVal_int(obj3, &val4);
34260 if (!SWIG_IsOK(ecode4)) {
34261 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34262 }
34263 arg4 = static_cast< wxDragResult >(val4);
34264 {
34265 PyThreadState* __tstate = wxPyBeginAllowThreads();
34266 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34267 wxPyEndAllowThreads(__tstate);
34268 if (PyErr_Occurred()) SWIG_fail;
34269 }
34270 resultobj = SWIG_From_int(static_cast< int >(result));
34271 return resultobj;
34272 fail:
34273 return NULL;
34274 }
34275
34276
34277 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34278 PyObject *resultobj = 0;
34279 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34280 int arg2 ;
34281 int arg3 ;
34282 wxDragResult arg4 ;
34283 wxDragResult result;
34284 void *argp1 = 0 ;
34285 int res1 = 0 ;
34286 int val2 ;
34287 int ecode2 = 0 ;
34288 int val3 ;
34289 int ecode3 = 0 ;
34290 int val4 ;
34291 int ecode4 = 0 ;
34292 PyObject * obj0 = 0 ;
34293 PyObject * obj1 = 0 ;
34294 PyObject * obj2 = 0 ;
34295 PyObject * obj3 = 0 ;
34296 char * kwnames[] = {
34297 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34298 };
34299
34300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34302 if (!SWIG_IsOK(res1)) {
34303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34304 }
34305 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34306 ecode2 = SWIG_AsVal_int(obj1, &val2);
34307 if (!SWIG_IsOK(ecode2)) {
34308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34309 }
34310 arg2 = static_cast< int >(val2);
34311 ecode3 = SWIG_AsVal_int(obj2, &val3);
34312 if (!SWIG_IsOK(ecode3)) {
34313 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34314 }
34315 arg3 = static_cast< int >(val3);
34316 ecode4 = SWIG_AsVal_int(obj3, &val4);
34317 if (!SWIG_IsOK(ecode4)) {
34318 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34319 }
34320 arg4 = static_cast< wxDragResult >(val4);
34321 {
34322 PyThreadState* __tstate = wxPyBeginAllowThreads();
34323 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34324 wxPyEndAllowThreads(__tstate);
34325 if (PyErr_Occurred()) SWIG_fail;
34326 }
34327 resultobj = SWIG_From_int(static_cast< int >(result));
34328 return resultobj;
34329 fail:
34330 return NULL;
34331 }
34332
34333
34334 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34335 PyObject *resultobj = 0;
34336 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34337 void *argp1 = 0 ;
34338 int res1 = 0 ;
34339 PyObject *swig_obj[1] ;
34340
34341 if (!args) SWIG_fail;
34342 swig_obj[0] = args;
34343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34344 if (!SWIG_IsOK(res1)) {
34345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34346 }
34347 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34348 {
34349 PyThreadState* __tstate = wxPyBeginAllowThreads();
34350 (arg1)->OnLeave();
34351 wxPyEndAllowThreads(__tstate);
34352 if (PyErr_Occurred()) SWIG_fail;
34353 }
34354 resultobj = SWIG_Py_Void();
34355 return resultobj;
34356 fail:
34357 return NULL;
34358 }
34359
34360
34361 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34362 PyObject *resultobj = 0;
34363 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34364 int arg2 ;
34365 int arg3 ;
34366 bool result;
34367 void *argp1 = 0 ;
34368 int res1 = 0 ;
34369 int val2 ;
34370 int ecode2 = 0 ;
34371 int val3 ;
34372 int ecode3 = 0 ;
34373 PyObject * obj0 = 0 ;
34374 PyObject * obj1 = 0 ;
34375 PyObject * obj2 = 0 ;
34376 char * kwnames[] = {
34377 (char *) "self",(char *) "x",(char *) "y", NULL
34378 };
34379
34380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34382 if (!SWIG_IsOK(res1)) {
34383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34384 }
34385 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34386 ecode2 = SWIG_AsVal_int(obj1, &val2);
34387 if (!SWIG_IsOK(ecode2)) {
34388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34389 }
34390 arg2 = static_cast< int >(val2);
34391 ecode3 = SWIG_AsVal_int(obj2, &val3);
34392 if (!SWIG_IsOK(ecode3)) {
34393 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34394 }
34395 arg3 = static_cast< int >(val3);
34396 {
34397 PyThreadState* __tstate = wxPyBeginAllowThreads();
34398 result = (bool)(arg1)->OnDrop(arg2,arg3);
34399 wxPyEndAllowThreads(__tstate);
34400 if (PyErr_Occurred()) SWIG_fail;
34401 }
34402 {
34403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34404 }
34405 return resultobj;
34406 fail:
34407 return NULL;
34408 }
34409
34410
34411 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34412 PyObject *resultobj = 0;
34413 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34414 bool result;
34415 void *argp1 = 0 ;
34416 int res1 = 0 ;
34417 PyObject *swig_obj[1] ;
34418
34419 if (!args) SWIG_fail;
34420 swig_obj[0] = args;
34421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34422 if (!SWIG_IsOK(res1)) {
34423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34424 }
34425 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34426 {
34427 PyThreadState* __tstate = wxPyBeginAllowThreads();
34428 result = (bool)(arg1)->GetData();
34429 wxPyEndAllowThreads(__tstate);
34430 if (PyErr_Occurred()) SWIG_fail;
34431 }
34432 {
34433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34434 }
34435 return resultobj;
34436 fail:
34437 return NULL;
34438 }
34439
34440
34441 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34442 PyObject *resultobj = 0;
34443 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34444 wxDragResult arg2 ;
34445 void *argp1 = 0 ;
34446 int res1 = 0 ;
34447 int val2 ;
34448 int ecode2 = 0 ;
34449 PyObject * obj0 = 0 ;
34450 PyObject * obj1 = 0 ;
34451 char * kwnames[] = {
34452 (char *) "self",(char *) "action", NULL
34453 };
34454
34455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34457 if (!SWIG_IsOK(res1)) {
34458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34459 }
34460 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34461 ecode2 = SWIG_AsVal_int(obj1, &val2);
34462 if (!SWIG_IsOK(ecode2)) {
34463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34464 }
34465 arg2 = static_cast< wxDragResult >(val2);
34466 {
34467 PyThreadState* __tstate = wxPyBeginAllowThreads();
34468 (arg1)->SetDefaultAction(arg2);
34469 wxPyEndAllowThreads(__tstate);
34470 if (PyErr_Occurred()) SWIG_fail;
34471 }
34472 resultobj = SWIG_Py_Void();
34473 return resultobj;
34474 fail:
34475 return NULL;
34476 }
34477
34478
34479 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34480 PyObject *resultobj = 0;
34481 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34482 wxDragResult result;
34483 void *argp1 = 0 ;
34484 int res1 = 0 ;
34485 PyObject *swig_obj[1] ;
34486
34487 if (!args) SWIG_fail;
34488 swig_obj[0] = args;
34489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34490 if (!SWIG_IsOK(res1)) {
34491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34492 }
34493 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34494 {
34495 PyThreadState* __tstate = wxPyBeginAllowThreads();
34496 result = (wxDragResult)(arg1)->GetDefaultAction();
34497 wxPyEndAllowThreads(__tstate);
34498 if (PyErr_Occurred()) SWIG_fail;
34499 }
34500 resultobj = SWIG_From_int(static_cast< int >(result));
34501 return resultobj;
34502 fail:
34503 return NULL;
34504 }
34505
34506
34507 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34508 PyObject *obj;
34509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34510 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34511 return SWIG_Py_Void();
34512 }
34513
34514 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34515 return SWIG_Python_InitShadowInstance(args);
34516 }
34517
34518 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34519 PyObject *resultobj = 0;
34520 wxPyTextDropTarget *result = 0 ;
34521
34522 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34523 {
34524 PyThreadState* __tstate = wxPyBeginAllowThreads();
34525 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34526 wxPyEndAllowThreads(__tstate);
34527 if (PyErr_Occurred()) SWIG_fail;
34528 }
34529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34530 return resultobj;
34531 fail:
34532 return NULL;
34533 }
34534
34535
34536 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34537 PyObject *resultobj = 0;
34538 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34539 PyObject *arg2 = (PyObject *) 0 ;
34540 PyObject *arg3 = (PyObject *) 0 ;
34541 void *argp1 = 0 ;
34542 int res1 = 0 ;
34543 PyObject * obj0 = 0 ;
34544 PyObject * obj1 = 0 ;
34545 PyObject * obj2 = 0 ;
34546 char * kwnames[] = {
34547 (char *) "self",(char *) "self",(char *) "_class", NULL
34548 };
34549
34550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34552 if (!SWIG_IsOK(res1)) {
34553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34554 }
34555 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34556 arg2 = obj1;
34557 arg3 = obj2;
34558 {
34559 PyThreadState* __tstate = wxPyBeginAllowThreads();
34560 (arg1)->_setCallbackInfo(arg2,arg3);
34561 wxPyEndAllowThreads(__tstate);
34562 if (PyErr_Occurred()) SWIG_fail;
34563 }
34564 resultobj = SWIG_Py_Void();
34565 return resultobj;
34566 fail:
34567 return NULL;
34568 }
34569
34570
34571 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34572 PyObject *resultobj = 0;
34573 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34574 int arg2 ;
34575 int arg3 ;
34576 wxString *arg4 = 0 ;
34577 bool result;
34578 void *argp1 = 0 ;
34579 int res1 = 0 ;
34580 int val2 ;
34581 int ecode2 = 0 ;
34582 int val3 ;
34583 int ecode3 = 0 ;
34584 bool temp4 = false ;
34585 PyObject * obj0 = 0 ;
34586 PyObject * obj1 = 0 ;
34587 PyObject * obj2 = 0 ;
34588 PyObject * obj3 = 0 ;
34589 char * kwnames[] = {
34590 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34591 };
34592
34593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34595 if (!SWIG_IsOK(res1)) {
34596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34597 }
34598 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34599 ecode2 = SWIG_AsVal_int(obj1, &val2);
34600 if (!SWIG_IsOK(ecode2)) {
34601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34602 }
34603 arg2 = static_cast< int >(val2);
34604 ecode3 = SWIG_AsVal_int(obj2, &val3);
34605 if (!SWIG_IsOK(ecode3)) {
34606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34607 }
34608 arg3 = static_cast< int >(val3);
34609 {
34610 arg4 = wxString_in_helper(obj3);
34611 if (arg4 == NULL) SWIG_fail;
34612 temp4 = true;
34613 }
34614 {
34615 PyThreadState* __tstate = wxPyBeginAllowThreads();
34616 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34617 wxPyEndAllowThreads(__tstate);
34618 if (PyErr_Occurred()) SWIG_fail;
34619 }
34620 {
34621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34622 }
34623 {
34624 if (temp4)
34625 delete arg4;
34626 }
34627 return resultobj;
34628 fail:
34629 {
34630 if (temp4)
34631 delete arg4;
34632 }
34633 return NULL;
34634 }
34635
34636
34637 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(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_OnEnter",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_OnEnter" "', 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_OnEnter" "', 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_OnEnter" "', 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_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34679 }
34680 arg4 = static_cast< wxDragResult >(val4);
34681 {
34682 PyThreadState* __tstate = wxPyBeginAllowThreads();
34683 result = (wxDragResult)(arg1)->OnEnter(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 *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34695 PyObject *resultobj = 0;
34696 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34697 int arg2 ;
34698 int arg3 ;
34699 wxDragResult arg4 ;
34700 wxDragResult result;
34701 void *argp1 = 0 ;
34702 int res1 = 0 ;
34703 int val2 ;
34704 int ecode2 = 0 ;
34705 int val3 ;
34706 int ecode3 = 0 ;
34707 int val4 ;
34708 int ecode4 = 0 ;
34709 PyObject * obj0 = 0 ;
34710 PyObject * obj1 = 0 ;
34711 PyObject * obj2 = 0 ;
34712 PyObject * obj3 = 0 ;
34713 char * kwnames[] = {
34714 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34715 };
34716
34717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34719 if (!SWIG_IsOK(res1)) {
34720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34721 }
34722 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34723 ecode2 = SWIG_AsVal_int(obj1, &val2);
34724 if (!SWIG_IsOK(ecode2)) {
34725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34726 }
34727 arg2 = static_cast< int >(val2);
34728 ecode3 = SWIG_AsVal_int(obj2, &val3);
34729 if (!SWIG_IsOK(ecode3)) {
34730 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34731 }
34732 arg3 = static_cast< int >(val3);
34733 ecode4 = SWIG_AsVal_int(obj3, &val4);
34734 if (!SWIG_IsOK(ecode4)) {
34735 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34736 }
34737 arg4 = static_cast< wxDragResult >(val4);
34738 {
34739 PyThreadState* __tstate = wxPyBeginAllowThreads();
34740 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34741 wxPyEndAllowThreads(__tstate);
34742 if (PyErr_Occurred()) SWIG_fail;
34743 }
34744 resultobj = SWIG_From_int(static_cast< int >(result));
34745 return resultobj;
34746 fail:
34747 return NULL;
34748 }
34749
34750
34751 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34752 PyObject *resultobj = 0;
34753 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34754 void *argp1 = 0 ;
34755 int res1 = 0 ;
34756 PyObject *swig_obj[1] ;
34757
34758 if (!args) SWIG_fail;
34759 swig_obj[0] = args;
34760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34761 if (!SWIG_IsOK(res1)) {
34762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34763 }
34764 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34765 {
34766 PyThreadState* __tstate = wxPyBeginAllowThreads();
34767 (arg1)->OnLeave();
34768 wxPyEndAllowThreads(__tstate);
34769 if (PyErr_Occurred()) SWIG_fail;
34770 }
34771 resultobj = SWIG_Py_Void();
34772 return resultobj;
34773 fail:
34774 return NULL;
34775 }
34776
34777
34778 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34779 PyObject *resultobj = 0;
34780 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34781 int arg2 ;
34782 int arg3 ;
34783 bool result;
34784 void *argp1 = 0 ;
34785 int res1 = 0 ;
34786 int val2 ;
34787 int ecode2 = 0 ;
34788 int val3 ;
34789 int ecode3 = 0 ;
34790 PyObject * obj0 = 0 ;
34791 PyObject * obj1 = 0 ;
34792 PyObject * obj2 = 0 ;
34793 char * kwnames[] = {
34794 (char *) "self",(char *) "x",(char *) "y", NULL
34795 };
34796
34797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34799 if (!SWIG_IsOK(res1)) {
34800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34801 }
34802 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34803 ecode2 = SWIG_AsVal_int(obj1, &val2);
34804 if (!SWIG_IsOK(ecode2)) {
34805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34806 }
34807 arg2 = static_cast< int >(val2);
34808 ecode3 = SWIG_AsVal_int(obj2, &val3);
34809 if (!SWIG_IsOK(ecode3)) {
34810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34811 }
34812 arg3 = static_cast< int >(val3);
34813 {
34814 PyThreadState* __tstate = wxPyBeginAllowThreads();
34815 result = (bool)(arg1)->OnDrop(arg2,arg3);
34816 wxPyEndAllowThreads(__tstate);
34817 if (PyErr_Occurred()) SWIG_fail;
34818 }
34819 {
34820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34821 }
34822 return resultobj;
34823 fail:
34824 return NULL;
34825 }
34826
34827
34828 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34829 PyObject *resultobj = 0;
34830 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34831 int arg2 ;
34832 int arg3 ;
34833 wxDragResult arg4 ;
34834 wxDragResult result;
34835 void *argp1 = 0 ;
34836 int res1 = 0 ;
34837 int val2 ;
34838 int ecode2 = 0 ;
34839 int val3 ;
34840 int ecode3 = 0 ;
34841 int val4 ;
34842 int ecode4 = 0 ;
34843 PyObject * obj0 = 0 ;
34844 PyObject * obj1 = 0 ;
34845 PyObject * obj2 = 0 ;
34846 PyObject * obj3 = 0 ;
34847 char * kwnames[] = {
34848 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34849 };
34850
34851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34853 if (!SWIG_IsOK(res1)) {
34854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34855 }
34856 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34857 ecode2 = SWIG_AsVal_int(obj1, &val2);
34858 if (!SWIG_IsOK(ecode2)) {
34859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34860 }
34861 arg2 = static_cast< int >(val2);
34862 ecode3 = SWIG_AsVal_int(obj2, &val3);
34863 if (!SWIG_IsOK(ecode3)) {
34864 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34865 }
34866 arg3 = static_cast< int >(val3);
34867 ecode4 = SWIG_AsVal_int(obj3, &val4);
34868 if (!SWIG_IsOK(ecode4)) {
34869 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34870 }
34871 arg4 = static_cast< wxDragResult >(val4);
34872 {
34873 PyThreadState* __tstate = wxPyBeginAllowThreads();
34874 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34875 wxPyEndAllowThreads(__tstate);
34876 if (PyErr_Occurred()) SWIG_fail;
34877 }
34878 resultobj = SWIG_From_int(static_cast< int >(result));
34879 return resultobj;
34880 fail:
34881 return NULL;
34882 }
34883
34884
34885 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34886 PyObject *obj;
34887 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34888 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34889 return SWIG_Py_Void();
34890 }
34891
34892 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34893 return SWIG_Python_InitShadowInstance(args);
34894 }
34895
34896 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34897 PyObject *resultobj = 0;
34898 wxPyFileDropTarget *result = 0 ;
34899
34900 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34901 {
34902 PyThreadState* __tstate = wxPyBeginAllowThreads();
34903 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34904 wxPyEndAllowThreads(__tstate);
34905 if (PyErr_Occurred()) SWIG_fail;
34906 }
34907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34908 return resultobj;
34909 fail:
34910 return NULL;
34911 }
34912
34913
34914 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34915 PyObject *resultobj = 0;
34916 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34917 PyObject *arg2 = (PyObject *) 0 ;
34918 PyObject *arg3 = (PyObject *) 0 ;
34919 void *argp1 = 0 ;
34920 int res1 = 0 ;
34921 PyObject * obj0 = 0 ;
34922 PyObject * obj1 = 0 ;
34923 PyObject * obj2 = 0 ;
34924 char * kwnames[] = {
34925 (char *) "self",(char *) "self",(char *) "_class", NULL
34926 };
34927
34928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34930 if (!SWIG_IsOK(res1)) {
34931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34932 }
34933 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34934 arg2 = obj1;
34935 arg3 = obj2;
34936 {
34937 PyThreadState* __tstate = wxPyBeginAllowThreads();
34938 (arg1)->_setCallbackInfo(arg2,arg3);
34939 wxPyEndAllowThreads(__tstate);
34940 if (PyErr_Occurred()) SWIG_fail;
34941 }
34942 resultobj = SWIG_Py_Void();
34943 return resultobj;
34944 fail:
34945 return NULL;
34946 }
34947
34948
34949 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34950 PyObject *resultobj = 0;
34951 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34952 int arg2 ;
34953 int arg3 ;
34954 wxArrayString *arg4 = 0 ;
34955 bool result;
34956 void *argp1 = 0 ;
34957 int res1 = 0 ;
34958 int val2 ;
34959 int ecode2 = 0 ;
34960 int val3 ;
34961 int ecode3 = 0 ;
34962 bool temp4 = false ;
34963 PyObject * obj0 = 0 ;
34964 PyObject * obj1 = 0 ;
34965 PyObject * obj2 = 0 ;
34966 PyObject * obj3 = 0 ;
34967 char * kwnames[] = {
34968 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
34969 };
34970
34971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34973 if (!SWIG_IsOK(res1)) {
34974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34975 }
34976 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34977 ecode2 = SWIG_AsVal_int(obj1, &val2);
34978 if (!SWIG_IsOK(ecode2)) {
34979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
34980 }
34981 arg2 = static_cast< int >(val2);
34982 ecode3 = SWIG_AsVal_int(obj2, &val3);
34983 if (!SWIG_IsOK(ecode3)) {
34984 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
34985 }
34986 arg3 = static_cast< int >(val3);
34987 {
34988 if (! PySequence_Check(obj3)) {
34989 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
34990 SWIG_fail;
34991 }
34992 arg4 = new wxArrayString;
34993 temp4 = true;
34994 int i, len=PySequence_Length(obj3);
34995 for (i=0; i<len; i++) {
34996 PyObject* item = PySequence_GetItem(obj3, i);
34997 wxString* s = wxString_in_helper(item);
34998 if (PyErr_Occurred()) SWIG_fail;
34999 arg4->Add(*s);
35000 delete s;
35001 Py_DECREF(item);
35002 }
35003 }
35004 {
35005 PyThreadState* __tstate = wxPyBeginAllowThreads();
35006 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
35007 wxPyEndAllowThreads(__tstate);
35008 if (PyErr_Occurred()) SWIG_fail;
35009 }
35010 {
35011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35012 }
35013 {
35014 if (temp4) delete arg4;
35015 }
35016 return resultobj;
35017 fail:
35018 {
35019 if (temp4) delete arg4;
35020 }
35021 return NULL;
35022 }
35023
35024
35025 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(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_OnEnter",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_OnEnter" "', 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_OnEnter" "', 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_OnEnter" "', 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_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35067 }
35068 arg4 = static_cast< wxDragResult >(val4);
35069 {
35070 PyThreadState* __tstate = wxPyBeginAllowThreads();
35071 result = (wxDragResult)(arg1)->OnEnter(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 *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35083 PyObject *resultobj = 0;
35084 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35085 int arg2 ;
35086 int arg3 ;
35087 wxDragResult arg4 ;
35088 wxDragResult result;
35089 void *argp1 = 0 ;
35090 int res1 = 0 ;
35091 int val2 ;
35092 int ecode2 = 0 ;
35093 int val3 ;
35094 int ecode3 = 0 ;
35095 int val4 ;
35096 int ecode4 = 0 ;
35097 PyObject * obj0 = 0 ;
35098 PyObject * obj1 = 0 ;
35099 PyObject * obj2 = 0 ;
35100 PyObject * obj3 = 0 ;
35101 char * kwnames[] = {
35102 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35103 };
35104
35105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35107 if (!SWIG_IsOK(res1)) {
35108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35109 }
35110 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35111 ecode2 = SWIG_AsVal_int(obj1, &val2);
35112 if (!SWIG_IsOK(ecode2)) {
35113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35114 }
35115 arg2 = static_cast< int >(val2);
35116 ecode3 = SWIG_AsVal_int(obj2, &val3);
35117 if (!SWIG_IsOK(ecode3)) {
35118 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35119 }
35120 arg3 = static_cast< int >(val3);
35121 ecode4 = SWIG_AsVal_int(obj3, &val4);
35122 if (!SWIG_IsOK(ecode4)) {
35123 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35124 }
35125 arg4 = static_cast< wxDragResult >(val4);
35126 {
35127 PyThreadState* __tstate = wxPyBeginAllowThreads();
35128 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35129 wxPyEndAllowThreads(__tstate);
35130 if (PyErr_Occurred()) SWIG_fail;
35131 }
35132 resultobj = SWIG_From_int(static_cast< int >(result));
35133 return resultobj;
35134 fail:
35135 return NULL;
35136 }
35137
35138
35139 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35140 PyObject *resultobj = 0;
35141 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35142 void *argp1 = 0 ;
35143 int res1 = 0 ;
35144 PyObject *swig_obj[1] ;
35145
35146 if (!args) SWIG_fail;
35147 swig_obj[0] = args;
35148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35149 if (!SWIG_IsOK(res1)) {
35150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35151 }
35152 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35153 {
35154 PyThreadState* __tstate = wxPyBeginAllowThreads();
35155 (arg1)->OnLeave();
35156 wxPyEndAllowThreads(__tstate);
35157 if (PyErr_Occurred()) SWIG_fail;
35158 }
35159 resultobj = SWIG_Py_Void();
35160 return resultobj;
35161 fail:
35162 return NULL;
35163 }
35164
35165
35166 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35167 PyObject *resultobj = 0;
35168 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35169 int arg2 ;
35170 int arg3 ;
35171 bool result;
35172 void *argp1 = 0 ;
35173 int res1 = 0 ;
35174 int val2 ;
35175 int ecode2 = 0 ;
35176 int val3 ;
35177 int ecode3 = 0 ;
35178 PyObject * obj0 = 0 ;
35179 PyObject * obj1 = 0 ;
35180 PyObject * obj2 = 0 ;
35181 char * kwnames[] = {
35182 (char *) "self",(char *) "x",(char *) "y", NULL
35183 };
35184
35185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35187 if (!SWIG_IsOK(res1)) {
35188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35189 }
35190 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35191 ecode2 = SWIG_AsVal_int(obj1, &val2);
35192 if (!SWIG_IsOK(ecode2)) {
35193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35194 }
35195 arg2 = static_cast< int >(val2);
35196 ecode3 = SWIG_AsVal_int(obj2, &val3);
35197 if (!SWIG_IsOK(ecode3)) {
35198 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35199 }
35200 arg3 = static_cast< int >(val3);
35201 {
35202 PyThreadState* __tstate = wxPyBeginAllowThreads();
35203 result = (bool)(arg1)->OnDrop(arg2,arg3);
35204 wxPyEndAllowThreads(__tstate);
35205 if (PyErr_Occurred()) SWIG_fail;
35206 }
35207 {
35208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35209 }
35210 return resultobj;
35211 fail:
35212 return NULL;
35213 }
35214
35215
35216 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35217 PyObject *resultobj = 0;
35218 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35219 int arg2 ;
35220 int arg3 ;
35221 wxDragResult arg4 ;
35222 wxDragResult result;
35223 void *argp1 = 0 ;
35224 int res1 = 0 ;
35225 int val2 ;
35226 int ecode2 = 0 ;
35227 int val3 ;
35228 int ecode3 = 0 ;
35229 int val4 ;
35230 int ecode4 = 0 ;
35231 PyObject * obj0 = 0 ;
35232 PyObject * obj1 = 0 ;
35233 PyObject * obj2 = 0 ;
35234 PyObject * obj3 = 0 ;
35235 char * kwnames[] = {
35236 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35237 };
35238
35239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35241 if (!SWIG_IsOK(res1)) {
35242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35243 }
35244 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35245 ecode2 = SWIG_AsVal_int(obj1, &val2);
35246 if (!SWIG_IsOK(ecode2)) {
35247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35248 }
35249 arg2 = static_cast< int >(val2);
35250 ecode3 = SWIG_AsVal_int(obj2, &val3);
35251 if (!SWIG_IsOK(ecode3)) {
35252 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35253 }
35254 arg3 = static_cast< int >(val3);
35255 ecode4 = SWIG_AsVal_int(obj3, &val4);
35256 if (!SWIG_IsOK(ecode4)) {
35257 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35258 }
35259 arg4 = static_cast< wxDragResult >(val4);
35260 {
35261 PyThreadState* __tstate = wxPyBeginAllowThreads();
35262 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35263 wxPyEndAllowThreads(__tstate);
35264 if (PyErr_Occurred()) SWIG_fail;
35265 }
35266 resultobj = SWIG_From_int(static_cast< int >(result));
35267 return resultobj;
35268 fail:
35269 return NULL;
35270 }
35271
35272
35273 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35274 PyObject *obj;
35275 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35276 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35277 return SWIG_Py_Void();
35278 }
35279
35280 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35281 return SWIG_Python_InitShadowInstance(args);
35282 }
35283
35284 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35285 PyObject *resultobj = 0;
35286 wxClipboard *result = 0 ;
35287
35288 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35289 {
35290 PyThreadState* __tstate = wxPyBeginAllowThreads();
35291 result = (wxClipboard *)new wxClipboard();
35292 wxPyEndAllowThreads(__tstate);
35293 if (PyErr_Occurred()) SWIG_fail;
35294 }
35295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35296 return resultobj;
35297 fail:
35298 return NULL;
35299 }
35300
35301
35302 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35303 PyObject *resultobj = 0;
35304 wxClipboard *arg1 = (wxClipboard *) 0 ;
35305 void *argp1 = 0 ;
35306 int res1 = 0 ;
35307 PyObject *swig_obj[1] ;
35308
35309 if (!args) SWIG_fail;
35310 swig_obj[0] = args;
35311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35312 if (!SWIG_IsOK(res1)) {
35313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35314 }
35315 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35316 {
35317 PyThreadState* __tstate = wxPyBeginAllowThreads();
35318 delete arg1;
35319
35320 wxPyEndAllowThreads(__tstate);
35321 if (PyErr_Occurred()) SWIG_fail;
35322 }
35323 resultobj = SWIG_Py_Void();
35324 return resultobj;
35325 fail:
35326 return NULL;
35327 }
35328
35329
35330 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35331 PyObject *resultobj = 0;
35332 wxClipboard *arg1 = (wxClipboard *) 0 ;
35333 bool result;
35334 void *argp1 = 0 ;
35335 int res1 = 0 ;
35336 PyObject *swig_obj[1] ;
35337
35338 if (!args) SWIG_fail;
35339 swig_obj[0] = args;
35340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35341 if (!SWIG_IsOK(res1)) {
35342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35343 }
35344 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35345 {
35346 PyThreadState* __tstate = wxPyBeginAllowThreads();
35347 result = (bool)(arg1)->Open();
35348 wxPyEndAllowThreads(__tstate);
35349 if (PyErr_Occurred()) SWIG_fail;
35350 }
35351 {
35352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35353 }
35354 return resultobj;
35355 fail:
35356 return NULL;
35357 }
35358
35359
35360 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35361 PyObject *resultobj = 0;
35362 wxClipboard *arg1 = (wxClipboard *) 0 ;
35363 void *argp1 = 0 ;
35364 int res1 = 0 ;
35365 PyObject *swig_obj[1] ;
35366
35367 if (!args) SWIG_fail;
35368 swig_obj[0] = args;
35369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35370 if (!SWIG_IsOK(res1)) {
35371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35372 }
35373 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35374 {
35375 PyThreadState* __tstate = wxPyBeginAllowThreads();
35376 (arg1)->Close();
35377 wxPyEndAllowThreads(__tstate);
35378 if (PyErr_Occurred()) SWIG_fail;
35379 }
35380 resultobj = SWIG_Py_Void();
35381 return resultobj;
35382 fail:
35383 return NULL;
35384 }
35385
35386
35387 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35388 PyObject *resultobj = 0;
35389 wxClipboard *arg1 = (wxClipboard *) 0 ;
35390 bool result;
35391 void *argp1 = 0 ;
35392 int res1 = 0 ;
35393 PyObject *swig_obj[1] ;
35394
35395 if (!args) SWIG_fail;
35396 swig_obj[0] = args;
35397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35398 if (!SWIG_IsOK(res1)) {
35399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35400 }
35401 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35402 {
35403 PyThreadState* __tstate = wxPyBeginAllowThreads();
35404 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35405 wxPyEndAllowThreads(__tstate);
35406 if (PyErr_Occurred()) SWIG_fail;
35407 }
35408 {
35409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35410 }
35411 return resultobj;
35412 fail:
35413 return NULL;
35414 }
35415
35416
35417 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35418 PyObject *resultobj = 0;
35419 wxClipboard *arg1 = (wxClipboard *) 0 ;
35420 wxDataObject *arg2 = (wxDataObject *) 0 ;
35421 bool result;
35422 void *argp1 = 0 ;
35423 int res1 = 0 ;
35424 int res2 = 0 ;
35425 PyObject * obj0 = 0 ;
35426 PyObject * obj1 = 0 ;
35427 char * kwnames[] = {
35428 (char *) "self",(char *) "data", NULL
35429 };
35430
35431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35433 if (!SWIG_IsOK(res1)) {
35434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35435 }
35436 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35437 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35438 if (!SWIG_IsOK(res2)) {
35439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35440 }
35441 {
35442 PyThreadState* __tstate = wxPyBeginAllowThreads();
35443 result = (bool)(arg1)->AddData(arg2);
35444 wxPyEndAllowThreads(__tstate);
35445 if (PyErr_Occurred()) SWIG_fail;
35446 }
35447 {
35448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35449 }
35450 return resultobj;
35451 fail:
35452 return NULL;
35453 }
35454
35455
35456 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35457 PyObject *resultobj = 0;
35458 wxClipboard *arg1 = (wxClipboard *) 0 ;
35459 wxDataObject *arg2 = (wxDataObject *) 0 ;
35460 bool result;
35461 void *argp1 = 0 ;
35462 int res1 = 0 ;
35463 int res2 = 0 ;
35464 PyObject * obj0 = 0 ;
35465 PyObject * obj1 = 0 ;
35466 char * kwnames[] = {
35467 (char *) "self",(char *) "data", NULL
35468 };
35469
35470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35472 if (!SWIG_IsOK(res1)) {
35473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35474 }
35475 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35476 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35477 if (!SWIG_IsOK(res2)) {
35478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35479 }
35480 {
35481 PyThreadState* __tstate = wxPyBeginAllowThreads();
35482 result = (bool)(arg1)->SetData(arg2);
35483 wxPyEndAllowThreads(__tstate);
35484 if (PyErr_Occurred()) SWIG_fail;
35485 }
35486 {
35487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35488 }
35489 return resultobj;
35490 fail:
35491 return NULL;
35492 }
35493
35494
35495 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35496 PyObject *resultobj = 0;
35497 wxClipboard *arg1 = (wxClipboard *) 0 ;
35498 wxDataFormat *arg2 = 0 ;
35499 bool result;
35500 void *argp1 = 0 ;
35501 int res1 = 0 ;
35502 void *argp2 = 0 ;
35503 int res2 = 0 ;
35504 PyObject * obj0 = 0 ;
35505 PyObject * obj1 = 0 ;
35506 char * kwnames[] = {
35507 (char *) "self",(char *) "format", NULL
35508 };
35509
35510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35512 if (!SWIG_IsOK(res1)) {
35513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35514 }
35515 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35516 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35517 if (!SWIG_IsOK(res2)) {
35518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35519 }
35520 if (!argp2) {
35521 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35522 }
35523 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35524 {
35525 PyThreadState* __tstate = wxPyBeginAllowThreads();
35526 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35527 wxPyEndAllowThreads(__tstate);
35528 if (PyErr_Occurred()) SWIG_fail;
35529 }
35530 {
35531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35532 }
35533 return resultobj;
35534 fail:
35535 return NULL;
35536 }
35537
35538
35539 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35540 PyObject *resultobj = 0;
35541 wxClipboard *arg1 = (wxClipboard *) 0 ;
35542 wxDataObject *arg2 = 0 ;
35543 bool result;
35544 void *argp1 = 0 ;
35545 int res1 = 0 ;
35546 void *argp2 = 0 ;
35547 int res2 = 0 ;
35548 PyObject * obj0 = 0 ;
35549 PyObject * obj1 = 0 ;
35550 char * kwnames[] = {
35551 (char *) "self",(char *) "data", NULL
35552 };
35553
35554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35556 if (!SWIG_IsOK(res1)) {
35557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35558 }
35559 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35560 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35561 if (!SWIG_IsOK(res2)) {
35562 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35563 }
35564 if (!argp2) {
35565 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35566 }
35567 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35568 {
35569 PyThreadState* __tstate = wxPyBeginAllowThreads();
35570 result = (bool)(arg1)->GetData(*arg2);
35571 wxPyEndAllowThreads(__tstate);
35572 if (PyErr_Occurred()) SWIG_fail;
35573 }
35574 {
35575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35576 }
35577 return resultobj;
35578 fail:
35579 return NULL;
35580 }
35581
35582
35583 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35584 PyObject *resultobj = 0;
35585 wxClipboard *arg1 = (wxClipboard *) 0 ;
35586 void *argp1 = 0 ;
35587 int res1 = 0 ;
35588 PyObject *swig_obj[1] ;
35589
35590 if (!args) SWIG_fail;
35591 swig_obj[0] = args;
35592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35593 if (!SWIG_IsOK(res1)) {
35594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35595 }
35596 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35597 {
35598 PyThreadState* __tstate = wxPyBeginAllowThreads();
35599 (arg1)->Clear();
35600 wxPyEndAllowThreads(__tstate);
35601 if (PyErr_Occurred()) SWIG_fail;
35602 }
35603 resultobj = SWIG_Py_Void();
35604 return resultobj;
35605 fail:
35606 return NULL;
35607 }
35608
35609
35610 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35611 PyObject *resultobj = 0;
35612 wxClipboard *arg1 = (wxClipboard *) 0 ;
35613 bool result;
35614 void *argp1 = 0 ;
35615 int res1 = 0 ;
35616 PyObject *swig_obj[1] ;
35617
35618 if (!args) SWIG_fail;
35619 swig_obj[0] = args;
35620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35621 if (!SWIG_IsOK(res1)) {
35622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35623 }
35624 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35625 {
35626 PyThreadState* __tstate = wxPyBeginAllowThreads();
35627 result = (bool)(arg1)->Flush();
35628 wxPyEndAllowThreads(__tstate);
35629 if (PyErr_Occurred()) SWIG_fail;
35630 }
35631 {
35632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35633 }
35634 return resultobj;
35635 fail:
35636 return NULL;
35637 }
35638
35639
35640 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35641 PyObject *resultobj = 0;
35642 wxClipboard *arg1 = (wxClipboard *) 0 ;
35643 bool arg2 = (bool) true ;
35644 void *argp1 = 0 ;
35645 int res1 = 0 ;
35646 bool val2 ;
35647 int ecode2 = 0 ;
35648 PyObject * obj0 = 0 ;
35649 PyObject * obj1 = 0 ;
35650 char * kwnames[] = {
35651 (char *) "self",(char *) "primary", NULL
35652 };
35653
35654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35656 if (!SWIG_IsOK(res1)) {
35657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35658 }
35659 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35660 if (obj1) {
35661 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35662 if (!SWIG_IsOK(ecode2)) {
35663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35664 }
35665 arg2 = static_cast< bool >(val2);
35666 }
35667 {
35668 PyThreadState* __tstate = wxPyBeginAllowThreads();
35669 (arg1)->UsePrimarySelection(arg2);
35670 wxPyEndAllowThreads(__tstate);
35671 if (PyErr_Occurred()) SWIG_fail;
35672 }
35673 resultobj = SWIG_Py_Void();
35674 return resultobj;
35675 fail:
35676 return NULL;
35677 }
35678
35679
35680 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35681 PyObject *resultobj = 0;
35682 wxClipboard *result = 0 ;
35683
35684 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35685 {
35686 PyThreadState* __tstate = wxPyBeginAllowThreads();
35687 result = (wxClipboard *)wxClipboard::Get();
35688 wxPyEndAllowThreads(__tstate);
35689 if (PyErr_Occurred()) SWIG_fail;
35690 }
35691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35692 return resultobj;
35693 fail:
35694 return NULL;
35695 }
35696
35697
35698 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35699 PyObject *obj;
35700 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35701 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35702 return SWIG_Py_Void();
35703 }
35704
35705 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35706 return SWIG_Python_InitShadowInstance(args);
35707 }
35708
35709 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35710 PyObject *resultobj = 0;
35711 wxClipboard *arg1 = (wxClipboard *) NULL ;
35712 wxClipboardLocker *result = 0 ;
35713 void *argp1 = 0 ;
35714 int res1 = 0 ;
35715 PyObject * obj0 = 0 ;
35716 char * kwnames[] = {
35717 (char *) "clipboard", NULL
35718 };
35719
35720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35721 if (obj0) {
35722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35723 if (!SWIG_IsOK(res1)) {
35724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35725 }
35726 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35727 }
35728 {
35729 PyThreadState* __tstate = wxPyBeginAllowThreads();
35730 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35731 wxPyEndAllowThreads(__tstate);
35732 if (PyErr_Occurred()) SWIG_fail;
35733 }
35734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35735 return resultobj;
35736 fail:
35737 return NULL;
35738 }
35739
35740
35741 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35742 PyObject *resultobj = 0;
35743 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35744 void *argp1 = 0 ;
35745 int res1 = 0 ;
35746 PyObject *swig_obj[1] ;
35747
35748 if (!args) SWIG_fail;
35749 swig_obj[0] = args;
35750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35751 if (!SWIG_IsOK(res1)) {
35752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35753 }
35754 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35755 {
35756 PyThreadState* __tstate = wxPyBeginAllowThreads();
35757 delete arg1;
35758
35759 wxPyEndAllowThreads(__tstate);
35760 if (PyErr_Occurred()) SWIG_fail;
35761 }
35762 resultobj = SWIG_Py_Void();
35763 return resultobj;
35764 fail:
35765 return NULL;
35766 }
35767
35768
35769 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35770 PyObject *resultobj = 0;
35771 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35772 bool result;
35773 void *argp1 = 0 ;
35774 int res1 = 0 ;
35775 PyObject *swig_obj[1] ;
35776
35777 if (!args) SWIG_fail;
35778 swig_obj[0] = args;
35779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35780 if (!SWIG_IsOK(res1)) {
35781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35782 }
35783 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35784 {
35785 PyThreadState* __tstate = wxPyBeginAllowThreads();
35786 result = (bool)wxClipboardLocker___nonzero__(arg1);
35787 wxPyEndAllowThreads(__tstate);
35788 if (PyErr_Occurred()) SWIG_fail;
35789 }
35790 {
35791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35792 }
35793 return resultobj;
35794 fail:
35795 return NULL;
35796 }
35797
35798
35799 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35800 PyObject *obj;
35801 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35802 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35803 return SWIG_Py_Void();
35804 }
35805
35806 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35807 return SWIG_Python_InitShadowInstance(args);
35808 }
35809
35810 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35811 PyObject *resultobj = 0;
35812 int arg1 = (int) 0 ;
35813 int arg2 = (int) 0 ;
35814 int arg3 = (int) 0 ;
35815 int arg4 = (int) 0 ;
35816 wxVideoMode *result = 0 ;
35817 int val1 ;
35818 int ecode1 = 0 ;
35819 int val2 ;
35820 int ecode2 = 0 ;
35821 int val3 ;
35822 int ecode3 = 0 ;
35823 int val4 ;
35824 int ecode4 = 0 ;
35825 PyObject * obj0 = 0 ;
35826 PyObject * obj1 = 0 ;
35827 PyObject * obj2 = 0 ;
35828 PyObject * obj3 = 0 ;
35829 char * kwnames[] = {
35830 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35831 };
35832
35833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35834 if (obj0) {
35835 ecode1 = SWIG_AsVal_int(obj0, &val1);
35836 if (!SWIG_IsOK(ecode1)) {
35837 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35838 }
35839 arg1 = static_cast< int >(val1);
35840 }
35841 if (obj1) {
35842 ecode2 = SWIG_AsVal_int(obj1, &val2);
35843 if (!SWIG_IsOK(ecode2)) {
35844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35845 }
35846 arg2 = static_cast< int >(val2);
35847 }
35848 if (obj2) {
35849 ecode3 = SWIG_AsVal_int(obj2, &val3);
35850 if (!SWIG_IsOK(ecode3)) {
35851 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35852 }
35853 arg3 = static_cast< int >(val3);
35854 }
35855 if (obj3) {
35856 ecode4 = SWIG_AsVal_int(obj3, &val4);
35857 if (!SWIG_IsOK(ecode4)) {
35858 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35859 }
35860 arg4 = static_cast< int >(val4);
35861 }
35862 {
35863 PyThreadState* __tstate = wxPyBeginAllowThreads();
35864 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35865 wxPyEndAllowThreads(__tstate);
35866 if (PyErr_Occurred()) SWIG_fail;
35867 }
35868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35869 return resultobj;
35870 fail:
35871 return NULL;
35872 }
35873
35874
35875 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35876 PyObject *resultobj = 0;
35877 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35878 void *argp1 = 0 ;
35879 int res1 = 0 ;
35880 PyObject *swig_obj[1] ;
35881
35882 if (!args) SWIG_fail;
35883 swig_obj[0] = args;
35884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35885 if (!SWIG_IsOK(res1)) {
35886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35887 }
35888 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35889 {
35890 PyThreadState* __tstate = wxPyBeginAllowThreads();
35891 delete arg1;
35892
35893 wxPyEndAllowThreads(__tstate);
35894 if (PyErr_Occurred()) SWIG_fail;
35895 }
35896 resultobj = SWIG_Py_Void();
35897 return resultobj;
35898 fail:
35899 return NULL;
35900 }
35901
35902
35903 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35904 PyObject *resultobj = 0;
35905 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35906 wxVideoMode *arg2 = 0 ;
35907 bool result;
35908 void *argp1 = 0 ;
35909 int res1 = 0 ;
35910 void *argp2 = 0 ;
35911 int res2 = 0 ;
35912 PyObject * obj0 = 0 ;
35913 PyObject * obj1 = 0 ;
35914 char * kwnames[] = {
35915 (char *) "self",(char *) "other", NULL
35916 };
35917
35918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35920 if (!SWIG_IsOK(res1)) {
35921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35922 }
35923 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35924 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35925 if (!SWIG_IsOK(res2)) {
35926 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35927 }
35928 if (!argp2) {
35929 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35930 }
35931 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35932 {
35933 PyThreadState* __tstate = wxPyBeginAllowThreads();
35934 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35935 wxPyEndAllowThreads(__tstate);
35936 if (PyErr_Occurred()) SWIG_fail;
35937 }
35938 {
35939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35940 }
35941 return resultobj;
35942 fail:
35943 return NULL;
35944 }
35945
35946
35947 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35948 PyObject *resultobj = 0;
35949 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35950 int result;
35951 void *argp1 = 0 ;
35952 int res1 = 0 ;
35953 PyObject *swig_obj[1] ;
35954
35955 if (!args) SWIG_fail;
35956 swig_obj[0] = args;
35957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35958 if (!SWIG_IsOK(res1)) {
35959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35960 }
35961 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35962 {
35963 PyThreadState* __tstate = wxPyBeginAllowThreads();
35964 result = (int)((wxVideoMode const *)arg1)->GetWidth();
35965 wxPyEndAllowThreads(__tstate);
35966 if (PyErr_Occurred()) SWIG_fail;
35967 }
35968 resultobj = SWIG_From_int(static_cast< int >(result));
35969 return resultobj;
35970 fail:
35971 return NULL;
35972 }
35973
35974
35975 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35976 PyObject *resultobj = 0;
35977 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35978 int result;
35979 void *argp1 = 0 ;
35980 int res1 = 0 ;
35981 PyObject *swig_obj[1] ;
35982
35983 if (!args) SWIG_fail;
35984 swig_obj[0] = args;
35985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35986 if (!SWIG_IsOK(res1)) {
35987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35988 }
35989 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35990 {
35991 PyThreadState* __tstate = wxPyBeginAllowThreads();
35992 result = (int)((wxVideoMode const *)arg1)->GetHeight();
35993 wxPyEndAllowThreads(__tstate);
35994 if (PyErr_Occurred()) SWIG_fail;
35995 }
35996 resultobj = SWIG_From_int(static_cast< int >(result));
35997 return resultobj;
35998 fail:
35999 return NULL;
36000 }
36001
36002
36003 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36004 PyObject *resultobj = 0;
36005 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36006 int result;
36007 void *argp1 = 0 ;
36008 int res1 = 0 ;
36009 PyObject *swig_obj[1] ;
36010
36011 if (!args) SWIG_fail;
36012 swig_obj[0] = args;
36013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36014 if (!SWIG_IsOK(res1)) {
36015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36016 }
36017 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36018 {
36019 PyThreadState* __tstate = wxPyBeginAllowThreads();
36020 result = (int)((wxVideoMode const *)arg1)->GetDepth();
36021 wxPyEndAllowThreads(__tstate);
36022 if (PyErr_Occurred()) SWIG_fail;
36023 }
36024 resultobj = SWIG_From_int(static_cast< int >(result));
36025 return resultobj;
36026 fail:
36027 return NULL;
36028 }
36029
36030
36031 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36032 PyObject *resultobj = 0;
36033 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36034 bool result;
36035 void *argp1 = 0 ;
36036 int res1 = 0 ;
36037 PyObject *swig_obj[1] ;
36038
36039 if (!args) SWIG_fail;
36040 swig_obj[0] = args;
36041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36042 if (!SWIG_IsOK(res1)) {
36043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36044 }
36045 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36046 {
36047 PyThreadState* __tstate = wxPyBeginAllowThreads();
36048 result = (bool)((wxVideoMode const *)arg1)->IsOk();
36049 wxPyEndAllowThreads(__tstate);
36050 if (PyErr_Occurred()) SWIG_fail;
36051 }
36052 {
36053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36054 }
36055 return resultobj;
36056 fail:
36057 return NULL;
36058 }
36059
36060
36061 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36062 PyObject *resultobj = 0;
36063 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36064 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36065 bool result;
36066 void *argp1 = 0 ;
36067 int res1 = 0 ;
36068 void *argp2 = 0 ;
36069 int res2 = 0 ;
36070 PyObject * obj0 = 0 ;
36071 PyObject * obj1 = 0 ;
36072 char * kwnames[] = {
36073 (char *) "self",(char *) "other", NULL
36074 };
36075
36076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36078 if (!SWIG_IsOK(res1)) {
36079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36080 }
36081 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36082 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36083 if (!SWIG_IsOK(res2)) {
36084 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36085 }
36086 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36087 {
36088 PyThreadState* __tstate = wxPyBeginAllowThreads();
36089 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36090 wxPyEndAllowThreads(__tstate);
36091 if (PyErr_Occurred()) SWIG_fail;
36092 }
36093 {
36094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36095 }
36096 return resultobj;
36097 fail:
36098 return NULL;
36099 }
36100
36101
36102 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36103 PyObject *resultobj = 0;
36104 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36105 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36106 bool result;
36107 void *argp1 = 0 ;
36108 int res1 = 0 ;
36109 void *argp2 = 0 ;
36110 int res2 = 0 ;
36111 PyObject * obj0 = 0 ;
36112 PyObject * obj1 = 0 ;
36113 char * kwnames[] = {
36114 (char *) "self",(char *) "other", NULL
36115 };
36116
36117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36119 if (!SWIG_IsOK(res1)) {
36120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36121 }
36122 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36123 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36124 if (!SWIG_IsOK(res2)) {
36125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36126 }
36127 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36128 {
36129 PyThreadState* __tstate = wxPyBeginAllowThreads();
36130 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36131 wxPyEndAllowThreads(__tstate);
36132 if (PyErr_Occurred()) SWIG_fail;
36133 }
36134 {
36135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36136 }
36137 return resultobj;
36138 fail:
36139 return NULL;
36140 }
36141
36142
36143 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36144 PyObject *resultobj = 0;
36145 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36146 int arg2 ;
36147 void *argp1 = 0 ;
36148 int res1 = 0 ;
36149 int val2 ;
36150 int ecode2 = 0 ;
36151 PyObject *swig_obj[2] ;
36152
36153 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36155 if (!SWIG_IsOK(res1)) {
36156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36157 }
36158 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36159 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36160 if (!SWIG_IsOK(ecode2)) {
36161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36162 }
36163 arg2 = static_cast< int >(val2);
36164 if (arg1) (arg1)->w = arg2;
36165
36166 resultobj = SWIG_Py_Void();
36167 return resultobj;
36168 fail:
36169 return NULL;
36170 }
36171
36172
36173 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36174 PyObject *resultobj = 0;
36175 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36176 int result;
36177 void *argp1 = 0 ;
36178 int res1 = 0 ;
36179 PyObject *swig_obj[1] ;
36180
36181 if (!args) SWIG_fail;
36182 swig_obj[0] = args;
36183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36184 if (!SWIG_IsOK(res1)) {
36185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36186 }
36187 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36188 result = (int) ((arg1)->w);
36189 resultobj = SWIG_From_int(static_cast< int >(result));
36190 return resultobj;
36191 fail:
36192 return NULL;
36193 }
36194
36195
36196 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36197 PyObject *resultobj = 0;
36198 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36199 int arg2 ;
36200 void *argp1 = 0 ;
36201 int res1 = 0 ;
36202 int val2 ;
36203 int ecode2 = 0 ;
36204 PyObject *swig_obj[2] ;
36205
36206 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36208 if (!SWIG_IsOK(res1)) {
36209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36210 }
36211 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36212 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36213 if (!SWIG_IsOK(ecode2)) {
36214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36215 }
36216 arg2 = static_cast< int >(val2);
36217 if (arg1) (arg1)->h = arg2;
36218
36219 resultobj = SWIG_Py_Void();
36220 return resultobj;
36221 fail:
36222 return NULL;
36223 }
36224
36225
36226 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36227 PyObject *resultobj = 0;
36228 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36229 int result;
36230 void *argp1 = 0 ;
36231 int res1 = 0 ;
36232 PyObject *swig_obj[1] ;
36233
36234 if (!args) SWIG_fail;
36235 swig_obj[0] = args;
36236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36237 if (!SWIG_IsOK(res1)) {
36238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36239 }
36240 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36241 result = (int) ((arg1)->h);
36242 resultobj = SWIG_From_int(static_cast< int >(result));
36243 return resultobj;
36244 fail:
36245 return NULL;
36246 }
36247
36248
36249 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36250 PyObject *resultobj = 0;
36251 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36252 int arg2 ;
36253 void *argp1 = 0 ;
36254 int res1 = 0 ;
36255 int val2 ;
36256 int ecode2 = 0 ;
36257 PyObject *swig_obj[2] ;
36258
36259 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36261 if (!SWIG_IsOK(res1)) {
36262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36263 }
36264 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36265 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36266 if (!SWIG_IsOK(ecode2)) {
36267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36268 }
36269 arg2 = static_cast< int >(val2);
36270 if (arg1) (arg1)->bpp = arg2;
36271
36272 resultobj = SWIG_Py_Void();
36273 return resultobj;
36274 fail:
36275 return NULL;
36276 }
36277
36278
36279 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36280 PyObject *resultobj = 0;
36281 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36282 int result;
36283 void *argp1 = 0 ;
36284 int res1 = 0 ;
36285 PyObject *swig_obj[1] ;
36286
36287 if (!args) SWIG_fail;
36288 swig_obj[0] = args;
36289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36290 if (!SWIG_IsOK(res1)) {
36291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36292 }
36293 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36294 result = (int) ((arg1)->bpp);
36295 resultobj = SWIG_From_int(static_cast< int >(result));
36296 return resultobj;
36297 fail:
36298 return NULL;
36299 }
36300
36301
36302 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36303 PyObject *resultobj = 0;
36304 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36305 int arg2 ;
36306 void *argp1 = 0 ;
36307 int res1 = 0 ;
36308 int val2 ;
36309 int ecode2 = 0 ;
36310 PyObject *swig_obj[2] ;
36311
36312 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36314 if (!SWIG_IsOK(res1)) {
36315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36316 }
36317 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36318 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36319 if (!SWIG_IsOK(ecode2)) {
36320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36321 }
36322 arg2 = static_cast< int >(val2);
36323 if (arg1) (arg1)->refresh = arg2;
36324
36325 resultobj = SWIG_Py_Void();
36326 return resultobj;
36327 fail:
36328 return NULL;
36329 }
36330
36331
36332 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36333 PyObject *resultobj = 0;
36334 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36335 int result;
36336 void *argp1 = 0 ;
36337 int res1 = 0 ;
36338 PyObject *swig_obj[1] ;
36339
36340 if (!args) SWIG_fail;
36341 swig_obj[0] = args;
36342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36343 if (!SWIG_IsOK(res1)) {
36344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36345 }
36346 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36347 result = (int) ((arg1)->refresh);
36348 resultobj = SWIG_From_int(static_cast< int >(result));
36349 return resultobj;
36350 fail:
36351 return NULL;
36352 }
36353
36354
36355 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36356 PyObject *obj;
36357 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36358 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36359 return SWIG_Py_Void();
36360 }
36361
36362 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36363 return SWIG_Python_InitShadowInstance(args);
36364 }
36365
36366 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36367 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36368 return 1;
36369 }
36370
36371
36372 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36373 PyObject *pyobj = 0;
36374
36375 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36376 return pyobj;
36377 }
36378
36379
36380 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36381 PyObject *resultobj = 0;
36382 unsigned int arg1 = (unsigned int) 0 ;
36383 wxDisplay *result = 0 ;
36384 unsigned int val1 ;
36385 int ecode1 = 0 ;
36386 PyObject * obj0 = 0 ;
36387 char * kwnames[] = {
36388 (char *) "index", NULL
36389 };
36390
36391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36392 if (obj0) {
36393 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36394 if (!SWIG_IsOK(ecode1)) {
36395 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36396 }
36397 arg1 = static_cast< unsigned int >(val1);
36398 }
36399 {
36400 PyThreadState* __tstate = wxPyBeginAllowThreads();
36401 result = (wxDisplay *)new wxDisplay(arg1);
36402 wxPyEndAllowThreads(__tstate);
36403 if (PyErr_Occurred()) SWIG_fail;
36404 }
36405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36406 return resultobj;
36407 fail:
36408 return NULL;
36409 }
36410
36411
36412 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36413 PyObject *resultobj = 0;
36414 wxDisplay *arg1 = (wxDisplay *) 0 ;
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, SWIG_POINTER_DISOWN | 0 );
36422 if (!SWIG_IsOK(res1)) {
36423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36424 }
36425 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36426 {
36427 PyThreadState* __tstate = wxPyBeginAllowThreads();
36428 delete arg1;
36429
36430 wxPyEndAllowThreads(__tstate);
36431 if (PyErr_Occurred()) SWIG_fail;
36432 }
36433 resultobj = SWIG_Py_Void();
36434 return resultobj;
36435 fail:
36436 return NULL;
36437 }
36438
36439
36440 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36441 PyObject *resultobj = 0;
36442 unsigned int result;
36443
36444 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36445 {
36446 PyThreadState* __tstate = wxPyBeginAllowThreads();
36447 result = (unsigned int)wxDisplay::GetCount();
36448 wxPyEndAllowThreads(__tstate);
36449 if (PyErr_Occurred()) SWIG_fail;
36450 }
36451 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36452 return resultobj;
36453 fail:
36454 return NULL;
36455 }
36456
36457
36458 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36459 PyObject *resultobj = 0;
36460 wxPoint *arg1 = 0 ;
36461 int result;
36462 wxPoint temp1 ;
36463 PyObject * obj0 = 0 ;
36464 char * kwnames[] = {
36465 (char *) "pt", NULL
36466 };
36467
36468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36469 {
36470 arg1 = &temp1;
36471 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36472 }
36473 {
36474 PyThreadState* __tstate = wxPyBeginAllowThreads();
36475 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36476 wxPyEndAllowThreads(__tstate);
36477 if (PyErr_Occurred()) SWIG_fail;
36478 }
36479 resultobj = SWIG_From_int(static_cast< int >(result));
36480 return resultobj;
36481 fail:
36482 return NULL;
36483 }
36484
36485
36486 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36487 PyObject *resultobj = 0;
36488 wxWindow *arg1 = (wxWindow *) 0 ;
36489 int result;
36490 void *argp1 = 0 ;
36491 int res1 = 0 ;
36492 PyObject * obj0 = 0 ;
36493 char * kwnames[] = {
36494 (char *) "window", NULL
36495 };
36496
36497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36499 if (!SWIG_IsOK(res1)) {
36500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36501 }
36502 arg1 = reinterpret_cast< wxWindow * >(argp1);
36503 {
36504 PyThreadState* __tstate = wxPyBeginAllowThreads();
36505 result = (int)wxDisplay::GetFromWindow(arg1);
36506 wxPyEndAllowThreads(__tstate);
36507 if (PyErr_Occurred()) SWIG_fail;
36508 }
36509 resultobj = SWIG_From_int(static_cast< int >(result));
36510 return resultobj;
36511 fail:
36512 return NULL;
36513 }
36514
36515
36516 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36517 PyObject *resultobj = 0;
36518 wxDisplay *arg1 = (wxDisplay *) 0 ;
36519 bool result;
36520 void *argp1 = 0 ;
36521 int res1 = 0 ;
36522 PyObject *swig_obj[1] ;
36523
36524 if (!args) SWIG_fail;
36525 swig_obj[0] = args;
36526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36527 if (!SWIG_IsOK(res1)) {
36528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36529 }
36530 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36531 {
36532 PyThreadState* __tstate = wxPyBeginAllowThreads();
36533 result = (bool)((wxDisplay const *)arg1)->IsOk();
36534 wxPyEndAllowThreads(__tstate);
36535 if (PyErr_Occurred()) SWIG_fail;
36536 }
36537 {
36538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36539 }
36540 return resultobj;
36541 fail:
36542 return NULL;
36543 }
36544
36545
36546 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36547 PyObject *resultobj = 0;
36548 wxDisplay *arg1 = (wxDisplay *) 0 ;
36549 wxRect result;
36550 void *argp1 = 0 ;
36551 int res1 = 0 ;
36552 PyObject *swig_obj[1] ;
36553
36554 if (!args) SWIG_fail;
36555 swig_obj[0] = args;
36556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36557 if (!SWIG_IsOK(res1)) {
36558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36559 }
36560 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36561 {
36562 PyThreadState* __tstate = wxPyBeginAllowThreads();
36563 result = ((wxDisplay const *)arg1)->GetGeometry();
36564 wxPyEndAllowThreads(__tstate);
36565 if (PyErr_Occurred()) SWIG_fail;
36566 }
36567 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36568 return resultobj;
36569 fail:
36570 return NULL;
36571 }
36572
36573
36574 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36575 PyObject *resultobj = 0;
36576 wxDisplay *arg1 = (wxDisplay *) 0 ;
36577 wxRect result;
36578 void *argp1 = 0 ;
36579 int res1 = 0 ;
36580 PyObject *swig_obj[1] ;
36581
36582 if (!args) SWIG_fail;
36583 swig_obj[0] = args;
36584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36585 if (!SWIG_IsOK(res1)) {
36586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36587 }
36588 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36589 {
36590 PyThreadState* __tstate = wxPyBeginAllowThreads();
36591 result = ((wxDisplay const *)arg1)->GetClientArea();
36592 wxPyEndAllowThreads(__tstate);
36593 if (PyErr_Occurred()) SWIG_fail;
36594 }
36595 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36596 return resultobj;
36597 fail:
36598 return NULL;
36599 }
36600
36601
36602 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36603 PyObject *resultobj = 0;
36604 wxDisplay *arg1 = (wxDisplay *) 0 ;
36605 wxString result;
36606 void *argp1 = 0 ;
36607 int res1 = 0 ;
36608 PyObject *swig_obj[1] ;
36609
36610 if (!args) SWIG_fail;
36611 swig_obj[0] = args;
36612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36613 if (!SWIG_IsOK(res1)) {
36614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36615 }
36616 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36617 {
36618 PyThreadState* __tstate = wxPyBeginAllowThreads();
36619 result = ((wxDisplay const *)arg1)->GetName();
36620 wxPyEndAllowThreads(__tstate);
36621 if (PyErr_Occurred()) SWIG_fail;
36622 }
36623 {
36624 #if wxUSE_UNICODE
36625 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36626 #else
36627 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36628 #endif
36629 }
36630 return resultobj;
36631 fail:
36632 return NULL;
36633 }
36634
36635
36636 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36637 PyObject *resultobj = 0;
36638 wxDisplay *arg1 = (wxDisplay *) 0 ;
36639 bool result;
36640 void *argp1 = 0 ;
36641 int res1 = 0 ;
36642 PyObject *swig_obj[1] ;
36643
36644 if (!args) SWIG_fail;
36645 swig_obj[0] = args;
36646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36647 if (!SWIG_IsOK(res1)) {
36648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36649 }
36650 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36651 {
36652 PyThreadState* __tstate = wxPyBeginAllowThreads();
36653 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36654 wxPyEndAllowThreads(__tstate);
36655 if (PyErr_Occurred()) SWIG_fail;
36656 }
36657 {
36658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36659 }
36660 return resultobj;
36661 fail:
36662 return NULL;
36663 }
36664
36665
36666 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36667 PyObject *resultobj = 0;
36668 wxDisplay *arg1 = (wxDisplay *) 0 ;
36669 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36670 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36671 PyObject *result = 0 ;
36672 void *argp1 = 0 ;
36673 int res1 = 0 ;
36674 void *argp2 = 0 ;
36675 int res2 = 0 ;
36676 PyObject * obj0 = 0 ;
36677 PyObject * obj1 = 0 ;
36678 char * kwnames[] = {
36679 (char *) "self",(char *) "mode", NULL
36680 };
36681
36682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36684 if (!SWIG_IsOK(res1)) {
36685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36686 }
36687 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36688 if (obj1) {
36689 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36690 if (!SWIG_IsOK(res2)) {
36691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36692 }
36693 if (!argp2) {
36694 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36695 }
36696 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36697 }
36698 {
36699 PyThreadState* __tstate = wxPyBeginAllowThreads();
36700 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36701 wxPyEndAllowThreads(__tstate);
36702 if (PyErr_Occurred()) SWIG_fail;
36703 }
36704 resultobj = result;
36705 return resultobj;
36706 fail:
36707 return NULL;
36708 }
36709
36710
36711 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36712 PyObject *resultobj = 0;
36713 wxDisplay *arg1 = (wxDisplay *) 0 ;
36714 wxVideoMode result;
36715 void *argp1 = 0 ;
36716 int res1 = 0 ;
36717 PyObject *swig_obj[1] ;
36718
36719 if (!args) SWIG_fail;
36720 swig_obj[0] = args;
36721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36722 if (!SWIG_IsOK(res1)) {
36723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36724 }
36725 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36726 {
36727 PyThreadState* __tstate = wxPyBeginAllowThreads();
36728 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36729 wxPyEndAllowThreads(__tstate);
36730 if (PyErr_Occurred()) SWIG_fail;
36731 }
36732 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36733 return resultobj;
36734 fail:
36735 return NULL;
36736 }
36737
36738
36739 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36740 PyObject *resultobj = 0;
36741 wxDisplay *arg1 = (wxDisplay *) 0 ;
36742 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36743 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36744 bool result;
36745 void *argp1 = 0 ;
36746 int res1 = 0 ;
36747 void *argp2 = 0 ;
36748 int res2 = 0 ;
36749 PyObject * obj0 = 0 ;
36750 PyObject * obj1 = 0 ;
36751 char * kwnames[] = {
36752 (char *) "self",(char *) "mode", NULL
36753 };
36754
36755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36757 if (!SWIG_IsOK(res1)) {
36758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36759 }
36760 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36761 if (obj1) {
36762 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36763 if (!SWIG_IsOK(res2)) {
36764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36765 }
36766 if (!argp2) {
36767 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36768 }
36769 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36770 }
36771 {
36772 PyThreadState* __tstate = wxPyBeginAllowThreads();
36773 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36774 wxPyEndAllowThreads(__tstate);
36775 if (PyErr_Occurred()) SWIG_fail;
36776 }
36777 {
36778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36779 }
36780 return resultobj;
36781 fail:
36782 return NULL;
36783 }
36784
36785
36786 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36787 PyObject *resultobj = 0;
36788 wxDisplay *arg1 = (wxDisplay *) 0 ;
36789 void *argp1 = 0 ;
36790 int res1 = 0 ;
36791 PyObject *swig_obj[1] ;
36792
36793 if (!args) SWIG_fail;
36794 swig_obj[0] = args;
36795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36796 if (!SWIG_IsOK(res1)) {
36797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36798 }
36799 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36800 {
36801 PyThreadState* __tstate = wxPyBeginAllowThreads();
36802 wxDisplay_ResetMode(arg1);
36803 wxPyEndAllowThreads(__tstate);
36804 if (PyErr_Occurred()) SWIG_fail;
36805 }
36806 resultobj = SWIG_Py_Void();
36807 return resultobj;
36808 fail:
36809 return NULL;
36810 }
36811
36812
36813 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36814 PyObject *obj;
36815 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36816 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36817 return SWIG_Py_Void();
36818 }
36819
36820 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36821 return SWIG_Python_InitShadowInstance(args);
36822 }
36823
36824 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36825 PyObject *resultobj = 0;
36826 wxStandardPaths *result = 0 ;
36827
36828 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36829 {
36830 PyThreadState* __tstate = wxPyBeginAllowThreads();
36831 result = (wxStandardPaths *)wxStandardPaths_Get();
36832 wxPyEndAllowThreads(__tstate);
36833 if (PyErr_Occurred()) SWIG_fail;
36834 }
36835 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36836 return resultobj;
36837 fail:
36838 return NULL;
36839 }
36840
36841
36842 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36843 PyObject *resultobj = 0;
36844 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36845 wxString result;
36846 void *argp1 = 0 ;
36847 int res1 = 0 ;
36848 PyObject *swig_obj[1] ;
36849
36850 if (!args) SWIG_fail;
36851 swig_obj[0] = args;
36852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36853 if (!SWIG_IsOK(res1)) {
36854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36855 }
36856 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36857 {
36858 PyThreadState* __tstate = wxPyBeginAllowThreads();
36859 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36860 wxPyEndAllowThreads(__tstate);
36861 if (PyErr_Occurred()) SWIG_fail;
36862 }
36863 {
36864 #if wxUSE_UNICODE
36865 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36866 #else
36867 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36868 #endif
36869 }
36870 return resultobj;
36871 fail:
36872 return NULL;
36873 }
36874
36875
36876 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36877 PyObject *resultobj = 0;
36878 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36879 wxString result;
36880 void *argp1 = 0 ;
36881 int res1 = 0 ;
36882 PyObject *swig_obj[1] ;
36883
36884 if (!args) SWIG_fail;
36885 swig_obj[0] = args;
36886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36887 if (!SWIG_IsOK(res1)) {
36888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36889 }
36890 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36891 {
36892 PyThreadState* __tstate = wxPyBeginAllowThreads();
36893 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36894 wxPyEndAllowThreads(__tstate);
36895 if (PyErr_Occurred()) SWIG_fail;
36896 }
36897 {
36898 #if wxUSE_UNICODE
36899 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36900 #else
36901 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36902 #endif
36903 }
36904 return resultobj;
36905 fail:
36906 return NULL;
36907 }
36908
36909
36910 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36911 PyObject *resultobj = 0;
36912 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36913 wxString result;
36914 void *argp1 = 0 ;
36915 int res1 = 0 ;
36916 PyObject *swig_obj[1] ;
36917
36918 if (!args) SWIG_fail;
36919 swig_obj[0] = args;
36920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36921 if (!SWIG_IsOK(res1)) {
36922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36923 }
36924 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36925 {
36926 PyThreadState* __tstate = wxPyBeginAllowThreads();
36927 result = ((wxStandardPaths const *)arg1)->GetDataDir();
36928 wxPyEndAllowThreads(__tstate);
36929 if (PyErr_Occurred()) SWIG_fail;
36930 }
36931 {
36932 #if wxUSE_UNICODE
36933 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36934 #else
36935 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36936 #endif
36937 }
36938 return resultobj;
36939 fail:
36940 return NULL;
36941 }
36942
36943
36944 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36945 PyObject *resultobj = 0;
36946 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36947 wxString result;
36948 void *argp1 = 0 ;
36949 int res1 = 0 ;
36950 PyObject *swig_obj[1] ;
36951
36952 if (!args) SWIG_fail;
36953 swig_obj[0] = args;
36954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36955 if (!SWIG_IsOK(res1)) {
36956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36957 }
36958 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36959 {
36960 PyThreadState* __tstate = wxPyBeginAllowThreads();
36961 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
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 return resultobj;
36973 fail:
36974 return NULL;
36975 }
36976
36977
36978 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36979 PyObject *resultobj = 0;
36980 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36981 wxString result;
36982 void *argp1 = 0 ;
36983 int res1 = 0 ;
36984 PyObject *swig_obj[1] ;
36985
36986 if (!args) SWIG_fail;
36987 swig_obj[0] = args;
36988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36989 if (!SWIG_IsOK(res1)) {
36990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36991 }
36992 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36993 {
36994 PyThreadState* __tstate = wxPyBeginAllowThreads();
36995 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
36996 wxPyEndAllowThreads(__tstate);
36997 if (PyErr_Occurred()) SWIG_fail;
36998 }
36999 {
37000 #if wxUSE_UNICODE
37001 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37002 #else
37003 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37004 #endif
37005 }
37006 return resultobj;
37007 fail:
37008 return NULL;
37009 }
37010
37011
37012 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37013 PyObject *resultobj = 0;
37014 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37015 wxString result;
37016 void *argp1 = 0 ;
37017 int res1 = 0 ;
37018 PyObject *swig_obj[1] ;
37019
37020 if (!args) SWIG_fail;
37021 swig_obj[0] = args;
37022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37023 if (!SWIG_IsOK(res1)) {
37024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37025 }
37026 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37027 {
37028 PyThreadState* __tstate = wxPyBeginAllowThreads();
37029 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
37030 wxPyEndAllowThreads(__tstate);
37031 if (PyErr_Occurred()) SWIG_fail;
37032 }
37033 {
37034 #if wxUSE_UNICODE
37035 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37036 #else
37037 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37038 #endif
37039 }
37040 return resultobj;
37041 fail:
37042 return NULL;
37043 }
37044
37045
37046 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37047 PyObject *resultobj = 0;
37048 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37049 wxString result;
37050 void *argp1 = 0 ;
37051 int res1 = 0 ;
37052 PyObject *swig_obj[1] ;
37053
37054 if (!args) SWIG_fail;
37055 swig_obj[0] = args;
37056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37057 if (!SWIG_IsOK(res1)) {
37058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37059 }
37060 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37061 {
37062 PyThreadState* __tstate = wxPyBeginAllowThreads();
37063 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37064 wxPyEndAllowThreads(__tstate);
37065 if (PyErr_Occurred()) SWIG_fail;
37066 }
37067 {
37068 #if wxUSE_UNICODE
37069 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37070 #else
37071 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37072 #endif
37073 }
37074 return resultobj;
37075 fail:
37076 return NULL;
37077 }
37078
37079
37080 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37081 PyObject *resultobj = 0;
37082 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37083 wxString result;
37084 void *argp1 = 0 ;
37085 int res1 = 0 ;
37086 PyObject *swig_obj[1] ;
37087
37088 if (!args) SWIG_fail;
37089 swig_obj[0] = args;
37090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37091 if (!SWIG_IsOK(res1)) {
37092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37093 }
37094 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37095 {
37096 PyThreadState* __tstate = wxPyBeginAllowThreads();
37097 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37098 wxPyEndAllowThreads(__tstate);
37099 if (PyErr_Occurred()) SWIG_fail;
37100 }
37101 {
37102 #if wxUSE_UNICODE
37103 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37104 #else
37105 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37106 #endif
37107 }
37108 return resultobj;
37109 fail:
37110 return NULL;
37111 }
37112
37113
37114 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37115 PyObject *resultobj = 0;
37116 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37117 wxString *arg2 = 0 ;
37118 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37119 wxString result;
37120 void *argp1 = 0 ;
37121 int res1 = 0 ;
37122 bool temp2 = false ;
37123 int val3 ;
37124 int ecode3 = 0 ;
37125 PyObject * obj0 = 0 ;
37126 PyObject * obj1 = 0 ;
37127 PyObject * obj2 = 0 ;
37128 char * kwnames[] = {
37129 (char *) "self",(char *) "lang",(char *) "category", NULL
37130 };
37131
37132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37134 if (!SWIG_IsOK(res1)) {
37135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37136 }
37137 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37138 {
37139 arg2 = wxString_in_helper(obj1);
37140 if (arg2 == NULL) SWIG_fail;
37141 temp2 = true;
37142 }
37143 if (obj2) {
37144 ecode3 = SWIG_AsVal_int(obj2, &val3);
37145 if (!SWIG_IsOK(ecode3)) {
37146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37147 }
37148 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37149 }
37150 {
37151 PyThreadState* __tstate = wxPyBeginAllowThreads();
37152 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37153 wxPyEndAllowThreads(__tstate);
37154 if (PyErr_Occurred()) SWIG_fail;
37155 }
37156 {
37157 #if wxUSE_UNICODE
37158 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37159 #else
37160 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37161 #endif
37162 }
37163 {
37164 if (temp2)
37165 delete arg2;
37166 }
37167 return resultobj;
37168 fail:
37169 {
37170 if (temp2)
37171 delete arg2;
37172 }
37173 return NULL;
37174 }
37175
37176
37177 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37178 PyObject *resultobj = 0;
37179 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37180 wxString result;
37181 void *argp1 = 0 ;
37182 int res1 = 0 ;
37183 PyObject *swig_obj[1] ;
37184
37185 if (!args) SWIG_fail;
37186 swig_obj[0] = args;
37187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37188 if (!SWIG_IsOK(res1)) {
37189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37190 }
37191 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37192 {
37193 PyThreadState* __tstate = wxPyBeginAllowThreads();
37194 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37195 wxPyEndAllowThreads(__tstate);
37196 if (PyErr_Occurred()) SWIG_fail;
37197 }
37198 {
37199 #if wxUSE_UNICODE
37200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37201 #else
37202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37203 #endif
37204 }
37205 return resultobj;
37206 fail:
37207 return NULL;
37208 }
37209
37210
37211 SWIGINTERN PyObject *_wrap_StandardPaths_GetTempDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37212 PyObject *resultobj = 0;
37213 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37214 wxString result;
37215 void *argp1 = 0 ;
37216 int res1 = 0 ;
37217 PyObject *swig_obj[1] ;
37218
37219 if (!args) SWIG_fail;
37220 swig_obj[0] = args;
37221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37222 if (!SWIG_IsOK(res1)) {
37223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetTempDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37224 }
37225 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37226 {
37227 PyThreadState* __tstate = wxPyBeginAllowThreads();
37228 result = ((wxStandardPaths const *)arg1)->GetTempDir();
37229 wxPyEndAllowThreads(__tstate);
37230 if (PyErr_Occurred()) SWIG_fail;
37231 }
37232 {
37233 #if wxUSE_UNICODE
37234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37235 #else
37236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37237 #endif
37238 }
37239 return resultobj;
37240 fail:
37241 return NULL;
37242 }
37243
37244
37245 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37246 PyObject *resultobj = 0;
37247 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37248 wxString *arg2 = 0 ;
37249 void *argp1 = 0 ;
37250 int res1 = 0 ;
37251 bool temp2 = false ;
37252 PyObject * obj0 = 0 ;
37253 PyObject * obj1 = 0 ;
37254 char * kwnames[] = {
37255 (char *) "self",(char *) "prefix", NULL
37256 };
37257
37258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37260 if (!SWIG_IsOK(res1)) {
37261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37262 }
37263 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37264 {
37265 arg2 = wxString_in_helper(obj1);
37266 if (arg2 == NULL) SWIG_fail;
37267 temp2 = true;
37268 }
37269 {
37270 PyThreadState* __tstate = wxPyBeginAllowThreads();
37271 (arg1)->SetInstallPrefix((wxString const &)*arg2);
37272 wxPyEndAllowThreads(__tstate);
37273 if (PyErr_Occurred()) SWIG_fail;
37274 }
37275 resultobj = SWIG_Py_Void();
37276 {
37277 if (temp2)
37278 delete arg2;
37279 }
37280 return resultobj;
37281 fail:
37282 {
37283 if (temp2)
37284 delete arg2;
37285 }
37286 return NULL;
37287 }
37288
37289
37290 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37291 PyObject *resultobj = 0;
37292 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37293 wxString result;
37294 void *argp1 = 0 ;
37295 int res1 = 0 ;
37296 PyObject *swig_obj[1] ;
37297
37298 if (!args) SWIG_fail;
37299 swig_obj[0] = args;
37300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37301 if (!SWIG_IsOK(res1)) {
37302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37303 }
37304 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37305 {
37306 PyThreadState* __tstate = wxPyBeginAllowThreads();
37307 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
37308 wxPyEndAllowThreads(__tstate);
37309 if (PyErr_Occurred()) SWIG_fail;
37310 }
37311 {
37312 #if wxUSE_UNICODE
37313 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37314 #else
37315 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37316 #endif
37317 }
37318 return resultobj;
37319 fail:
37320 return NULL;
37321 }
37322
37323
37324 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37325 PyObject *obj;
37326 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37327 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37328 return SWIG_Py_Void();
37329 }
37330
37331 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37332 PyObject *resultobj = 0;
37333 wxEventType arg1 ;
37334 wxPowerEvent *result = 0 ;
37335 int val1 ;
37336 int ecode1 = 0 ;
37337 PyObject * obj0 = 0 ;
37338 char * kwnames[] = {
37339 (char *) "evtType", NULL
37340 };
37341
37342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37343 ecode1 = SWIG_AsVal_int(obj0, &val1);
37344 if (!SWIG_IsOK(ecode1)) {
37345 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37346 }
37347 arg1 = static_cast< wxEventType >(val1);
37348 {
37349 PyThreadState* __tstate = wxPyBeginAllowThreads();
37350 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37351 wxPyEndAllowThreads(__tstate);
37352 if (PyErr_Occurred()) SWIG_fail;
37353 }
37354 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37355 return resultobj;
37356 fail:
37357 return NULL;
37358 }
37359
37360
37361 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37362 PyObject *resultobj = 0;
37363 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37364 void *argp1 = 0 ;
37365 int res1 = 0 ;
37366 PyObject *swig_obj[1] ;
37367
37368 if (!args) SWIG_fail;
37369 swig_obj[0] = args;
37370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37371 if (!SWIG_IsOK(res1)) {
37372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37373 }
37374 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37375 {
37376 PyThreadState* __tstate = wxPyBeginAllowThreads();
37377 (arg1)->Veto();
37378 wxPyEndAllowThreads(__tstate);
37379 if (PyErr_Occurred()) SWIG_fail;
37380 }
37381 resultobj = SWIG_Py_Void();
37382 return resultobj;
37383 fail:
37384 return NULL;
37385 }
37386
37387
37388 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37389 PyObject *resultobj = 0;
37390 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37391 bool result;
37392 void *argp1 = 0 ;
37393 int res1 = 0 ;
37394 PyObject *swig_obj[1] ;
37395
37396 if (!args) SWIG_fail;
37397 swig_obj[0] = args;
37398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37399 if (!SWIG_IsOK(res1)) {
37400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37401 }
37402 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37403 {
37404 PyThreadState* __tstate = wxPyBeginAllowThreads();
37405 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37406 wxPyEndAllowThreads(__tstate);
37407 if (PyErr_Occurred()) SWIG_fail;
37408 }
37409 {
37410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37411 }
37412 return resultobj;
37413 fail:
37414 return NULL;
37415 }
37416
37417
37418 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37419 PyObject *obj;
37420 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37421 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37422 return SWIG_Py_Void();
37423 }
37424
37425 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37426 return SWIG_Python_InitShadowInstance(args);
37427 }
37428
37429 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37430 PyObject *resultobj = 0;
37431 wxPowerType result;
37432
37433 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37434 {
37435 PyThreadState* __tstate = wxPyBeginAllowThreads();
37436 result = (wxPowerType)wxGetPowerType();
37437 wxPyEndAllowThreads(__tstate);
37438 if (PyErr_Occurred()) SWIG_fail;
37439 }
37440 resultobj = SWIG_From_int(static_cast< int >(result));
37441 return resultobj;
37442 fail:
37443 return NULL;
37444 }
37445
37446
37447 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37448 PyObject *resultobj = 0;
37449 wxBatteryState result;
37450
37451 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37452 {
37453 PyThreadState* __tstate = wxPyBeginAllowThreads();
37454 result = (wxBatteryState)wxGetBatteryState();
37455 wxPyEndAllowThreads(__tstate);
37456 if (PyErr_Occurred()) SWIG_fail;
37457 }
37458 resultobj = SWIG_From_int(static_cast< int >(result));
37459 return resultobj;
37460 fail:
37461 return NULL;
37462 }
37463
37464
37465 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37466 PyObject *resultobj = 0;
37467 wxAboutDialogInfo *result = 0 ;
37468
37469 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37470 {
37471 PyThreadState* __tstate = wxPyBeginAllowThreads();
37472 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37473 wxPyEndAllowThreads(__tstate);
37474 if (PyErr_Occurred()) SWIG_fail;
37475 }
37476 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37477 return resultobj;
37478 fail:
37479 return NULL;
37480 }
37481
37482
37483 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37484 PyObject *resultobj = 0;
37485 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37486 void *argp1 = 0 ;
37487 int res1 = 0 ;
37488 PyObject *swig_obj[1] ;
37489
37490 if (!args) SWIG_fail;
37491 swig_obj[0] = args;
37492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37493 if (!SWIG_IsOK(res1)) {
37494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37495 }
37496 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37497 {
37498 PyThreadState* __tstate = wxPyBeginAllowThreads();
37499 delete arg1;
37500
37501 wxPyEndAllowThreads(__tstate);
37502 if (PyErr_Occurred()) SWIG_fail;
37503 }
37504 resultobj = SWIG_Py_Void();
37505 return resultobj;
37506 fail:
37507 return NULL;
37508 }
37509
37510
37511 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37512 PyObject *resultobj = 0;
37513 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37514 wxString *arg2 = 0 ;
37515 void *argp1 = 0 ;
37516 int res1 = 0 ;
37517 bool temp2 = false ;
37518 PyObject * obj0 = 0 ;
37519 PyObject * obj1 = 0 ;
37520 char * kwnames[] = {
37521 (char *) "self",(char *) "name", NULL
37522 };
37523
37524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
37525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37526 if (!SWIG_IsOK(res1)) {
37527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37528 }
37529 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37530 {
37531 arg2 = wxString_in_helper(obj1);
37532 if (arg2 == NULL) SWIG_fail;
37533 temp2 = true;
37534 }
37535 {
37536 PyThreadState* __tstate = wxPyBeginAllowThreads();
37537 (arg1)->SetName((wxString const &)*arg2);
37538 wxPyEndAllowThreads(__tstate);
37539 if (PyErr_Occurred()) SWIG_fail;
37540 }
37541 resultobj = SWIG_Py_Void();
37542 {
37543 if (temp2)
37544 delete arg2;
37545 }
37546 return resultobj;
37547 fail:
37548 {
37549 if (temp2)
37550 delete arg2;
37551 }
37552 return NULL;
37553 }
37554
37555
37556 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37557 PyObject *resultobj = 0;
37558 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37559 wxString result;
37560 void *argp1 = 0 ;
37561 int res1 = 0 ;
37562 PyObject *swig_obj[1] ;
37563
37564 if (!args) SWIG_fail;
37565 swig_obj[0] = args;
37566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37567 if (!SWIG_IsOK(res1)) {
37568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37569 }
37570 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37571 {
37572 PyThreadState* __tstate = wxPyBeginAllowThreads();
37573 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37574 wxPyEndAllowThreads(__tstate);
37575 if (PyErr_Occurred()) SWIG_fail;
37576 }
37577 {
37578 #if wxUSE_UNICODE
37579 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37580 #else
37581 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37582 #endif
37583 }
37584 return resultobj;
37585 fail:
37586 return NULL;
37587 }
37588
37589
37590 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37591 PyObject *resultobj = 0;
37592 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37593 wxString *arg2 = 0 ;
37594 void *argp1 = 0 ;
37595 int res1 = 0 ;
37596 bool temp2 = false ;
37597 PyObject * obj0 = 0 ;
37598 PyObject * obj1 = 0 ;
37599 char * kwnames[] = {
37600 (char *) "self",(char *) "version", NULL
37601 };
37602
37603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37605 if (!SWIG_IsOK(res1)) {
37606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37607 }
37608 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37609 {
37610 arg2 = wxString_in_helper(obj1);
37611 if (arg2 == NULL) SWIG_fail;
37612 temp2 = true;
37613 }
37614 {
37615 PyThreadState* __tstate = wxPyBeginAllowThreads();
37616 (arg1)->SetVersion((wxString const &)*arg2);
37617 wxPyEndAllowThreads(__tstate);
37618 if (PyErr_Occurred()) SWIG_fail;
37619 }
37620 resultobj = SWIG_Py_Void();
37621 {
37622 if (temp2)
37623 delete arg2;
37624 }
37625 return resultobj;
37626 fail:
37627 {
37628 if (temp2)
37629 delete arg2;
37630 }
37631 return NULL;
37632 }
37633
37634
37635 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37636 PyObject *resultobj = 0;
37637 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37638 bool result;
37639 void *argp1 = 0 ;
37640 int res1 = 0 ;
37641 PyObject *swig_obj[1] ;
37642
37643 if (!args) SWIG_fail;
37644 swig_obj[0] = args;
37645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37646 if (!SWIG_IsOK(res1)) {
37647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37648 }
37649 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37650 {
37651 PyThreadState* __tstate = wxPyBeginAllowThreads();
37652 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37653 wxPyEndAllowThreads(__tstate);
37654 if (PyErr_Occurred()) SWIG_fail;
37655 }
37656 {
37657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37658 }
37659 return resultobj;
37660 fail:
37661 return NULL;
37662 }
37663
37664
37665 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37666 PyObject *resultobj = 0;
37667 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37668 wxString result;
37669 void *argp1 = 0 ;
37670 int res1 = 0 ;
37671 PyObject *swig_obj[1] ;
37672
37673 if (!args) SWIG_fail;
37674 swig_obj[0] = args;
37675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37676 if (!SWIG_IsOK(res1)) {
37677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37678 }
37679 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37680 {
37681 PyThreadState* __tstate = wxPyBeginAllowThreads();
37682 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37683 wxPyEndAllowThreads(__tstate);
37684 if (PyErr_Occurred()) SWIG_fail;
37685 }
37686 {
37687 #if wxUSE_UNICODE
37688 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37689 #else
37690 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37691 #endif
37692 }
37693 return resultobj;
37694 fail:
37695 return NULL;
37696 }
37697
37698
37699 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37700 PyObject *resultobj = 0;
37701 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37702 wxString *arg2 = 0 ;
37703 void *argp1 = 0 ;
37704 int res1 = 0 ;
37705 bool temp2 = false ;
37706 PyObject * obj0 = 0 ;
37707 PyObject * obj1 = 0 ;
37708 char * kwnames[] = {
37709 (char *) "self",(char *) "desc", NULL
37710 };
37711
37712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37714 if (!SWIG_IsOK(res1)) {
37715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37716 }
37717 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37718 {
37719 arg2 = wxString_in_helper(obj1);
37720 if (arg2 == NULL) SWIG_fail;
37721 temp2 = true;
37722 }
37723 {
37724 PyThreadState* __tstate = wxPyBeginAllowThreads();
37725 (arg1)->SetDescription((wxString const &)*arg2);
37726 wxPyEndAllowThreads(__tstate);
37727 if (PyErr_Occurred()) SWIG_fail;
37728 }
37729 resultobj = SWIG_Py_Void();
37730 {
37731 if (temp2)
37732 delete arg2;
37733 }
37734 return resultobj;
37735 fail:
37736 {
37737 if (temp2)
37738 delete arg2;
37739 }
37740 return NULL;
37741 }
37742
37743
37744 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37745 PyObject *resultobj = 0;
37746 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37747 bool result;
37748 void *argp1 = 0 ;
37749 int res1 = 0 ;
37750 PyObject *swig_obj[1] ;
37751
37752 if (!args) SWIG_fail;
37753 swig_obj[0] = args;
37754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37755 if (!SWIG_IsOK(res1)) {
37756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37757 }
37758 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37759 {
37760 PyThreadState* __tstate = wxPyBeginAllowThreads();
37761 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37762 wxPyEndAllowThreads(__tstate);
37763 if (PyErr_Occurred()) SWIG_fail;
37764 }
37765 {
37766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37767 }
37768 return resultobj;
37769 fail:
37770 return NULL;
37771 }
37772
37773
37774 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37775 PyObject *resultobj = 0;
37776 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37777 wxString result;
37778 void *argp1 = 0 ;
37779 int res1 = 0 ;
37780 PyObject *swig_obj[1] ;
37781
37782 if (!args) SWIG_fail;
37783 swig_obj[0] = args;
37784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37785 if (!SWIG_IsOK(res1)) {
37786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37787 }
37788 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37789 {
37790 PyThreadState* __tstate = wxPyBeginAllowThreads();
37791 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37792 wxPyEndAllowThreads(__tstate);
37793 if (PyErr_Occurred()) SWIG_fail;
37794 }
37795 {
37796 #if wxUSE_UNICODE
37797 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37798 #else
37799 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37800 #endif
37801 }
37802 return resultobj;
37803 fail:
37804 return NULL;
37805 }
37806
37807
37808 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37809 PyObject *resultobj = 0;
37810 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37811 wxString *arg2 = 0 ;
37812 void *argp1 = 0 ;
37813 int res1 = 0 ;
37814 bool temp2 = false ;
37815 PyObject * obj0 = 0 ;
37816 PyObject * obj1 = 0 ;
37817 char * kwnames[] = {
37818 (char *) "self",(char *) "copyright", NULL
37819 };
37820
37821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
37822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37823 if (!SWIG_IsOK(res1)) {
37824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37825 }
37826 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37827 {
37828 arg2 = wxString_in_helper(obj1);
37829 if (arg2 == NULL) SWIG_fail;
37830 temp2 = true;
37831 }
37832 {
37833 PyThreadState* __tstate = wxPyBeginAllowThreads();
37834 (arg1)->SetCopyright((wxString const &)*arg2);
37835 wxPyEndAllowThreads(__tstate);
37836 if (PyErr_Occurred()) SWIG_fail;
37837 }
37838 resultobj = SWIG_Py_Void();
37839 {
37840 if (temp2)
37841 delete arg2;
37842 }
37843 return resultobj;
37844 fail:
37845 {
37846 if (temp2)
37847 delete arg2;
37848 }
37849 return NULL;
37850 }
37851
37852
37853 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37854 PyObject *resultobj = 0;
37855 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37856 bool result;
37857 void *argp1 = 0 ;
37858 int res1 = 0 ;
37859 PyObject *swig_obj[1] ;
37860
37861 if (!args) SWIG_fail;
37862 swig_obj[0] = args;
37863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37864 if (!SWIG_IsOK(res1)) {
37865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37866 }
37867 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37868 {
37869 PyThreadState* __tstate = wxPyBeginAllowThreads();
37870 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
37871 wxPyEndAllowThreads(__tstate);
37872 if (PyErr_Occurred()) SWIG_fail;
37873 }
37874 {
37875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37876 }
37877 return resultobj;
37878 fail:
37879 return NULL;
37880 }
37881
37882
37883 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37884 PyObject *resultobj = 0;
37885 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37886 wxString result;
37887 void *argp1 = 0 ;
37888 int res1 = 0 ;
37889 PyObject *swig_obj[1] ;
37890
37891 if (!args) SWIG_fail;
37892 swig_obj[0] = args;
37893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37894 if (!SWIG_IsOK(res1)) {
37895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37896 }
37897 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37898 {
37899 PyThreadState* __tstate = wxPyBeginAllowThreads();
37900 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
37901 wxPyEndAllowThreads(__tstate);
37902 if (PyErr_Occurred()) SWIG_fail;
37903 }
37904 {
37905 #if wxUSE_UNICODE
37906 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37907 #else
37908 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37909 #endif
37910 }
37911 return resultobj;
37912 fail:
37913 return NULL;
37914 }
37915
37916
37917 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37918 PyObject *resultobj = 0;
37919 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37920 wxString *arg2 = 0 ;
37921 void *argp1 = 0 ;
37922 int res1 = 0 ;
37923 bool temp2 = false ;
37924 PyObject * obj0 = 0 ;
37925 PyObject * obj1 = 0 ;
37926 char * kwnames[] = {
37927 (char *) "self",(char *) "licence", NULL
37928 };
37929
37930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
37931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37932 if (!SWIG_IsOK(res1)) {
37933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37934 }
37935 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37936 {
37937 arg2 = wxString_in_helper(obj1);
37938 if (arg2 == NULL) SWIG_fail;
37939 temp2 = true;
37940 }
37941 {
37942 PyThreadState* __tstate = wxPyBeginAllowThreads();
37943 (arg1)->SetLicence((wxString const &)*arg2);
37944 wxPyEndAllowThreads(__tstate);
37945 if (PyErr_Occurred()) SWIG_fail;
37946 }
37947 resultobj = SWIG_Py_Void();
37948 {
37949 if (temp2)
37950 delete arg2;
37951 }
37952 return resultobj;
37953 fail:
37954 {
37955 if (temp2)
37956 delete arg2;
37957 }
37958 return NULL;
37959 }
37960
37961
37962 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37963 PyObject *resultobj = 0;
37964 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37965 wxString *arg2 = 0 ;
37966 void *argp1 = 0 ;
37967 int res1 = 0 ;
37968 bool temp2 = false ;
37969 PyObject * obj0 = 0 ;
37970 PyObject * obj1 = 0 ;
37971 char * kwnames[] = {
37972 (char *) "self",(char *) "licence", NULL
37973 };
37974
37975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
37976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37977 if (!SWIG_IsOK(res1)) {
37978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37979 }
37980 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37981 {
37982 arg2 = wxString_in_helper(obj1);
37983 if (arg2 == NULL) SWIG_fail;
37984 temp2 = true;
37985 }
37986 {
37987 PyThreadState* __tstate = wxPyBeginAllowThreads();
37988 (arg1)->SetLicense((wxString const &)*arg2);
37989 wxPyEndAllowThreads(__tstate);
37990 if (PyErr_Occurred()) SWIG_fail;
37991 }
37992 resultobj = SWIG_Py_Void();
37993 {
37994 if (temp2)
37995 delete arg2;
37996 }
37997 return resultobj;
37998 fail:
37999 {
38000 if (temp2)
38001 delete arg2;
38002 }
38003 return NULL;
38004 }
38005
38006
38007 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38008 PyObject *resultobj = 0;
38009 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38010 bool result;
38011 void *argp1 = 0 ;
38012 int res1 = 0 ;
38013 PyObject *swig_obj[1] ;
38014
38015 if (!args) SWIG_fail;
38016 swig_obj[0] = args;
38017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38018 if (!SWIG_IsOK(res1)) {
38019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38020 }
38021 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38022 {
38023 PyThreadState* __tstate = wxPyBeginAllowThreads();
38024 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
38025 wxPyEndAllowThreads(__tstate);
38026 if (PyErr_Occurred()) SWIG_fail;
38027 }
38028 {
38029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38030 }
38031 return resultobj;
38032 fail:
38033 return NULL;
38034 }
38035
38036
38037 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38038 PyObject *resultobj = 0;
38039 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38040 wxString result;
38041 void *argp1 = 0 ;
38042 int res1 = 0 ;
38043 PyObject *swig_obj[1] ;
38044
38045 if (!args) SWIG_fail;
38046 swig_obj[0] = args;
38047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38048 if (!SWIG_IsOK(res1)) {
38049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38050 }
38051 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38052 {
38053 PyThreadState* __tstate = wxPyBeginAllowThreads();
38054 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
38055 wxPyEndAllowThreads(__tstate);
38056 if (PyErr_Occurred()) SWIG_fail;
38057 }
38058 {
38059 #if wxUSE_UNICODE
38060 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38061 #else
38062 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38063 #endif
38064 }
38065 return resultobj;
38066 fail:
38067 return NULL;
38068 }
38069
38070
38071 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38072 PyObject *resultobj = 0;
38073 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38074 wxIcon *arg2 = 0 ;
38075 void *argp1 = 0 ;
38076 int res1 = 0 ;
38077 void *argp2 = 0 ;
38078 int res2 = 0 ;
38079 PyObject * obj0 = 0 ;
38080 PyObject * obj1 = 0 ;
38081 char * kwnames[] = {
38082 (char *) "self",(char *) "icon", NULL
38083 };
38084
38085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
38086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38087 if (!SWIG_IsOK(res1)) {
38088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38089 }
38090 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38091 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
38092 if (!SWIG_IsOK(res2)) {
38093 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38094 }
38095 if (!argp2) {
38096 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38097 }
38098 arg2 = reinterpret_cast< wxIcon * >(argp2);
38099 {
38100 PyThreadState* __tstate = wxPyBeginAllowThreads();
38101 (arg1)->SetIcon((wxIcon const &)*arg2);
38102 wxPyEndAllowThreads(__tstate);
38103 if (PyErr_Occurred()) SWIG_fail;
38104 }
38105 resultobj = SWIG_Py_Void();
38106 return resultobj;
38107 fail:
38108 return NULL;
38109 }
38110
38111
38112 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38113 PyObject *resultobj = 0;
38114 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38115 bool result;
38116 void *argp1 = 0 ;
38117 int res1 = 0 ;
38118 PyObject *swig_obj[1] ;
38119
38120 if (!args) SWIG_fail;
38121 swig_obj[0] = args;
38122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38123 if (!SWIG_IsOK(res1)) {
38124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38125 }
38126 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38127 {
38128 PyThreadState* __tstate = wxPyBeginAllowThreads();
38129 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38130 wxPyEndAllowThreads(__tstate);
38131 if (PyErr_Occurred()) SWIG_fail;
38132 }
38133 {
38134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38135 }
38136 return resultobj;
38137 fail:
38138 return NULL;
38139 }
38140
38141
38142 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38143 PyObject *resultobj = 0;
38144 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38145 wxIcon result;
38146 void *argp1 = 0 ;
38147 int res1 = 0 ;
38148 PyObject *swig_obj[1] ;
38149
38150 if (!args) SWIG_fail;
38151 swig_obj[0] = args;
38152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38153 if (!SWIG_IsOK(res1)) {
38154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38155 }
38156 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38157 {
38158 PyThreadState* __tstate = wxPyBeginAllowThreads();
38159 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38160 wxPyEndAllowThreads(__tstate);
38161 if (PyErr_Occurred()) SWIG_fail;
38162 }
38163 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38164 return resultobj;
38165 fail:
38166 return NULL;
38167 }
38168
38169
38170 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38171 PyObject *resultobj = 0;
38172 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38173 wxString *arg2 = 0 ;
38174 wxString const &arg3_defvalue = wxEmptyString ;
38175 wxString *arg3 = (wxString *) &arg3_defvalue ;
38176 void *argp1 = 0 ;
38177 int res1 = 0 ;
38178 bool temp2 = false ;
38179 bool temp3 = false ;
38180 PyObject * obj0 = 0 ;
38181 PyObject * obj1 = 0 ;
38182 PyObject * obj2 = 0 ;
38183 char * kwnames[] = {
38184 (char *) "self",(char *) "url",(char *) "desc", NULL
38185 };
38186
38187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38189 if (!SWIG_IsOK(res1)) {
38190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38191 }
38192 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38193 {
38194 arg2 = wxString_in_helper(obj1);
38195 if (arg2 == NULL) SWIG_fail;
38196 temp2 = true;
38197 }
38198 if (obj2) {
38199 {
38200 arg3 = wxString_in_helper(obj2);
38201 if (arg3 == NULL) SWIG_fail;
38202 temp3 = true;
38203 }
38204 }
38205 {
38206 PyThreadState* __tstate = wxPyBeginAllowThreads();
38207 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38208 wxPyEndAllowThreads(__tstate);
38209 if (PyErr_Occurred()) SWIG_fail;
38210 }
38211 resultobj = SWIG_Py_Void();
38212 {
38213 if (temp2)
38214 delete arg2;
38215 }
38216 {
38217 if (temp3)
38218 delete arg3;
38219 }
38220 return resultobj;
38221 fail:
38222 {
38223 if (temp2)
38224 delete arg2;
38225 }
38226 {
38227 if (temp3)
38228 delete arg3;
38229 }
38230 return NULL;
38231 }
38232
38233
38234 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38235 PyObject *resultobj = 0;
38236 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38237 wxString result;
38238 void *argp1 = 0 ;
38239 int res1 = 0 ;
38240 PyObject *swig_obj[1] ;
38241
38242 if (!args) SWIG_fail;
38243 swig_obj[0] = args;
38244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38245 if (!SWIG_IsOK(res1)) {
38246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38247 }
38248 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38249 {
38250 PyThreadState* __tstate = wxPyBeginAllowThreads();
38251 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38252 wxPyEndAllowThreads(__tstate);
38253 if (PyErr_Occurred()) SWIG_fail;
38254 }
38255 {
38256 #if wxUSE_UNICODE
38257 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38258 #else
38259 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38260 #endif
38261 }
38262 return resultobj;
38263 fail:
38264 return NULL;
38265 }
38266
38267
38268 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38269 PyObject *resultobj = 0;
38270 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38271 wxString result;
38272 void *argp1 = 0 ;
38273 int res1 = 0 ;
38274 PyObject *swig_obj[1] ;
38275
38276 if (!args) SWIG_fail;
38277 swig_obj[0] = args;
38278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38279 if (!SWIG_IsOK(res1)) {
38280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38281 }
38282 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38283 {
38284 PyThreadState* __tstate = wxPyBeginAllowThreads();
38285 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38286 wxPyEndAllowThreads(__tstate);
38287 if (PyErr_Occurred()) SWIG_fail;
38288 }
38289 {
38290 #if wxUSE_UNICODE
38291 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38292 #else
38293 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38294 #endif
38295 }
38296 return resultobj;
38297 fail:
38298 return NULL;
38299 }
38300
38301
38302 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38303 PyObject *resultobj = 0;
38304 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38305 bool result;
38306 void *argp1 = 0 ;
38307 int res1 = 0 ;
38308 PyObject *swig_obj[1] ;
38309
38310 if (!args) SWIG_fail;
38311 swig_obj[0] = args;
38312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38313 if (!SWIG_IsOK(res1)) {
38314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38315 }
38316 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38317 {
38318 PyThreadState* __tstate = wxPyBeginAllowThreads();
38319 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38320 wxPyEndAllowThreads(__tstate);
38321 if (PyErr_Occurred()) SWIG_fail;
38322 }
38323 {
38324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38325 }
38326 return resultobj;
38327 fail:
38328 return NULL;
38329 }
38330
38331
38332 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38333 PyObject *resultobj = 0;
38334 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38335 wxArrayString *arg2 = 0 ;
38336 void *argp1 = 0 ;
38337 int res1 = 0 ;
38338 bool temp2 = false ;
38339 PyObject * obj0 = 0 ;
38340 PyObject * obj1 = 0 ;
38341 char * kwnames[] = {
38342 (char *) "self",(char *) "developers", NULL
38343 };
38344
38345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38347 if (!SWIG_IsOK(res1)) {
38348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38349 }
38350 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38351 {
38352 if (! PySequence_Check(obj1)) {
38353 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38354 SWIG_fail;
38355 }
38356 arg2 = new wxArrayString;
38357 temp2 = true;
38358 int i, len=PySequence_Length(obj1);
38359 for (i=0; i<len; i++) {
38360 PyObject* item = PySequence_GetItem(obj1, i);
38361 wxString* s = wxString_in_helper(item);
38362 if (PyErr_Occurred()) SWIG_fail;
38363 arg2->Add(*s);
38364 delete s;
38365 Py_DECREF(item);
38366 }
38367 }
38368 {
38369 PyThreadState* __tstate = wxPyBeginAllowThreads();
38370 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38371 wxPyEndAllowThreads(__tstate);
38372 if (PyErr_Occurred()) SWIG_fail;
38373 }
38374 resultobj = SWIG_Py_Void();
38375 {
38376 if (temp2) delete arg2;
38377 }
38378 return resultobj;
38379 fail:
38380 {
38381 if (temp2) delete arg2;
38382 }
38383 return NULL;
38384 }
38385
38386
38387 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38388 PyObject *resultobj = 0;
38389 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38390 wxString *arg2 = 0 ;
38391 void *argp1 = 0 ;
38392 int res1 = 0 ;
38393 bool temp2 = false ;
38394 PyObject * obj0 = 0 ;
38395 PyObject * obj1 = 0 ;
38396 char * kwnames[] = {
38397 (char *) "self",(char *) "developer", NULL
38398 };
38399
38400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38402 if (!SWIG_IsOK(res1)) {
38403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38404 }
38405 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38406 {
38407 arg2 = wxString_in_helper(obj1);
38408 if (arg2 == NULL) SWIG_fail;
38409 temp2 = true;
38410 }
38411 {
38412 PyThreadState* __tstate = wxPyBeginAllowThreads();
38413 (arg1)->AddDeveloper((wxString const &)*arg2);
38414 wxPyEndAllowThreads(__tstate);
38415 if (PyErr_Occurred()) SWIG_fail;
38416 }
38417 resultobj = SWIG_Py_Void();
38418 {
38419 if (temp2)
38420 delete arg2;
38421 }
38422 return resultobj;
38423 fail:
38424 {
38425 if (temp2)
38426 delete arg2;
38427 }
38428 return NULL;
38429 }
38430
38431
38432 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38433 PyObject *resultobj = 0;
38434 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38435 bool result;
38436 void *argp1 = 0 ;
38437 int res1 = 0 ;
38438 PyObject *swig_obj[1] ;
38439
38440 if (!args) SWIG_fail;
38441 swig_obj[0] = args;
38442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38443 if (!SWIG_IsOK(res1)) {
38444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38445 }
38446 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38447 {
38448 PyThreadState* __tstate = wxPyBeginAllowThreads();
38449 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38450 wxPyEndAllowThreads(__tstate);
38451 if (PyErr_Occurred()) SWIG_fail;
38452 }
38453 {
38454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38455 }
38456 return resultobj;
38457 fail:
38458 return NULL;
38459 }
38460
38461
38462 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38463 PyObject *resultobj = 0;
38464 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38465 wxArrayString *result = 0 ;
38466 void *argp1 = 0 ;
38467 int res1 = 0 ;
38468 PyObject *swig_obj[1] ;
38469
38470 if (!args) SWIG_fail;
38471 swig_obj[0] = args;
38472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38473 if (!SWIG_IsOK(res1)) {
38474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38475 }
38476 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38477 {
38478 PyThreadState* __tstate = wxPyBeginAllowThreads();
38479 {
38480 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38481 result = (wxArrayString *) &_result_ref;
38482 }
38483 wxPyEndAllowThreads(__tstate);
38484 if (PyErr_Occurred()) SWIG_fail;
38485 }
38486 {
38487 resultobj = wxArrayString2PyList_helper(*result);
38488 }
38489 return resultobj;
38490 fail:
38491 return NULL;
38492 }
38493
38494
38495 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38496 PyObject *resultobj = 0;
38497 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38498 wxArrayString *arg2 = 0 ;
38499 void *argp1 = 0 ;
38500 int res1 = 0 ;
38501 bool temp2 = false ;
38502 PyObject * obj0 = 0 ;
38503 PyObject * obj1 = 0 ;
38504 char * kwnames[] = {
38505 (char *) "self",(char *) "docwriters", NULL
38506 };
38507
38508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38510 if (!SWIG_IsOK(res1)) {
38511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38512 }
38513 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38514 {
38515 if (! PySequence_Check(obj1)) {
38516 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38517 SWIG_fail;
38518 }
38519 arg2 = new wxArrayString;
38520 temp2 = true;
38521 int i, len=PySequence_Length(obj1);
38522 for (i=0; i<len; i++) {
38523 PyObject* item = PySequence_GetItem(obj1, i);
38524 wxString* s = wxString_in_helper(item);
38525 if (PyErr_Occurred()) SWIG_fail;
38526 arg2->Add(*s);
38527 delete s;
38528 Py_DECREF(item);
38529 }
38530 }
38531 {
38532 PyThreadState* __tstate = wxPyBeginAllowThreads();
38533 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38534 wxPyEndAllowThreads(__tstate);
38535 if (PyErr_Occurred()) SWIG_fail;
38536 }
38537 resultobj = SWIG_Py_Void();
38538 {
38539 if (temp2) delete arg2;
38540 }
38541 return resultobj;
38542 fail:
38543 {
38544 if (temp2) delete arg2;
38545 }
38546 return NULL;
38547 }
38548
38549
38550 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38551 PyObject *resultobj = 0;
38552 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38553 wxString *arg2 = 0 ;
38554 void *argp1 = 0 ;
38555 int res1 = 0 ;
38556 bool temp2 = false ;
38557 PyObject * obj0 = 0 ;
38558 PyObject * obj1 = 0 ;
38559 char * kwnames[] = {
38560 (char *) "self",(char *) "docwriter", NULL
38561 };
38562
38563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38565 if (!SWIG_IsOK(res1)) {
38566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38567 }
38568 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38569 {
38570 arg2 = wxString_in_helper(obj1);
38571 if (arg2 == NULL) SWIG_fail;
38572 temp2 = true;
38573 }
38574 {
38575 PyThreadState* __tstate = wxPyBeginAllowThreads();
38576 (arg1)->AddDocWriter((wxString const &)*arg2);
38577 wxPyEndAllowThreads(__tstate);
38578 if (PyErr_Occurred()) SWIG_fail;
38579 }
38580 resultobj = SWIG_Py_Void();
38581 {
38582 if (temp2)
38583 delete arg2;
38584 }
38585 return resultobj;
38586 fail:
38587 {
38588 if (temp2)
38589 delete arg2;
38590 }
38591 return NULL;
38592 }
38593
38594
38595 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38596 PyObject *resultobj = 0;
38597 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38598 bool result;
38599 void *argp1 = 0 ;
38600 int res1 = 0 ;
38601 PyObject *swig_obj[1] ;
38602
38603 if (!args) SWIG_fail;
38604 swig_obj[0] = args;
38605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38606 if (!SWIG_IsOK(res1)) {
38607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38608 }
38609 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38610 {
38611 PyThreadState* __tstate = wxPyBeginAllowThreads();
38612 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38613 wxPyEndAllowThreads(__tstate);
38614 if (PyErr_Occurred()) SWIG_fail;
38615 }
38616 {
38617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38618 }
38619 return resultobj;
38620 fail:
38621 return NULL;
38622 }
38623
38624
38625 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38626 PyObject *resultobj = 0;
38627 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38628 wxArrayString *result = 0 ;
38629 void *argp1 = 0 ;
38630 int res1 = 0 ;
38631 PyObject *swig_obj[1] ;
38632
38633 if (!args) SWIG_fail;
38634 swig_obj[0] = args;
38635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38636 if (!SWIG_IsOK(res1)) {
38637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38638 }
38639 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38640 {
38641 PyThreadState* __tstate = wxPyBeginAllowThreads();
38642 {
38643 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38644 result = (wxArrayString *) &_result_ref;
38645 }
38646 wxPyEndAllowThreads(__tstate);
38647 if (PyErr_Occurred()) SWIG_fail;
38648 }
38649 {
38650 resultobj = wxArrayString2PyList_helper(*result);
38651 }
38652 return resultobj;
38653 fail:
38654 return NULL;
38655 }
38656
38657
38658 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38659 PyObject *resultobj = 0;
38660 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38661 wxArrayString *arg2 = 0 ;
38662 void *argp1 = 0 ;
38663 int res1 = 0 ;
38664 bool temp2 = false ;
38665 PyObject * obj0 = 0 ;
38666 PyObject * obj1 = 0 ;
38667 char * kwnames[] = {
38668 (char *) "self",(char *) "artists", NULL
38669 };
38670
38671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38673 if (!SWIG_IsOK(res1)) {
38674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38675 }
38676 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38677 {
38678 if (! PySequence_Check(obj1)) {
38679 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38680 SWIG_fail;
38681 }
38682 arg2 = new wxArrayString;
38683 temp2 = true;
38684 int i, len=PySequence_Length(obj1);
38685 for (i=0; i<len; i++) {
38686 PyObject* item = PySequence_GetItem(obj1, i);
38687 wxString* s = wxString_in_helper(item);
38688 if (PyErr_Occurred()) SWIG_fail;
38689 arg2->Add(*s);
38690 delete s;
38691 Py_DECREF(item);
38692 }
38693 }
38694 {
38695 PyThreadState* __tstate = wxPyBeginAllowThreads();
38696 (arg1)->SetArtists((wxArrayString const &)*arg2);
38697 wxPyEndAllowThreads(__tstate);
38698 if (PyErr_Occurred()) SWIG_fail;
38699 }
38700 resultobj = SWIG_Py_Void();
38701 {
38702 if (temp2) delete arg2;
38703 }
38704 return resultobj;
38705 fail:
38706 {
38707 if (temp2) delete arg2;
38708 }
38709 return NULL;
38710 }
38711
38712
38713 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38714 PyObject *resultobj = 0;
38715 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38716 wxString *arg2 = 0 ;
38717 void *argp1 = 0 ;
38718 int res1 = 0 ;
38719 bool temp2 = false ;
38720 PyObject * obj0 = 0 ;
38721 PyObject * obj1 = 0 ;
38722 char * kwnames[] = {
38723 (char *) "self",(char *) "artist", NULL
38724 };
38725
38726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38728 if (!SWIG_IsOK(res1)) {
38729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38730 }
38731 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38732 {
38733 arg2 = wxString_in_helper(obj1);
38734 if (arg2 == NULL) SWIG_fail;
38735 temp2 = true;
38736 }
38737 {
38738 PyThreadState* __tstate = wxPyBeginAllowThreads();
38739 (arg1)->AddArtist((wxString const &)*arg2);
38740 wxPyEndAllowThreads(__tstate);
38741 if (PyErr_Occurred()) SWIG_fail;
38742 }
38743 resultobj = SWIG_Py_Void();
38744 {
38745 if (temp2)
38746 delete arg2;
38747 }
38748 return resultobj;
38749 fail:
38750 {
38751 if (temp2)
38752 delete arg2;
38753 }
38754 return NULL;
38755 }
38756
38757
38758 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38759 PyObject *resultobj = 0;
38760 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38761 bool result;
38762 void *argp1 = 0 ;
38763 int res1 = 0 ;
38764 PyObject *swig_obj[1] ;
38765
38766 if (!args) SWIG_fail;
38767 swig_obj[0] = args;
38768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38769 if (!SWIG_IsOK(res1)) {
38770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38771 }
38772 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38773 {
38774 PyThreadState* __tstate = wxPyBeginAllowThreads();
38775 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38776 wxPyEndAllowThreads(__tstate);
38777 if (PyErr_Occurred()) SWIG_fail;
38778 }
38779 {
38780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38781 }
38782 return resultobj;
38783 fail:
38784 return NULL;
38785 }
38786
38787
38788 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38789 PyObject *resultobj = 0;
38790 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38791 wxArrayString *result = 0 ;
38792 void *argp1 = 0 ;
38793 int res1 = 0 ;
38794 PyObject *swig_obj[1] ;
38795
38796 if (!args) SWIG_fail;
38797 swig_obj[0] = args;
38798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38799 if (!SWIG_IsOK(res1)) {
38800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38801 }
38802 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38803 {
38804 PyThreadState* __tstate = wxPyBeginAllowThreads();
38805 {
38806 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
38807 result = (wxArrayString *) &_result_ref;
38808 }
38809 wxPyEndAllowThreads(__tstate);
38810 if (PyErr_Occurred()) SWIG_fail;
38811 }
38812 {
38813 resultobj = wxArrayString2PyList_helper(*result);
38814 }
38815 return resultobj;
38816 fail:
38817 return NULL;
38818 }
38819
38820
38821 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38822 PyObject *resultobj = 0;
38823 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38824 wxArrayString *arg2 = 0 ;
38825 void *argp1 = 0 ;
38826 int res1 = 0 ;
38827 bool temp2 = false ;
38828 PyObject * obj0 = 0 ;
38829 PyObject * obj1 = 0 ;
38830 char * kwnames[] = {
38831 (char *) "self",(char *) "translators", NULL
38832 };
38833
38834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
38835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38836 if (!SWIG_IsOK(res1)) {
38837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38838 }
38839 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38840 {
38841 if (! PySequence_Check(obj1)) {
38842 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38843 SWIG_fail;
38844 }
38845 arg2 = new wxArrayString;
38846 temp2 = true;
38847 int i, len=PySequence_Length(obj1);
38848 for (i=0; i<len; i++) {
38849 PyObject* item = PySequence_GetItem(obj1, i);
38850 wxString* s = wxString_in_helper(item);
38851 if (PyErr_Occurred()) SWIG_fail;
38852 arg2->Add(*s);
38853 delete s;
38854 Py_DECREF(item);
38855 }
38856 }
38857 {
38858 PyThreadState* __tstate = wxPyBeginAllowThreads();
38859 (arg1)->SetTranslators((wxArrayString const &)*arg2);
38860 wxPyEndAllowThreads(__tstate);
38861 if (PyErr_Occurred()) SWIG_fail;
38862 }
38863 resultobj = SWIG_Py_Void();
38864 {
38865 if (temp2) delete arg2;
38866 }
38867 return resultobj;
38868 fail:
38869 {
38870 if (temp2) delete arg2;
38871 }
38872 return NULL;
38873 }
38874
38875
38876 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38877 PyObject *resultobj = 0;
38878 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38879 wxString *arg2 = 0 ;
38880 void *argp1 = 0 ;
38881 int res1 = 0 ;
38882 bool temp2 = false ;
38883 PyObject * obj0 = 0 ;
38884 PyObject * obj1 = 0 ;
38885 char * kwnames[] = {
38886 (char *) "self",(char *) "translator", NULL
38887 };
38888
38889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
38890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38891 if (!SWIG_IsOK(res1)) {
38892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38893 }
38894 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38895 {
38896 arg2 = wxString_in_helper(obj1);
38897 if (arg2 == NULL) SWIG_fail;
38898 temp2 = true;
38899 }
38900 {
38901 PyThreadState* __tstate = wxPyBeginAllowThreads();
38902 (arg1)->AddTranslator((wxString const &)*arg2);
38903 wxPyEndAllowThreads(__tstate);
38904 if (PyErr_Occurred()) SWIG_fail;
38905 }
38906 resultobj = SWIG_Py_Void();
38907 {
38908 if (temp2)
38909 delete arg2;
38910 }
38911 return resultobj;
38912 fail:
38913 {
38914 if (temp2)
38915 delete arg2;
38916 }
38917 return NULL;
38918 }
38919
38920
38921 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38922 PyObject *resultobj = 0;
38923 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38924 bool result;
38925 void *argp1 = 0 ;
38926 int res1 = 0 ;
38927 PyObject *swig_obj[1] ;
38928
38929 if (!args) SWIG_fail;
38930 swig_obj[0] = args;
38931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38932 if (!SWIG_IsOK(res1)) {
38933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38934 }
38935 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38936 {
38937 PyThreadState* __tstate = wxPyBeginAllowThreads();
38938 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
38939 wxPyEndAllowThreads(__tstate);
38940 if (PyErr_Occurred()) SWIG_fail;
38941 }
38942 {
38943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38944 }
38945 return resultobj;
38946 fail:
38947 return NULL;
38948 }
38949
38950
38951 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38952 PyObject *resultobj = 0;
38953 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38954 wxArrayString *result = 0 ;
38955 void *argp1 = 0 ;
38956 int res1 = 0 ;
38957 PyObject *swig_obj[1] ;
38958
38959 if (!args) SWIG_fail;
38960 swig_obj[0] = args;
38961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38962 if (!SWIG_IsOK(res1)) {
38963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38964 }
38965 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38966 {
38967 PyThreadState* __tstate = wxPyBeginAllowThreads();
38968 {
38969 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
38970 result = (wxArrayString *) &_result_ref;
38971 }
38972 wxPyEndAllowThreads(__tstate);
38973 if (PyErr_Occurred()) SWIG_fail;
38974 }
38975 {
38976 resultobj = wxArrayString2PyList_helper(*result);
38977 }
38978 return resultobj;
38979 fail:
38980 return NULL;
38981 }
38982
38983
38984 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38985 PyObject *resultobj = 0;
38986 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38987 bool result;
38988 void *argp1 = 0 ;
38989 int res1 = 0 ;
38990 PyObject *swig_obj[1] ;
38991
38992 if (!args) SWIG_fail;
38993 swig_obj[0] = args;
38994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38995 if (!SWIG_IsOK(res1)) {
38996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38997 }
38998 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38999 {
39000 PyThreadState* __tstate = wxPyBeginAllowThreads();
39001 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
39002 wxPyEndAllowThreads(__tstate);
39003 if (PyErr_Occurred()) SWIG_fail;
39004 }
39005 {
39006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39007 }
39008 return resultobj;
39009 fail:
39010 return NULL;
39011 }
39012
39013
39014 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39015 PyObject *resultobj = 0;
39016 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39017 wxString result;
39018 void *argp1 = 0 ;
39019 int res1 = 0 ;
39020 PyObject *swig_obj[1] ;
39021
39022 if (!args) SWIG_fail;
39023 swig_obj[0] = args;
39024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39025 if (!SWIG_IsOK(res1)) {
39026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39027 }
39028 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39029 {
39030 PyThreadState* __tstate = wxPyBeginAllowThreads();
39031 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
39032 wxPyEndAllowThreads(__tstate);
39033 if (PyErr_Occurred()) SWIG_fail;
39034 }
39035 {
39036 #if wxUSE_UNICODE
39037 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39038 #else
39039 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39040 #endif
39041 }
39042 return resultobj;
39043 fail:
39044 return NULL;
39045 }
39046
39047
39048 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39049 PyObject *obj;
39050 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39051 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
39052 return SWIG_Py_Void();
39053 }
39054
39055 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39056 return SWIG_Python_InitShadowInstance(args);
39057 }
39058
39059 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39060 PyObject *resultobj = 0;
39061 wxAboutDialogInfo *arg1 = 0 ;
39062 void *argp1 = 0 ;
39063 int res1 = 0 ;
39064 PyObject * obj0 = 0 ;
39065 char * kwnames[] = {
39066 (char *) "info", NULL
39067 };
39068
39069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
39070 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
39071 if (!SWIG_IsOK(res1)) {
39072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39073 }
39074 if (!argp1) {
39075 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39076 }
39077 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39078 {
39079 PyThreadState* __tstate = wxPyBeginAllowThreads();
39080 wxAboutBox((wxAboutDialogInfo const &)*arg1);
39081 wxPyEndAllowThreads(__tstate);
39082 if (PyErr_Occurred()) SWIG_fail;
39083 }
39084 resultobj = SWIG_Py_Void();
39085 return resultobj;
39086 fail:
39087 return NULL;
39088 }
39089
39090
39091 static PyMethodDef SwigMethods[] = {
39092 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
39093 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
39094 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
39095 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
39096 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
39097 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
39098 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
39099 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
39100 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39101 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39102 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39103 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39104 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
39105 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
39106 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
39107 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
39108 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
39109 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
39110 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
39111 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
39112 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39113 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39114 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
39115 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
39116 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
39117 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
39118 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39119 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39120 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39121 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
39122 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39123 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39124 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39125 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39126 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39127 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39128 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39129 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39130 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39131 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39132 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39133 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39134 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39135 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39136 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39137 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39138 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39139 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39140 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39141 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39142 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39143 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39144 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39145 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39146 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39147 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39148 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39149 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39150 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39151 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39152 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39153 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39154 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39155 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39156 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39157 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39158 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39159 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39160 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39161 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39162 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39163 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39164 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39165 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39166 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39167 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39168 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39169 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39170 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39171 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39172 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39173 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39174 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39175 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39176 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39177 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39178 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39179 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39180 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39181 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39182 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39183 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39184 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39185 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39186 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39187 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39188 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39189 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39190 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39191 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39192 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39193 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39194 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39195 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39196 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39197 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39198 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39199 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39200 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39201 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39202 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39203 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39204 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39205 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39206 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39207 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39208 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39209 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39210 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39211 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39212 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39213 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39214 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39215 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39216 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39217 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39218 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39219 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39220 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39221 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39222 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39223 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39224 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39225 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39226 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39227 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39228 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39229 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39230 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39231 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39232 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39233 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39234 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39235 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39236 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39237 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39238 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39239 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39240 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39241 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39242 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39243 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39244 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39245 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39246 { (char *)"delete_StopWatch", (PyCFunction)_wrap_delete_StopWatch, METH_O, NULL},
39247 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39248 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39249 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39250 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39251 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39252 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39253 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39254 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39255 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39256 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39257 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39258 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39259 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39260 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39261 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39262 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39263 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39264 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39265 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39266 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39267 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39268 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39269 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39270 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39271 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39272 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39273 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39274 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39275 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39276 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39277 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39278 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39279 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39280 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39281 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39282 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39283 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39284 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39285 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39286 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39287 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39288 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39289 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39290 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39291 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39292 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39293 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39294 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39295 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39296 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39297 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39298 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39299 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39300 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39301 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39302 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39303 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39304 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39305 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39306 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39307 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39308 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39309 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39310 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39311 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39312 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39313 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39314 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39315 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39316 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39317 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39318 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39319 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39320 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39321 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39322 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39323 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39324 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39325 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39326 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39327 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39328 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39329 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39330 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39331 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39332 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39333 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39334 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39335 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39336 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39337 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39338 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39339 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39340 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39341 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39342 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39343 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39344 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39345 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39346 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39347 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39348 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39349 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39350 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39351 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39352 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39353 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39354 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39355 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39356 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39357 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39358 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39359 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39360 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39361 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39362 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39363 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39364 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39365 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39366 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39367 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39368 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39369 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39370 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39371 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39372 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39373 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39374 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39375 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39376 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39377 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39378 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39379 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39380 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39381 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39382 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39383 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39384 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39385 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39386 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39387 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39388 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39389 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39390 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39391 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39392 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39393 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39394 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39395 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39396 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39397 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39398 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39399 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39400 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39401 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39402 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39403 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39404 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39405 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39406 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39407 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39408 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39409 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39410 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39411 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39412 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39413 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39414 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39415 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39416 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39417 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39418 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39419 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39420 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39421 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39422 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39423 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39424 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39425 { (char *)"delete_Process", (PyCFunction)_wrap_delete_Process, METH_O, NULL},
39426 { (char *)"Process_GetPid", (PyCFunction)_wrap_Process_GetPid, METH_O, NULL},
39427 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39428 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39429 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39430 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39431 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39432 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39433 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39434 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39435 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39436 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39437 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39438 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39439 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39440 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39441 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39442 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39443 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39444 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39445 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39446 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39447 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39448 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39449 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39450 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39451 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39452 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39453 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39454 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39455 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39456 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39457 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39458 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39459 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39460 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39461 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39462 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39463 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39464 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39465 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39466 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39467 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39468 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39469 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39470 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39471 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39472 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39473 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39474 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39475 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39476 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39477 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39478 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39479 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39480 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39481 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39482 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39483 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39484 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39485 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39486 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39487 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39488 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39489 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39490 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39491 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39492 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39493 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39494 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39495 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39496 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39497 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39498 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39499 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39500 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39501 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39502 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39503 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39504 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39505 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39506 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39507 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39508 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39509 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39510 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39511 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39512 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39513 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39514 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39515 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39516 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39517 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39518 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39519 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39520 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39521 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39522 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39523 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39524 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39525 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39526 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39527 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39528 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39529 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39530 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39531 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39532 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39533 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39534 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39535 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39536 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39537 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39538 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39539 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39540 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39541 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39542 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39543 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39544 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39545 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39546 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39547 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39548 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39549 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39550 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39551 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39552 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39553 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39554 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39555 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39556 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39557 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39558 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39559 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39560 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39561 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39562 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39563 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39564 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39565 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39566 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39567 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39568 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39569 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39570 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39571 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39572 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39573 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39574 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39575 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39576 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39577 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39578 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39579 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39580 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39581 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39582 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39583 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39584 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39585 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39586 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39587 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39588 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39589 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39590 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39591 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39592 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39593 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39594 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39595 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39596 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39597 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39598 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39599 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39600 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39601 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39602 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39603 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39604 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39605 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39606 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39607 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39608 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39609 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39610 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39611 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39612 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39613 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39614 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39615 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39616 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39617 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39618 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39619 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39620 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39621 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39622 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39623 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39624 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39625 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39626 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39627 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39628 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39629 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39630 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39631 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39632 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39633 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39634 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39635 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39636 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39637 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39638 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39639 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39640 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39641 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39642 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39643 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39644 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39645 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39646 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39647 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39648 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39649 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39650 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39651 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39652 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39653 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39654 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39655 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39656 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39657 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39658 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39659 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39660 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39661 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39662 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39663 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39664 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39665 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39666 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39667 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39668 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39669 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39670 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39671 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39672 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39673 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39674 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39675 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39676 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39677 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39678 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39679 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39680 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39681 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39682 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39683 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39684 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39685 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39686 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39687 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39688 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39689 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39690 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39691 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39692 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39693 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39694 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39695 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39696 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39697 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39698 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39699 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39700 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39701 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39702 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39703 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39704 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39705 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39706 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39707 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39708 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39709 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39710 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39711 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39712 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39713 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39714 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39715 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39716 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39717 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39718 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39719 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39720 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39721 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39722 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39723 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39724 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39725 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39726 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39727 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39728 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39729 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39730 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39731 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39732 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39733 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39734 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39735 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39736 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39737 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39738 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39739 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39740 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39741 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39742 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39743 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39744 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39745 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39746 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39747 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39748 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39749 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39750 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39751 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39752 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39753 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39754 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39755 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39756 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39757 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39758 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39759 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39760 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39761 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39762 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39763 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39764 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39765 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39766 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39767 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39768 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39769 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39770 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39771 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39772 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39773 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39774 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39775 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39776 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39777 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39778 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39779 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39780 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39781 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39782 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39783 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39784 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39785 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39786 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39787 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39788 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39789 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39790 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39791 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39792 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39793 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39794 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39795 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39797 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39798 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39799 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39800 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39801 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39802 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39803 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39804 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
39805 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39806 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
39807 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
39808 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
39809 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
39810 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
39811 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
39812 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39813 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
39814 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
39815 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39816 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
39817 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39818 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
39819 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39820 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
39821 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
39822 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
39823 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
39824 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
39825 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
39826 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
39827 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
39828 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
39829 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
39830 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
39831 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
39832 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
39833 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
39834 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39835 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39836 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
39837 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39838 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39839 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39840 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
39841 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39842 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39843 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39844 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39845 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39846 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39847 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39848 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
39849 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
39850 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
39851 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
39852 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
39853 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
39854 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39855 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39856 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
39857 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
39858 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
39859 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
39860 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
39861 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
39862 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
39863 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
39864 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
39865 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
39866 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39867 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
39868 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39869 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
39870 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
39871 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
39872 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39873 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
39874 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39875 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
39876 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39877 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
39878 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
39879 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39880 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
39881 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
39882 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39883 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39884 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
39885 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
39886 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
39887 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39888 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
39889 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
39890 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
39891 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39892 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
39893 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
39894 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
39895 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
39896 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
39897 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39898 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39899 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
39900 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
39901 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39902 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
39903 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39904 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
39905 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
39906 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39907 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39908 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
39909 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
39910 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
39911 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
39912 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
39913 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
39914 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
39915 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
39916 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39917 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
39918 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
39919 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
39920 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
39921 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39922 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
39923 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
39924 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
39925 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
39926 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
39927 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
39928 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
39929 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
39930 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
39931 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39932 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
39933 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39934 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
39935 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39936 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39937 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
39938 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
39939 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
39940 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39941 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39942 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
39943 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
39944 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39945 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39946 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39947 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
39948 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39949 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
39950 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
39951 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
39952 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
39953 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
39954 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
39955 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39956 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
39957 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39958 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39959 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
39960 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39961 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
39962 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
39963 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
39964 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
39965 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39966 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
39967 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39968 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39969 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
39970 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39971 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
39972 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
39973 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
39974 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
39975 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
39976 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
39977 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
39978 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
39979 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
39980 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39981 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39982 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
39983 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
39984 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
39985 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
39986 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
39987 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
39988 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
39989 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
39990 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
39991 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
39992 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
39993 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
39994 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
39995 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
39996 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
39997 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
39998 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
39999 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
40000 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
40001 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
40002 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
40003 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
40004 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
40005 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
40006 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
40007 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
40008 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
40009 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
40010 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
40011 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
40012 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
40013 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
40014 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
40015 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
40016 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
40017 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
40018 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
40019 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
40020 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
40021 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
40022 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
40023 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
40024 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
40025 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
40026 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
40027 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
40028 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
40029 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
40030 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
40031 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
40032 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
40033 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
40034 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
40035 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
40036 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
40037 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
40038 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
40039 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
40040 { (char *)"StandardPaths_GetTempDir", (PyCFunction)_wrap_StandardPaths_GetTempDir, METH_O, NULL},
40041 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
40042 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
40043 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
40044 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
40045 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
40046 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
40047 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
40048 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
40049 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
40050 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
40051 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
40052 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
40053 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
40054 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
40055 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
40056 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
40057 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
40058 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
40059 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
40060 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
40061 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
40062 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
40063 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
40064 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
40065 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
40066 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
40067 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
40068 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
40069 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
40070 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
40071 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
40072 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
40073 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
40074 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
40075 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
40076 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
40077 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
40078 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
40079 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
40080 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
40081 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
40082 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
40083 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
40084 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
40085 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
40086 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
40087 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
40088 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
40089 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
40090 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
40091 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
40092 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
40093 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
40094 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
40095 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
40096 { NULL, NULL, 0, NULL }
40097 };
40098
40099
40100 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
40101
40102 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
40103 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
40104 }
40105 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
40106 return (void *)((wxEvent *) ((wxMenuEvent *) x));
40107 }
40108 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
40109 return (void *)((wxEvent *) ((wxCloseEvent *) x));
40110 }
40111 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
40112 return (void *)((wxEvent *) ((wxMouseEvent *) x));
40113 }
40114 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
40115 return (void *)((wxEvent *) ((wxEraseEvent *) x));
40116 }
40117 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
40118 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
40119 }
40120 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
40121 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40122 }
40123 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40124 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40125 }
40126 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40127 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40128 }
40129 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40130 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40131 }
40132 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40133 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40134 }
40135 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40136 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40137 }
40138 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40139 return (void *)((wxEvent *) ((wxPyEvent *) x));
40140 }
40141 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40142 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40143 }
40144 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40145 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40146 }
40147 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40148 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40149 }
40150 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40151 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40152 }
40153 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40154 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40155 }
40156 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40157 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40158 }
40159 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40160 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40161 }
40162 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40163 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40164 }
40165 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40166 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40167 }
40168 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40169 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40170 }
40171 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40172 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40173 }
40174 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40175 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40176 }
40177 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40178 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40179 }
40180 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40181 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40182 }
40183 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40184 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40185 }
40186 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40187 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40188 }
40189 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40190 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40191 }
40192 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40193 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40194 }
40195 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40196 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40197 }
40198 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40199 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40200 }
40201 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40202 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40203 }
40204 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40205 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40206 }
40207 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40208 return (void *)((wxEvent *) ((wxShowEvent *) x));
40209 }
40210 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40211 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40212 }
40213 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40214 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40215 }
40216 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40217 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40218 }
40219 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40220 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40221 }
40222 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40223 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40224 }
40225 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40226 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40227 }
40228 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40229 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40230 }
40231 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40232 return (void *)((wxConfigBase *) ((wxConfig *) x));
40233 }
40234 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40235 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40236 }
40237 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40238 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40239 }
40240 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40241 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40242 }
40243 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40244 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40245 }
40246 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40247 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40248 }
40249 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40250 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40251 }
40252 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40253 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40254 }
40255 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40256 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40257 }
40258 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40259 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40260 }
40261 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40262 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40263 }
40264 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40265 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40266 }
40267 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40268 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40269 }
40270 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40271 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40272 }
40273 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40274 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40275 }
40276 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40277 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40278 }
40279 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40280 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40281 }
40282 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40283 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40284 }
40285 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40286 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40287 }
40288 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40289 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40290 }
40291 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40292 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40293 }
40294 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40295 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40296 }
40297 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40298 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40299 }
40300 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40301 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40302 }
40303 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40304 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40305 }
40306 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40307 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40308 }
40309 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40310 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40311 }
40312 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40313 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40314 }
40315 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40316 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40317 }
40318 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40319 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40320 }
40321 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40322 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40323 }
40324 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40325 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40326 }
40327 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40328 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40329 }
40330 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40331 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40332 }
40333 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40334 return (void *)((wxObject *) ((wxSizerItem *) x));
40335 }
40336 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40337 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40338 }
40339 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40340 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40341 }
40342 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40343 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40344 }
40345 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40346 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40347 }
40348 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40349 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40350 }
40351 static void *_p_wxSizerTo_p_wxObject(void *x) {
40352 return (void *)((wxObject *) ((wxSizer *) x));
40353 }
40354 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40355 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40356 }
40357 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40358 return (void *)((wxObject *) ((wxFileHistory *) x));
40359 }
40360 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40361 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40362 }
40363 static void *_p_wxEventTo_p_wxObject(void *x) {
40364 return (void *)((wxObject *) ((wxEvent *) x));
40365 }
40366 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40367 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40368 }
40369 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40370 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40371 }
40372 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40373 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40374 }
40375 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40376 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40377 }
40378 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40379 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40380 }
40381 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40382 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40383 }
40384 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40385 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40386 }
40387 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40388 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40389 }
40390 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40391 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40392 }
40393 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40394 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40395 }
40396 static void *_p_wxControlTo_p_wxObject(void *x) {
40397 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40398 }
40399 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40400 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40401 }
40402 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40403 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40404 }
40405 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40406 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40407 }
40408 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40409 return (void *)((wxObject *) ((wxFSFile *) x));
40410 }
40411 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40412 return (void *)((wxObject *) ((wxClipboard *) x));
40413 }
40414 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40415 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40416 }
40417 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40418 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40419 }
40420 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40421 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40422 }
40423 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40424 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40425 }
40426 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40427 return (void *)((wxObject *) ((wxToolTip *) x));
40428 }
40429 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40430 return (void *)((wxObject *) ((wxMenuItem *) x));
40431 }
40432 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40433 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40434 }
40435 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40436 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40437 }
40438 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40439 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40440 }
40441 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40442 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40443 }
40444 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40445 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40446 }
40447 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40448 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40449 }
40450 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40451 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40452 }
40453 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40454 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40455 }
40456 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40457 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40458 }
40459 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40460 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40461 }
40462 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40463 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40464 }
40465 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40466 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40467 }
40468 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40469 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40470 }
40471 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40472 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40473 }
40474 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40475 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40476 }
40477 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40478 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40479 }
40480 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40481 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40482 }
40483 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40484 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40485 }
40486 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40487 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40488 }
40489 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40490 return (void *)((wxObject *) ((wxImageHandler *) x));
40491 }
40492 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40493 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40494 }
40495 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40496 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40497 }
40498 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40499 return (void *)((wxObject *) ((wxEvtHandler *) x));
40500 }
40501 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40502 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40503 }
40504 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40505 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40506 }
40507 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40508 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40509 }
40510 static void *_p_wxImageTo_p_wxObject(void *x) {
40511 return (void *)((wxObject *) ((wxImage *) x));
40512 }
40513 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40514 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40515 }
40516 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40517 return (void *)((wxObject *) ((wxSystemOptions *) x));
40518 }
40519 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40520 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40521 }
40522 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40523 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40524 }
40525 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40526 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40527 }
40528 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40529 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40530 }
40531 static void *_p_wxWindowTo_p_wxObject(void *x) {
40532 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40533 }
40534 static void *_p_wxMenuTo_p_wxObject(void *x) {
40535 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40536 }
40537 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40538 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40539 }
40540 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40541 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40542 }
40543 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40544 return (void *)((wxObject *) ((wxFileSystem *) x));
40545 }
40546 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40547 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40548 }
40549 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40550 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40551 }
40552 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40553 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40554 }
40555 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40556 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40557 }
40558 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40559 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40560 }
40561 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40562 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40563 }
40564 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40565 return (void *)((wxObject *) ((wxBusyInfo *) x));
40566 }
40567 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40568 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40569 }
40570 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40571 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40572 }
40573 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40574 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40575 }
40576 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40577 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40578 }
40579 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40580 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40581 }
40582 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40583 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40584 }
40585 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40586 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40587 }
40588 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40589 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40590 }
40591 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40592 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40593 }
40594 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40595 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40596 }
40597 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40598 return (void *)((wxLog *) ((wxLogBuffer *) x));
40599 }
40600 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40601 return (void *)((wxLog *) ((wxLogStderr *) x));
40602 }
40603 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40604 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40605 }
40606 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40607 return (void *)((wxLog *) ((wxLogWindow *) x));
40608 }
40609 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40610 return (void *)((wxLog *) ((wxLogChain *) x));
40611 }
40612 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40613 return (void *)((wxLog *) ((wxLogGui *) x));
40614 }
40615 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40616 return (void *)((wxLog *) ((wxPyLog *) x));
40617 }
40618 static void *_p_wxControlTo_p_wxWindow(void *x) {
40619 return (void *)((wxWindow *) ((wxControl *) x));
40620 }
40621 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40622 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40623 }
40624 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40625 return (void *)((wxWindow *) ((wxMenuBar *) x));
40626 }
40627 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40628 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40629 }
40630 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40631 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40632 }
40633 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40634 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};
40635 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40636 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40637 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40638 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40639 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40640 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40641 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40642 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40643 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40644 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40645 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40646 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40647 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40648 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40649 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40650 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40651 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40652 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40653 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40654 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40655 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40656 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40657 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40658 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40659 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40660 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40661 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40662 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40663 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40664 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40665 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40666 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40667 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40668 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40669 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40670 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40671 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40672 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40673 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40674 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40675 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40676 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40677 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40678 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40679 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40680 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40681 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40682 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40683 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40684 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40685 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40686 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40687 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40688 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40689 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40690 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40691 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40692 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40693 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40694 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40695 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40696 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40697 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40698 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40699 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40700 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40701 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40702 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40703 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40704 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40705 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40706 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40707 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40708 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40709 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40710 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40711 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40712 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40713 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40714 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40715 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40716 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40717 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40718 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40719 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40720 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40721 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40722 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40723 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40724 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40725 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40726 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40727 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40728 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40729 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40730 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40731 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40732 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40733 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40734 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40735 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40736 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40737 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40738 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40739 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40740 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40741 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40742 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40743 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40744 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40745 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40746 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40747 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40748 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40749 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40750 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40751 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40752 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40753 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40754 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40755 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40756 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40757 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40758 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40759 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40760 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40761 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40762 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40763 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40764 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40765 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40766 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40767 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40768 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40769 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40770 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40771 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40772 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40773 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40774 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40775 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40776 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40777 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40778 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40779 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40780 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40781 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40782 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40783 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40784 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40785 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
40786 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
40787 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
40788 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
40789 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
40790 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
40791 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
40792 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
40793 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
40794 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
40795 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
40796 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
40797 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
40798 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
40799 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
40800 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
40801 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
40802 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
40803 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
40804 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
40805 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
40806
40807 static swig_type_info *swig_type_initial[] = {
40808 &_swigt__p_char,
40809 &_swigt__p_form_ops_t,
40810 &_swigt__p_int,
40811 &_swigt__p_unsigned_char,
40812 &_swigt__p_unsigned_int,
40813 &_swigt__p_unsigned_long,
40814 &_swigt__p_void,
40815 &_swigt__p_wxANIHandler,
40816 &_swigt__p_wxAboutDialogInfo,
40817 &_swigt__p_wxAcceleratorTable,
40818 &_swigt__p_wxActivateEvent,
40819 &_swigt__p_wxArrayString,
40820 &_swigt__p_wxBMPHandler,
40821 &_swigt__p_wxBitmap,
40822 &_swigt__p_wxBitmapDataObject,
40823 &_swigt__p_wxBoxSizer,
40824 &_swigt__p_wxBusyCursor,
40825 &_swigt__p_wxBusyInfo,
40826 &_swigt__p_wxCURHandler,
40827 &_swigt__p_wxCaret,
40828 &_swigt__p_wxChar,
40829 &_swigt__p_wxChildFocusEvent,
40830 &_swigt__p_wxClipboard,
40831 &_swigt__p_wxClipboardLocker,
40832 &_swigt__p_wxClipboardTextEvent,
40833 &_swigt__p_wxCloseEvent,
40834 &_swigt__p_wxColour,
40835 &_swigt__p_wxCommandEvent,
40836 &_swigt__p_wxConfig,
40837 &_swigt__p_wxConfigBase,
40838 &_swigt__p_wxConfigPathChanger,
40839 &_swigt__p_wxContextMenuEvent,
40840 &_swigt__p_wxControl,
40841 &_swigt__p_wxControlWithItems,
40842 &_swigt__p_wxCursor,
40843 &_swigt__p_wxCustomDataObject,
40844 &_swigt__p_wxDC,
40845 &_swigt__p_wxDataFormat,
40846 &_swigt__p_wxDataObject,
40847 &_swigt__p_wxDataObjectComposite,
40848 &_swigt__p_wxDataObjectSimple,
40849 &_swigt__p_wxDateEvent,
40850 &_swigt__p_wxDateSpan,
40851 &_swigt__p_wxDateTime,
40852 &_swigt__p_wxDateTime__TimeZone,
40853 &_swigt__p_wxDisplay,
40854 &_swigt__p_wxDisplayChangedEvent,
40855 &_swigt__p_wxDropFilesEvent,
40856 &_swigt__p_wxDuplexMode,
40857 &_swigt__p_wxEraseEvent,
40858 &_swigt__p_wxEvent,
40859 &_swigt__p_wxEvtHandler,
40860 &_swigt__p_wxFSFile,
40861 &_swigt__p_wxFileConfig,
40862 &_swigt__p_wxFileDataObject,
40863 &_swigt__p_wxFileHistory,
40864 &_swigt__p_wxFileSystem,
40865 &_swigt__p_wxFileType,
40866 &_swigt__p_wxFileTypeInfo,
40867 &_swigt__p_wxFlexGridSizer,
40868 &_swigt__p_wxFocusEvent,
40869 &_swigt__p_wxFont,
40870 &_swigt__p_wxFrame,
40871 &_swigt__p_wxGBSizerItem,
40872 &_swigt__p_wxGIFHandler,
40873 &_swigt__p_wxGridBagSizer,
40874 &_swigt__p_wxGridSizer,
40875 &_swigt__p_wxICOHandler,
40876 &_swigt__p_wxIcon,
40877 &_swigt__p_wxIconizeEvent,
40878 &_swigt__p_wxIdleEvent,
40879 &_swigt__p_wxImage,
40880 &_swigt__p_wxImageHandler,
40881 &_swigt__p_wxIndividualLayoutConstraint,
40882 &_swigt__p_wxInitDialogEvent,
40883 &_swigt__p_wxJPEGHandler,
40884 &_swigt__p_wxJoystick,
40885 &_swigt__p_wxJoystickEvent,
40886 &_swigt__p_wxKeyEvent,
40887 &_swigt__p_wxKillError,
40888 &_swigt__p_wxLayoutConstraints,
40889 &_swigt__p_wxLog,
40890 &_swigt__p_wxLogBuffer,
40891 &_swigt__p_wxLogChain,
40892 &_swigt__p_wxLogGui,
40893 &_swigt__p_wxLogNull,
40894 &_swigt__p_wxLogStderr,
40895 &_swigt__p_wxLogTextCtrl,
40896 &_swigt__p_wxLogWindow,
40897 &_swigt__p_wxMaximizeEvent,
40898 &_swigt__p_wxMenu,
40899 &_swigt__p_wxMenuBar,
40900 &_swigt__p_wxMenuEvent,
40901 &_swigt__p_wxMenuItem,
40902 &_swigt__p_wxMetafileDataObject,
40903 &_swigt__p_wxMimeTypesManager,
40904 &_swigt__p_wxMouseCaptureChangedEvent,
40905 &_swigt__p_wxMouseCaptureLostEvent,
40906 &_swigt__p_wxMouseEvent,
40907 &_swigt__p_wxMouseState,
40908 &_swigt__p_wxMoveEvent,
40909 &_swigt__p_wxMutexGuiLocker,
40910 &_swigt__p_wxNavigationKeyEvent,
40911 &_swigt__p_wxNcPaintEvent,
40912 &_swigt__p_wxNotifyEvent,
40913 &_swigt__p_wxObject,
40914 &_swigt__p_wxOutputStream,
40915 &_swigt__p_wxPCXHandler,
40916 &_swigt__p_wxPNGHandler,
40917 &_swigt__p_wxPNMHandler,
40918 &_swigt__p_wxPaintEvent,
40919 &_swigt__p_wxPaletteChangedEvent,
40920 &_swigt__p_wxPaperSize,
40921 &_swigt__p_wxPlatformInfo,
40922 &_swigt__p_wxPoint,
40923 &_swigt__p_wxPowerEvent,
40924 &_swigt__p_wxProcessEvent,
40925 &_swigt__p_wxPyApp,
40926 &_swigt__p_wxPyArtProvider,
40927 &_swigt__p_wxPyBitmapDataObject,
40928 &_swigt__p_wxPyCommandEvent,
40929 &_swigt__p_wxPyDataObjectSimple,
40930 &_swigt__p_wxPyDropSource,
40931 &_swigt__p_wxPyDropTarget,
40932 &_swigt__p_wxPyEvent,
40933 &_swigt__p_wxPyFileDropTarget,
40934 &_swigt__p_wxPyImageHandler,
40935 &_swigt__p_wxPyLog,
40936 &_swigt__p_wxPyProcess,
40937 &_swigt__p_wxPySizer,
40938 &_swigt__p_wxPyTextDataObject,
40939 &_swigt__p_wxPyTextDropTarget,
40940 &_swigt__p_wxPyTimer,
40941 &_swigt__p_wxPyTipProvider,
40942 &_swigt__p_wxPyValidator,
40943 &_swigt__p_wxQueryNewPaletteEvent,
40944 &_swigt__p_wxRect,
40945 &_swigt__p_wxScrollEvent,
40946 &_swigt__p_wxScrollWinEvent,
40947 &_swigt__p_wxSetCursorEvent,
40948 &_swigt__p_wxShowEvent,
40949 &_swigt__p_wxSingleInstanceChecker,
40950 &_swigt__p_wxSize,
40951 &_swigt__p_wxSizeEvent,
40952 &_swigt__p_wxSizer,
40953 &_swigt__p_wxSizerItem,
40954 &_swigt__p_wxSound,
40955 &_swigt__p_wxStandardPaths,
40956 &_swigt__p_wxStaticBoxSizer,
40957 &_swigt__p_wxStdDialogButtonSizer,
40958 &_swigt__p_wxStopWatch,
40959 &_swigt__p_wxString,
40960 &_swigt__p_wxSysColourChangedEvent,
40961 &_swigt__p_wxSystemOptions,
40962 &_swigt__p_wxSystemSettings,
40963 &_swigt__p_wxTIFFHandler,
40964 &_swigt__p_wxTextCtrl,
40965 &_swigt__p_wxTextDataObject,
40966 &_swigt__p_wxTimeSpan,
40967 &_swigt__p_wxTimer,
40968 &_swigt__p_wxTimerEvent,
40969 &_swigt__p_wxTimerRunner,
40970 &_swigt__p_wxTipProvider,
40971 &_swigt__p_wxToolTip,
40972 &_swigt__p_wxURLDataObject,
40973 &_swigt__p_wxUpdateUIEvent,
40974 &_swigt__p_wxValidator,
40975 &_swigt__p_wxVideoMode,
40976 &_swigt__p_wxWindow,
40977 &_swigt__p_wxWindowCreateEvent,
40978 &_swigt__p_wxWindowDestroyEvent,
40979 &_swigt__p_wxWindowDisabler,
40980 &_swigt__p_wxXPMHandler,
40981 };
40982
40983 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
40984 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
40985 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
40986 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
40987 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
40988 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
40989 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
40990 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
40991 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
40992 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
40993 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}};
40994 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
40995 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
40996 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
40997 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
40998 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
40999 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
41000 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
41001 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
41002 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}};
41003 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
41004 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
41005 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
41006 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
41007 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
41008 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}};
41009 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
41010 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}};
41011 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
41012 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
41013 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
41014 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
41015 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
41016 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41017 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41018 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
41019 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
41020 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
41021 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
41022 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
41023 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
41024 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
41025 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
41026 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
41027 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
41028 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
41029 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
41030 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41031 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41032 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
41033 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41034 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
41035 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
41036 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41037 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41038 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
41039 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
41040 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41041 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41042 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41043 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41044 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
41045 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41046 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41047 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
41048 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41049 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41050 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
41051 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41052 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41053 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
41054 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}};
41055 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
41056 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
41057 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
41058 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
41059 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
41060 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
41061 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}};
41062 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
41063 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41064 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
41065 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
41066 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
41067 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
41068 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
41069 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
41070 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
41071 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
41072 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
41073 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}};
41074 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
41075 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
41076 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
41077 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
41078 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
41079 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41080 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
41081 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
41082 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41083 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
41084 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
41085 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
41086 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
41087 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41088 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41089 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
41090 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41091 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41092 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
41093 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
41094 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41095 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41096 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
41097 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
41098 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
41099 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41100 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
41101 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
41102 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41103 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
41104 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
41105 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
41106 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
41107 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
41108 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
41109 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
41110 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
41111 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
41112 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
41113 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
41114 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
41115 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
41116 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}};
41117 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
41118 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
41119 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
41120 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
41121 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41122 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41123 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41124 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41125 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41126 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41127 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}};
41128 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41129 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41130 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41131 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41132 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41133 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41134 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41135 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41136 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41137 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41138 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41139 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41140 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41141 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41142 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41143 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41144 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41145 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}};
41146 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41147 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41148 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41149 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41150 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}};
41151 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41152 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41153 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41154 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}};
41155 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41156
41157 static swig_cast_info *swig_cast_initial[] = {
41158 _swigc__p_char,
41159 _swigc__p_form_ops_t,
41160 _swigc__p_int,
41161 _swigc__p_unsigned_char,
41162 _swigc__p_unsigned_int,
41163 _swigc__p_unsigned_long,
41164 _swigc__p_void,
41165 _swigc__p_wxANIHandler,
41166 _swigc__p_wxAboutDialogInfo,
41167 _swigc__p_wxAcceleratorTable,
41168 _swigc__p_wxActivateEvent,
41169 _swigc__p_wxArrayString,
41170 _swigc__p_wxBMPHandler,
41171 _swigc__p_wxBitmap,
41172 _swigc__p_wxBitmapDataObject,
41173 _swigc__p_wxBoxSizer,
41174 _swigc__p_wxBusyCursor,
41175 _swigc__p_wxBusyInfo,
41176 _swigc__p_wxCURHandler,
41177 _swigc__p_wxCaret,
41178 _swigc__p_wxChar,
41179 _swigc__p_wxChildFocusEvent,
41180 _swigc__p_wxClipboard,
41181 _swigc__p_wxClipboardLocker,
41182 _swigc__p_wxClipboardTextEvent,
41183 _swigc__p_wxCloseEvent,
41184 _swigc__p_wxColour,
41185 _swigc__p_wxCommandEvent,
41186 _swigc__p_wxConfig,
41187 _swigc__p_wxConfigBase,
41188 _swigc__p_wxConfigPathChanger,
41189 _swigc__p_wxContextMenuEvent,
41190 _swigc__p_wxControl,
41191 _swigc__p_wxControlWithItems,
41192 _swigc__p_wxCursor,
41193 _swigc__p_wxCustomDataObject,
41194 _swigc__p_wxDC,
41195 _swigc__p_wxDataFormat,
41196 _swigc__p_wxDataObject,
41197 _swigc__p_wxDataObjectComposite,
41198 _swigc__p_wxDataObjectSimple,
41199 _swigc__p_wxDateEvent,
41200 _swigc__p_wxDateSpan,
41201 _swigc__p_wxDateTime,
41202 _swigc__p_wxDateTime__TimeZone,
41203 _swigc__p_wxDisplay,
41204 _swigc__p_wxDisplayChangedEvent,
41205 _swigc__p_wxDropFilesEvent,
41206 _swigc__p_wxDuplexMode,
41207 _swigc__p_wxEraseEvent,
41208 _swigc__p_wxEvent,
41209 _swigc__p_wxEvtHandler,
41210 _swigc__p_wxFSFile,
41211 _swigc__p_wxFileConfig,
41212 _swigc__p_wxFileDataObject,
41213 _swigc__p_wxFileHistory,
41214 _swigc__p_wxFileSystem,
41215 _swigc__p_wxFileType,
41216 _swigc__p_wxFileTypeInfo,
41217 _swigc__p_wxFlexGridSizer,
41218 _swigc__p_wxFocusEvent,
41219 _swigc__p_wxFont,
41220 _swigc__p_wxFrame,
41221 _swigc__p_wxGBSizerItem,
41222 _swigc__p_wxGIFHandler,
41223 _swigc__p_wxGridBagSizer,
41224 _swigc__p_wxGridSizer,
41225 _swigc__p_wxICOHandler,
41226 _swigc__p_wxIcon,
41227 _swigc__p_wxIconizeEvent,
41228 _swigc__p_wxIdleEvent,
41229 _swigc__p_wxImage,
41230 _swigc__p_wxImageHandler,
41231 _swigc__p_wxIndividualLayoutConstraint,
41232 _swigc__p_wxInitDialogEvent,
41233 _swigc__p_wxJPEGHandler,
41234 _swigc__p_wxJoystick,
41235 _swigc__p_wxJoystickEvent,
41236 _swigc__p_wxKeyEvent,
41237 _swigc__p_wxKillError,
41238 _swigc__p_wxLayoutConstraints,
41239 _swigc__p_wxLog,
41240 _swigc__p_wxLogBuffer,
41241 _swigc__p_wxLogChain,
41242 _swigc__p_wxLogGui,
41243 _swigc__p_wxLogNull,
41244 _swigc__p_wxLogStderr,
41245 _swigc__p_wxLogTextCtrl,
41246 _swigc__p_wxLogWindow,
41247 _swigc__p_wxMaximizeEvent,
41248 _swigc__p_wxMenu,
41249 _swigc__p_wxMenuBar,
41250 _swigc__p_wxMenuEvent,
41251 _swigc__p_wxMenuItem,
41252 _swigc__p_wxMetafileDataObject,
41253 _swigc__p_wxMimeTypesManager,
41254 _swigc__p_wxMouseCaptureChangedEvent,
41255 _swigc__p_wxMouseCaptureLostEvent,
41256 _swigc__p_wxMouseEvent,
41257 _swigc__p_wxMouseState,
41258 _swigc__p_wxMoveEvent,
41259 _swigc__p_wxMutexGuiLocker,
41260 _swigc__p_wxNavigationKeyEvent,
41261 _swigc__p_wxNcPaintEvent,
41262 _swigc__p_wxNotifyEvent,
41263 _swigc__p_wxObject,
41264 _swigc__p_wxOutputStream,
41265 _swigc__p_wxPCXHandler,
41266 _swigc__p_wxPNGHandler,
41267 _swigc__p_wxPNMHandler,
41268 _swigc__p_wxPaintEvent,
41269 _swigc__p_wxPaletteChangedEvent,
41270 _swigc__p_wxPaperSize,
41271 _swigc__p_wxPlatformInfo,
41272 _swigc__p_wxPoint,
41273 _swigc__p_wxPowerEvent,
41274 _swigc__p_wxProcessEvent,
41275 _swigc__p_wxPyApp,
41276 _swigc__p_wxPyArtProvider,
41277 _swigc__p_wxPyBitmapDataObject,
41278 _swigc__p_wxPyCommandEvent,
41279 _swigc__p_wxPyDataObjectSimple,
41280 _swigc__p_wxPyDropSource,
41281 _swigc__p_wxPyDropTarget,
41282 _swigc__p_wxPyEvent,
41283 _swigc__p_wxPyFileDropTarget,
41284 _swigc__p_wxPyImageHandler,
41285 _swigc__p_wxPyLog,
41286 _swigc__p_wxPyProcess,
41287 _swigc__p_wxPySizer,
41288 _swigc__p_wxPyTextDataObject,
41289 _swigc__p_wxPyTextDropTarget,
41290 _swigc__p_wxPyTimer,
41291 _swigc__p_wxPyTipProvider,
41292 _swigc__p_wxPyValidator,
41293 _swigc__p_wxQueryNewPaletteEvent,
41294 _swigc__p_wxRect,
41295 _swigc__p_wxScrollEvent,
41296 _swigc__p_wxScrollWinEvent,
41297 _swigc__p_wxSetCursorEvent,
41298 _swigc__p_wxShowEvent,
41299 _swigc__p_wxSingleInstanceChecker,
41300 _swigc__p_wxSize,
41301 _swigc__p_wxSizeEvent,
41302 _swigc__p_wxSizer,
41303 _swigc__p_wxSizerItem,
41304 _swigc__p_wxSound,
41305 _swigc__p_wxStandardPaths,
41306 _swigc__p_wxStaticBoxSizer,
41307 _swigc__p_wxStdDialogButtonSizer,
41308 _swigc__p_wxStopWatch,
41309 _swigc__p_wxString,
41310 _swigc__p_wxSysColourChangedEvent,
41311 _swigc__p_wxSystemOptions,
41312 _swigc__p_wxSystemSettings,
41313 _swigc__p_wxTIFFHandler,
41314 _swigc__p_wxTextCtrl,
41315 _swigc__p_wxTextDataObject,
41316 _swigc__p_wxTimeSpan,
41317 _swigc__p_wxTimer,
41318 _swigc__p_wxTimerEvent,
41319 _swigc__p_wxTimerRunner,
41320 _swigc__p_wxTipProvider,
41321 _swigc__p_wxToolTip,
41322 _swigc__p_wxURLDataObject,
41323 _swigc__p_wxUpdateUIEvent,
41324 _swigc__p_wxValidator,
41325 _swigc__p_wxVideoMode,
41326 _swigc__p_wxWindow,
41327 _swigc__p_wxWindowCreateEvent,
41328 _swigc__p_wxWindowDestroyEvent,
41329 _swigc__p_wxWindowDisabler,
41330 _swigc__p_wxXPMHandler,
41331 };
41332
41333
41334 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41335
41336 static swig_const_info swig_const_table[] = {
41337 {0, 0, 0, 0.0, 0, 0}};
41338
41339 #ifdef __cplusplus
41340 }
41341 #endif
41342 /* -----------------------------------------------------------------------------
41343 * Type initialization:
41344 * This problem is tough by the requirement that no dynamic
41345 * memory is used. Also, since swig_type_info structures store pointers to
41346 * swig_cast_info structures and swig_cast_info structures store pointers back
41347 * to swig_type_info structures, we need some lookup code at initialization.
41348 * The idea is that swig generates all the structures that are needed.
41349 * The runtime then collects these partially filled structures.
41350 * The SWIG_InitializeModule function takes these initial arrays out of
41351 * swig_module, and does all the lookup, filling in the swig_module.types
41352 * array with the correct data and linking the correct swig_cast_info
41353 * structures together.
41354 *
41355 * The generated swig_type_info structures are assigned staticly to an initial
41356 * array. We just loop though that array, and handle each type individually.
41357 * First we lookup if this type has been already loaded, and if so, use the
41358 * loaded structure instead of the generated one. Then we have to fill in the
41359 * cast linked list. The cast data is initially stored in something like a
41360 * two-dimensional array. Each row corresponds to a type (there are the same
41361 * number of rows as there are in the swig_type_initial array). Each entry in
41362 * a column is one of the swig_cast_info structures for that type.
41363 * The cast_initial array is actually an array of arrays, because each row has
41364 * a variable number of columns. So to actually build the cast linked list,
41365 * we find the array of casts associated with the type, and loop through it
41366 * adding the casts to the list. The one last trick we need to do is making
41367 * sure the type pointer in the swig_cast_info struct is correct.
41368 *
41369 * First off, we lookup the cast->type name to see if it is already loaded.
41370 * There are three cases to handle:
41371 * 1) If the cast->type has already been loaded AND the type we are adding
41372 * casting info to has not been loaded (it is in this module), THEN we
41373 * replace the cast->type pointer with the type pointer that has already
41374 * been loaded.
41375 * 2) If BOTH types (the one we are adding casting info to, and the
41376 * cast->type) are loaded, THEN the cast info has already been loaded by
41377 * the previous module so we just ignore it.
41378 * 3) Finally, if cast->type has not already been loaded, then we add that
41379 * swig_cast_info to the linked list (because the cast->type) pointer will
41380 * be correct.
41381 * ----------------------------------------------------------------------------- */
41382
41383 #ifdef __cplusplus
41384 extern "C" {
41385 #if 0
41386 } /* c-mode */
41387 #endif
41388 #endif
41389
41390 #if 0
41391 #define SWIGRUNTIME_DEBUG
41392 #endif
41393
41394 SWIGRUNTIME void
41395 SWIG_InitializeModule(void *clientdata) {
41396 size_t i;
41397 swig_module_info *module_head;
41398 static int init_run = 0;
41399
41400 clientdata = clientdata;
41401
41402 if (init_run) return;
41403 init_run = 1;
41404
41405 /* Initialize the swig_module */
41406 swig_module.type_initial = swig_type_initial;
41407 swig_module.cast_initial = swig_cast_initial;
41408
41409 /* Try and load any already created modules */
41410 module_head = SWIG_GetModule(clientdata);
41411 if (module_head) {
41412 swig_module.next = module_head->next;
41413 module_head->next = &swig_module;
41414 } else {
41415 /* This is the first module loaded */
41416 swig_module.next = &swig_module;
41417 SWIG_SetModule(clientdata, &swig_module);
41418 }
41419
41420 /* Now work on filling in swig_module.types */
41421 #ifdef SWIGRUNTIME_DEBUG
41422 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41423 #endif
41424 for (i = 0; i < swig_module.size; ++i) {
41425 swig_type_info *type = 0;
41426 swig_type_info *ret;
41427 swig_cast_info *cast;
41428
41429 #ifdef SWIGRUNTIME_DEBUG
41430 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41431 #endif
41432
41433 /* if there is another module already loaded */
41434 if (swig_module.next != &swig_module) {
41435 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41436 }
41437 if (type) {
41438 /* Overwrite clientdata field */
41439 #ifdef SWIGRUNTIME_DEBUG
41440 printf("SWIG_InitializeModule: found type %s\n", type->name);
41441 #endif
41442 if (swig_module.type_initial[i]->clientdata) {
41443 type->clientdata = swig_module.type_initial[i]->clientdata;
41444 #ifdef SWIGRUNTIME_DEBUG
41445 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41446 #endif
41447 }
41448 } else {
41449 type = swig_module.type_initial[i];
41450 }
41451
41452 /* Insert casting types */
41453 cast = swig_module.cast_initial[i];
41454 while (cast->type) {
41455 /* Don't need to add information already in the list */
41456 ret = 0;
41457 #ifdef SWIGRUNTIME_DEBUG
41458 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41459 #endif
41460 if (swig_module.next != &swig_module) {
41461 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41462 #ifdef SWIGRUNTIME_DEBUG
41463 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41464 #endif
41465 }
41466 if (ret) {
41467 if (type == swig_module.type_initial[i]) {
41468 #ifdef SWIGRUNTIME_DEBUG
41469 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41470 #endif
41471 cast->type = ret;
41472 ret = 0;
41473 } else {
41474 /* Check for casting already in the list */
41475 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41476 #ifdef SWIGRUNTIME_DEBUG
41477 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41478 #endif
41479 if (!ocast) ret = 0;
41480 }
41481 }
41482
41483 if (!ret) {
41484 #ifdef SWIGRUNTIME_DEBUG
41485 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41486 #endif
41487 if (type->cast) {
41488 type->cast->prev = cast;
41489 cast->next = type->cast;
41490 }
41491 type->cast = cast;
41492 }
41493 cast++;
41494 }
41495 /* Set entry in modules->types array equal to the type */
41496 swig_module.types[i] = type;
41497 }
41498 swig_module.types[i] = 0;
41499
41500 #ifdef SWIGRUNTIME_DEBUG
41501 printf("**** SWIG_InitializeModule: Cast List ******\n");
41502 for (i = 0; i < swig_module.size; ++i) {
41503 int j = 0;
41504 swig_cast_info *cast = swig_module.cast_initial[i];
41505 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41506 while (cast->type) {
41507 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41508 cast++;
41509 ++j;
41510 }
41511 printf("---- Total casts: %d\n",j);
41512 }
41513 printf("**** SWIG_InitializeModule: Cast List ******\n");
41514 #endif
41515 }
41516
41517 /* This function will propagate the clientdata field of type to
41518 * any new swig_type_info structures that have been added into the list
41519 * of equivalent types. It is like calling
41520 * SWIG_TypeClientData(type, clientdata) a second time.
41521 */
41522 SWIGRUNTIME void
41523 SWIG_PropagateClientData(void) {
41524 size_t i;
41525 swig_cast_info *equiv;
41526 static int init_run = 0;
41527
41528 if (init_run) return;
41529 init_run = 1;
41530
41531 for (i = 0; i < swig_module.size; i++) {
41532 if (swig_module.types[i]->clientdata) {
41533 equiv = swig_module.types[i]->cast;
41534 while (equiv) {
41535 if (!equiv->converter) {
41536 if (equiv->type && !equiv->type->clientdata)
41537 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41538 }
41539 equiv = equiv->next;
41540 }
41541 }
41542 }
41543 }
41544
41545 #ifdef __cplusplus
41546 #if 0
41547 {
41548 /* c-mode */
41549 #endif
41550 }
41551 #endif
41552
41553
41554
41555 #ifdef __cplusplus
41556 extern "C" {
41557 #endif
41558
41559 /* Python-specific SWIG API */
41560 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41561 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41562 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41563
41564 /* -----------------------------------------------------------------------------
41565 * global variable support code.
41566 * ----------------------------------------------------------------------------- */
41567
41568 typedef struct swig_globalvar {
41569 char *name; /* Name of global variable */
41570 PyObject *(*get_attr)(void); /* Return the current value */
41571 int (*set_attr)(PyObject *); /* Set the value */
41572 struct swig_globalvar *next;
41573 } swig_globalvar;
41574
41575 typedef struct swig_varlinkobject {
41576 PyObject_HEAD
41577 swig_globalvar *vars;
41578 } swig_varlinkobject;
41579
41580 SWIGINTERN PyObject *
41581 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41582 return PyString_FromString("<Swig global variables>");
41583 }
41584
41585 SWIGINTERN PyObject *
41586 swig_varlink_str(swig_varlinkobject *v) {
41587 PyObject *str = PyString_FromString("(");
41588 swig_globalvar *var;
41589 for (var = v->vars; var; var=var->next) {
41590 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41591 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41592 }
41593 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41594 return str;
41595 }
41596
41597 SWIGINTERN int
41598 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41599 PyObject *str = swig_varlink_str(v);
41600 fprintf(fp,"Swig global variables ");
41601 fprintf(fp,"%s\n", PyString_AsString(str));
41602 Py_DECREF(str);
41603 return 0;
41604 }
41605
41606 SWIGINTERN void
41607 swig_varlink_dealloc(swig_varlinkobject *v) {
41608 swig_globalvar *var = v->vars;
41609 while (var) {
41610 swig_globalvar *n = var->next;
41611 free(var->name);
41612 free(var);
41613 var = n;
41614 }
41615 }
41616
41617 SWIGINTERN PyObject *
41618 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41619 PyObject *res = NULL;
41620 swig_globalvar *var = v->vars;
41621 while (var) {
41622 if (strcmp(var->name,n) == 0) {
41623 res = (*var->get_attr)();
41624 break;
41625 }
41626 var = var->next;
41627 }
41628 if (res == NULL && !PyErr_Occurred()) {
41629 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41630 }
41631 return res;
41632 }
41633
41634 SWIGINTERN int
41635 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41636 int res = 1;
41637 swig_globalvar *var = v->vars;
41638 while (var) {
41639 if (strcmp(var->name,n) == 0) {
41640 res = (*var->set_attr)(p);
41641 break;
41642 }
41643 var = var->next;
41644 }
41645 if (res == 1 && !PyErr_Occurred()) {
41646 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41647 }
41648 return res;
41649 }
41650
41651 SWIGINTERN PyTypeObject*
41652 swig_varlink_type(void) {
41653 static char varlink__doc__[] = "Swig var link object";
41654 static PyTypeObject varlink_type;
41655 static int type_init = 0;
41656 if (!type_init) {
41657 const PyTypeObject tmp
41658 = {
41659 PyObject_HEAD_INIT(NULL)
41660 0, /* Number of items in variable part (ob_size) */
41661 (char *)"swigvarlink", /* Type name (tp_name) */
41662 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41663 0, /* Itemsize (tp_itemsize) */
41664 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41665 (printfunc) swig_varlink_print, /* Print (tp_print) */
41666 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41667 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41668 0, /* tp_compare */
41669 (reprfunc) swig_varlink_repr, /* tp_repr */
41670 0, /* tp_as_number */
41671 0, /* tp_as_sequence */
41672 0, /* tp_as_mapping */
41673 0, /* tp_hash */
41674 0, /* tp_call */
41675 (reprfunc)swig_varlink_str, /* tp_str */
41676 0, /* tp_getattro */
41677 0, /* tp_setattro */
41678 0, /* tp_as_buffer */
41679 0, /* tp_flags */
41680 varlink__doc__, /* tp_doc */
41681 0, /* tp_traverse */
41682 0, /* tp_clear */
41683 0, /* tp_richcompare */
41684 0, /* tp_weaklistoffset */
41685 #if PY_VERSION_HEX >= 0x02020000
41686 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41687 #endif
41688 #if PY_VERSION_HEX >= 0x02030000
41689 0, /* tp_del */
41690 #endif
41691 #ifdef COUNT_ALLOCS
41692 0,0,0,0 /* tp_alloc -> tp_next */
41693 #endif
41694 };
41695 varlink_type = tmp;
41696 varlink_type.ob_type = &PyType_Type;
41697 type_init = 1;
41698 }
41699 return &varlink_type;
41700 }
41701
41702 /* Create a variable linking object for use later */
41703 SWIGINTERN PyObject *
41704 SWIG_Python_newvarlink(void) {
41705 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41706 if (result) {
41707 result->vars = 0;
41708 }
41709 return ((PyObject*) result);
41710 }
41711
41712 SWIGINTERN void
41713 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41714 swig_varlinkobject *v = (swig_varlinkobject *) p;
41715 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41716 if (gv) {
41717 size_t size = strlen(name)+1;
41718 gv->name = (char *)malloc(size);
41719 if (gv->name) {
41720 strncpy(gv->name,name,size);
41721 gv->get_attr = get_attr;
41722 gv->set_attr = set_attr;
41723 gv->next = v->vars;
41724 }
41725 }
41726 v->vars = gv;
41727 }
41728
41729 SWIGINTERN PyObject *
41730 SWIG_globals() {
41731 static PyObject *_SWIG_globals = 0;
41732 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41733 return _SWIG_globals;
41734 }
41735
41736 /* -----------------------------------------------------------------------------
41737 * constants/methods manipulation
41738 * ----------------------------------------------------------------------------- */
41739
41740 /* Install Constants */
41741 SWIGINTERN void
41742 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41743 PyObject *obj = 0;
41744 size_t i;
41745 for (i = 0; constants[i].type; ++i) {
41746 switch(constants[i].type) {
41747 case SWIG_PY_POINTER:
41748 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41749 break;
41750 case SWIG_PY_BINARY:
41751 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41752 break;
41753 default:
41754 obj = 0;
41755 break;
41756 }
41757 if (obj) {
41758 PyDict_SetItemString(d, constants[i].name, obj);
41759 Py_DECREF(obj);
41760 }
41761 }
41762 }
41763
41764 /* -----------------------------------------------------------------------------*/
41765 /* Fix SwigMethods to carry the callback ptrs when needed */
41766 /* -----------------------------------------------------------------------------*/
41767
41768 SWIGINTERN void
41769 SWIG_Python_FixMethods(PyMethodDef *methods,
41770 swig_const_info *const_table,
41771 swig_type_info **types,
41772 swig_type_info **types_initial) {
41773 size_t i;
41774 for (i = 0; methods[i].ml_name; ++i) {
41775 const char *c = methods[i].ml_doc;
41776 if (c && (c = strstr(c, "swig_ptr: "))) {
41777 int j;
41778 swig_const_info *ci = 0;
41779 const char *name = c + 10;
41780 for (j = 0; const_table[j].type; ++j) {
41781 if (strncmp(const_table[j].name, name,
41782 strlen(const_table[j].name)) == 0) {
41783 ci = &(const_table[j]);
41784 break;
41785 }
41786 }
41787 if (ci) {
41788 size_t shift = (ci->ptype) - types;
41789 swig_type_info *ty = types_initial[shift];
41790 size_t ldoc = (c - methods[i].ml_doc);
41791 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
41792 char *ndoc = (char*)malloc(ldoc + lptr + 10);
41793 if (ndoc) {
41794 char *buff = ndoc;
41795 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
41796 if (ptr) {
41797 strncpy(buff, methods[i].ml_doc, ldoc);
41798 buff += ldoc;
41799 strncpy(buff, "swig_ptr: ", 10);
41800 buff += 10;
41801 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
41802 methods[i].ml_doc = ndoc;
41803 }
41804 }
41805 }
41806 }
41807 }
41808 }
41809
41810 #ifdef __cplusplus
41811 }
41812 #endif
41813
41814 /* -----------------------------------------------------------------------------*
41815 * Partial Init method
41816 * -----------------------------------------------------------------------------*/
41817
41818 #ifdef __cplusplus
41819 extern "C"
41820 #endif
41821 SWIGEXPORT void SWIG_init(void) {
41822 PyObject *m, *d;
41823
41824 /* Fix SwigMethods to carry the callback ptrs when needed */
41825 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
41826
41827 m = Py_InitModule((char *) SWIG_name, SwigMethods);
41828 d = PyModule_GetDict(m);
41829
41830 SWIG_InitializeModule(0);
41831 SWIG_InstallConstants(d,swig_const_table);
41832
41833
41834 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
41835 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
41836 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
41837 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
41838 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
41839 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
41840 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
41841 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
41842 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
41843 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
41844 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
41845 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
41846 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
41847 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
41848 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
41849 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
41850 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
41851 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
41852 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
41853 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
41854 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
41855 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
41856 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
41857 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
41858 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
41859 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
41860 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
41861 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
41862 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
41863 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
41864 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
41865 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
41866 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
41867 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
41868 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
41869 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
41870 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
41871 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
41872 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
41873 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
41874 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
41875 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
41876 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
41877 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
41878 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
41879 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
41880 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
41881 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
41882 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
41883 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
41884 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
41885 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
41886 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
41887 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
41888 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
41889 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
41890 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
41891 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
41892 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
41893 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
41894 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
41895 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
41896 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
41897 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
41898 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
41899 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
41900 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
41901 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
41902 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
41903 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
41904 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
41905 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
41906 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
41907 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
41908 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
41909 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
41910 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
41911 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
41912 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
41913 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
41914 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
41915 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
41916 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
41917 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
41918 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
41919 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
41920 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
41921 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
41922 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
41923 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
41924 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
41925 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
41926 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
41927 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
41928 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
41929 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
41930 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
41931 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
41932 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
41933 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
41934 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
41935 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
41936 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
41937 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
41938 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
41939 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
41940 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
41941 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
41942 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
41943 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
41944 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
41945 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
41946 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
41947 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
41948 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
41949 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
41950 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
41951 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
41952 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
41953 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
41954 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
41955 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
41956 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
41957 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
41958 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
41959 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
41960 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
41961 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
41962 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
41963 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
41964 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
41965 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
41966 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
41967 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
41968 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
41969 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
41970 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
41971 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
41972 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
41973 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
41974 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
41975 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
41976 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
41977 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
41978 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
41979 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
41980 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
41981 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
41982
41983 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
41984
41985 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
41986 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
41987 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
41988 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
41989 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
41990 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
41991 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
41992 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
41993 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
41994 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
41995 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
41996 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
41997 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
41998 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
41999 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
42000 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
42001 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
42002 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
42003 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
42004 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
42005 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
42006 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
42007 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
42008 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
42009 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
42010 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
42011 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
42012 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
42013 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
42014 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
42015 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
42016 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
42017 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
42018 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
42019 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
42020 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
42021 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
42022 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
42023 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
42024 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
42025 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
42026 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
42027 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
42028 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
42029 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
42030 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
42031 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
42032 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
42033 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
42034 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
42035 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
42036 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
42037 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
42038
42039 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
42040
42041 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
42042 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
42043 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
42044 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
42045 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
42046 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
42047 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
42048 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
42049 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
42050 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
42051 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
42052 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
42053 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
42054 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
42055 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
42056 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
42057 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
42058 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
42059 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
42060 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
42061 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
42062 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
42063 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
42064 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
42065 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
42066 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
42067 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
42068 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
42069 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
42070 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
42071 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
42072 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
42073 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
42074 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
42075 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
42076 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
42077 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
42078 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
42079 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
42080 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
42081 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
42082 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
42083 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
42084 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
42085 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
42086 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
42087 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
42088 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
42089 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
42090 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
42091 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
42092 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
42093 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
42094 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
42095 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
42096 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
42097 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
42098 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
42099 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
42100 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
42101 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
42102 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
42103 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
42104 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
42105 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
42106 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
42107 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
42108 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
42109 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
42110 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
42111 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
42112 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
42113 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
42114 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
42115 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
42116 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
42117
42118 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
42119
42120 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
42121 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42122 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42123 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42124 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42125 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42126 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42127 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42128 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42129 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42130 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42131 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42132 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42133 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42134 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42135 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42136 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42137 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42138 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42139 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42140 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42141 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42142 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42143 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42144 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42145 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42146 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42147 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42148 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42149 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42150 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42151 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42152 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42153 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42154 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42155 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42156 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42157 SWIG_Python_SetConstant(d, "DateTime_GMT13",SWIG_From_int(static_cast< int >(wxDateTime::GMT13)));
42158 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42159 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42160 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42161 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42162 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42163 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42164 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42165 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42166 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42167 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42168 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42169 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42170 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42171 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42172 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42173 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42174 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42175 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42176 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42177 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42178 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42179 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42180 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42181 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42182 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42183 SWIG_Python_SetConstant(d, "DateTime_NZST",SWIG_From_int(static_cast< int >(wxDateTime::NZST)));
42184 SWIG_Python_SetConstant(d, "DateTime_NZDT",SWIG_From_int(static_cast< int >(wxDateTime::NZDT)));
42185 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42186 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42187 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42188 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42189 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42190 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42191 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42192 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42193 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42194 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42195 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42196 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42197 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42198 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42199 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42200 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42201 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42202 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42203 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42204 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42205 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42206 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42207 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42208 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42209 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42210 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42211 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42212 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42213 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42214 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42215 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42216 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42217 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42218 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42219 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42220 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42221 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42222 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42223 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42224 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42225 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42226 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42227 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42228 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42229 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42230 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42231 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42232 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42233 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42234 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42235 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42236 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42237 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42238 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42239 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42240 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42241 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42242 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42243 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42244 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42245 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42246 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42247 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42248 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42249 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42250 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42251 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42252 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42253 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42254 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42255 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42256 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42257 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42258 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42259 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42260 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42261 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42262 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42263 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42264 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42265 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42266 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42267 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42268 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42269 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42270 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42271 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42272 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42273 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42274 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42275 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42276 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42277 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42278 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42279 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42280 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42281 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42282 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42283 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42284 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42285 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42286 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42287 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42288 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42289 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42290 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42291 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42292 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42293 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42294 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42295 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42296 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42297 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42298 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42299 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42300 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42301 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42302 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42303 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42304 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42305 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42306 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42307 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42308 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42309 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42310 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42311 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42312 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42313 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42314 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42315 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42316 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42317 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42318 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42319 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42320 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42321 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42322 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42323
42324 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42325 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42326 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42327 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42328
42329 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42330 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42331 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42332 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42333 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42334 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42335 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42336 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42337 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42338 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42339 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42340 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42341 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42342 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42343 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42344 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42345 }
42346
wxWidgets (Impactor)