]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
also update manual.tex
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_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_wxMetafile swig_types[94]
2561 #define SWIGTYPE_p_wxMetafileDataObject swig_types[95]
2562 #define SWIGTYPE_p_wxMimeTypesManager swig_types[96]
2563 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseEvent swig_types[99]
2566 #define SWIGTYPE_p_wxMouseState swig_types[100]
2567 #define SWIGTYPE_p_wxMoveEvent swig_types[101]
2568 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[102]
2569 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[103]
2570 #define SWIGTYPE_p_wxNcPaintEvent swig_types[104]
2571 #define SWIGTYPE_p_wxNotifyEvent swig_types[105]
2572 #define SWIGTYPE_p_wxObject swig_types[106]
2573 #define SWIGTYPE_p_wxOutputStream swig_types[107]
2574 #define SWIGTYPE_p_wxPCXHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNGHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPNMHandler swig_types[110]
2577 #define SWIGTYPE_p_wxPaintEvent swig_types[111]
2578 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[112]
2579 #define SWIGTYPE_p_wxPaperSize swig_types[113]
2580 #define SWIGTYPE_p_wxPlatformInfo swig_types[114]
2581 #define SWIGTYPE_p_wxPoint swig_types[115]
2582 #define SWIGTYPE_p_wxPowerEvent swig_types[116]
2583 #define SWIGTYPE_p_wxProcessEvent swig_types[117]
2584 #define SWIGTYPE_p_wxPyApp swig_types[118]
2585 #define SWIGTYPE_p_wxPyArtProvider swig_types[119]
2586 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[120]
2587 #define SWIGTYPE_p_wxPyCommandEvent swig_types[121]
2588 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[122]
2589 #define SWIGTYPE_p_wxPyDropSource swig_types[123]
2590 #define SWIGTYPE_p_wxPyDropTarget swig_types[124]
2591 #define SWIGTYPE_p_wxPyEvent swig_types[125]
2592 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[126]
2593 #define SWIGTYPE_p_wxPyImageHandler swig_types[127]
2594 #define SWIGTYPE_p_wxPyLog swig_types[128]
2595 #define SWIGTYPE_p_wxPyProcess swig_types[129]
2596 #define SWIGTYPE_p_wxPySizer swig_types[130]
2597 #define SWIGTYPE_p_wxPyTextDataObject swig_types[131]
2598 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[132]
2599 #define SWIGTYPE_p_wxPyTimer swig_types[133]
2600 #define SWIGTYPE_p_wxPyTipProvider swig_types[134]
2601 #define SWIGTYPE_p_wxPyValidator swig_types[135]
2602 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[136]
2603 #define SWIGTYPE_p_wxRect swig_types[137]
2604 #define SWIGTYPE_p_wxScrollEvent swig_types[138]
2605 #define SWIGTYPE_p_wxScrollWinEvent swig_types[139]
2606 #define SWIGTYPE_p_wxSetCursorEvent swig_types[140]
2607 #define SWIGTYPE_p_wxShowEvent swig_types[141]
2608 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[142]
2609 #define SWIGTYPE_p_wxSize swig_types[143]
2610 #define SWIGTYPE_p_wxSizeEvent swig_types[144]
2611 #define SWIGTYPE_p_wxSizer swig_types[145]
2612 #define SWIGTYPE_p_wxSizerItem swig_types[146]
2613 #define SWIGTYPE_p_wxSound swig_types[147]
2614 #define SWIGTYPE_p_wxStandardPaths swig_types[148]
2615 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[149]
2616 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[150]
2617 #define SWIGTYPE_p_wxStopWatch swig_types[151]
2618 #define SWIGTYPE_p_wxString swig_types[152]
2619 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[153]
2620 #define SWIGTYPE_p_wxSystemOptions swig_types[154]
2621 #define SWIGTYPE_p_wxSystemSettings swig_types[155]
2622 #define SWIGTYPE_p_wxTGAHandler swig_types[156]
2623 #define SWIGTYPE_p_wxTIFFHandler swig_types[157]
2624 #define SWIGTYPE_p_wxTextCtrl swig_types[158]
2625 #define SWIGTYPE_p_wxTextDataObject swig_types[159]
2626 #define SWIGTYPE_p_wxTimeSpan swig_types[160]
2627 #define SWIGTYPE_p_wxTimer swig_types[161]
2628 #define SWIGTYPE_p_wxTimerEvent swig_types[162]
2629 #define SWIGTYPE_p_wxTimerRunner swig_types[163]
2630 #define SWIGTYPE_p_wxTipProvider swig_types[164]
2631 #define SWIGTYPE_p_wxToolTip swig_types[165]
2632 #define SWIGTYPE_p_wxURLDataObject swig_types[166]
2633 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[167]
2634 #define SWIGTYPE_p_wxValidator swig_types[168]
2635 #define SWIGTYPE_p_wxVideoMode swig_types[169]
2636 #define SWIGTYPE_p_wxWindow swig_types[170]
2637 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[171]
2638 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[172]
2639 #define SWIGTYPE_p_wxWindowDisabler swig_types[173]
2640 #define SWIGTYPE_p_wxXPMHandler swig_types[174]
2641 static swig_type_info *swig_types[176];
2642 static swig_module_info swig_module = {swig_types, 175, 0, 0, 0, 0};
2643 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2644 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2645
2646 /* -------- TYPES TABLE (END) -------- */
2647
2648 #if (PY_VERSION_HEX <= 0x02000000)
2649 # if !defined(SWIG_PYTHON_CLASSIC)
2650 # error "This python version requires to use swig with the '-classic' option"
2651 # endif
2652 #endif
2653 #if (PY_VERSION_HEX <= 0x02020000)
2654 # error "This python version requires to use swig with the '-nomodern' option"
2655 #endif
2656 #if (PY_VERSION_HEX <= 0x02020000)
2657 # error "This python version requires to use swig with the '-nomodernargs' option"
2658 #endif
2659 #ifndef METH_O
2660 # error "This python version requires to use swig with the '-nofastunpack' option"
2661 #endif
2662
2663 /*-----------------------------------------------
2664 @(target):= _misc_.so
2665 ------------------------------------------------*/
2666 #define SWIG_init init_misc_
2667
2668 #define SWIG_name "_misc_"
2669
2670 #define SWIGVERSION 0x010329
2671
2672
2673 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2674 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2675
2676
2677 #include <stdexcept>
2678
2679
2680 namespace swig {
2681 class PyObject_ptr {
2682 protected:
2683 PyObject *_obj;
2684
2685 public:
2686 PyObject_ptr() :_obj(0)
2687 {
2688 }
2689
2690 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2691 {
2692 Py_XINCREF(_obj);
2693 }
2694
2695 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2696 {
2697 if (initial_ref) Py_XINCREF(_obj);
2698 }
2699
2700 PyObject_ptr & operator=(const PyObject_ptr& item)
2701 {
2702 Py_XINCREF(item._obj);
2703 Py_XDECREF(_obj);
2704 _obj = item._obj;
2705 return *this;
2706 }
2707
2708 ~PyObject_ptr()
2709 {
2710 Py_XDECREF(_obj);
2711 }
2712
2713 operator PyObject *() const
2714 {
2715 return _obj;
2716 }
2717
2718 PyObject *operator->() const
2719 {
2720 return _obj;
2721 }
2722 };
2723 }
2724
2725
2726 namespace swig {
2727 struct PyObject_var : PyObject_ptr {
2728 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2729
2730 PyObject_var & operator = (PyObject* obj)
2731 {
2732 Py_XDECREF(_obj);
2733 _obj = obj;
2734 return *this;
2735 }
2736 };
2737 }
2738
2739
2740 #include "wx/wxPython/wxPython.h"
2741 #include "wx/wxPython/pyclasses.h"
2742 #include "wx/wxPython/pyistream.h"
2743
2744 static const wxString wxPyEmptyString(wxEmptyString);
2745
2746
2747
2748 #define SWIG_From_long PyInt_FromLong
2749
2750
2751 SWIGINTERNINLINE PyObject *
2752 SWIG_From_int (int value)
2753 {
2754 return SWIG_From_long (value);
2755 }
2756
2757
2758 #include <limits.h>
2759 #ifndef LLONG_MIN
2760 # define LLONG_MIN LONG_LONG_MIN
2761 #endif
2762 #ifndef LLONG_MAX
2763 # define LLONG_MAX LONG_LONG_MAX
2764 #endif
2765 #ifndef ULLONG_MAX
2766 # define ULLONG_MAX ULONG_LONG_MAX
2767 #endif
2768
2769
2770 SWIGINTERN int
2771 SWIG_AsVal_long (PyObject* obj, long* val)
2772 {
2773 if (PyNumber_Check(obj)) {
2774 if (val) *val = PyInt_AsLong(obj);
2775 return SWIG_OK;
2776 }
2777 return SWIG_TypeError;
2778 }
2779
2780
2781 SWIGINTERN int
2782 SWIG_AsVal_int (PyObject * obj, int *val)
2783 {
2784 long v;
2785 int res = SWIG_AsVal_long (obj, &v);
2786 if (SWIG_IsOK(res)) {
2787 if ((v < INT_MIN || v > INT_MAX)) {
2788 return SWIG_OverflowError;
2789 } else {
2790 if (val) *val = static_cast< int >(v);
2791 }
2792 }
2793 return res;
2794 }
2795
2796 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2797
2798 #include <wx/stockitem.h>
2799
2800 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2801 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2802 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2803
2804 SWIGINTERN int
2805 SWIG_AsVal_bool (PyObject *obj, bool *val)
2806 {
2807 if (obj == Py_True) {
2808 if (val) *val = true;
2809 return SWIG_OK;
2810 } else if (obj == Py_False) {
2811 if (val) *val = false;
2812 return SWIG_OK;
2813 } else {
2814 long v = 0;
2815 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2816 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2817 return res;
2818 }
2819 }
2820
2821
2822 SWIGINTERN int
2823 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2824 {
2825 long v = 0;
2826 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2827 return SWIG_TypeError;
2828 }
2829 else if (val)
2830 *val = (unsigned long)v;
2831 return SWIG_OK;
2832 }
2833
2834
2835 SWIGINTERNINLINE PyObject*
2836 SWIG_From_unsigned_SS_long (unsigned long value)
2837 {
2838 return (value > LONG_MAX) ?
2839 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2840 }
2841
2842
2843 void* wxGetXDisplay()
2844 {
2845 #ifdef __WXGTK__
2846 return wxGetDisplay();
2847 #else
2848 return NULL;
2849 #endif
2850 }
2851
2852
2853 wxWindow* FindWindowAtPointer() {
2854 wxPoint unused;
2855 return wxFindWindowAtPointer(unused);
2856 }
2857
2858
2859 bool wxThread_IsMain() {
2860 #ifdef WXP_WITH_THREAD
2861 return wxThread::IsMain();
2862 #else
2863 return true;
2864 #endif
2865 }
2866
2867 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2868 delete self;
2869 }
2870
2871 #include <wx/snglinst.h>
2872
2873
2874 #ifdef __WXMSW__
2875 #include <wx/msw/private.h>
2876 #include <wx/dynload.h>
2877 #endif
2878
2879
2880
2881 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2882 #if 0
2883 , int method
2884 #endif
2885 )
2886 {
2887 #ifdef __WXMSW__
2888 #if 0
2889 switch (method)
2890 {
2891 case 1:
2892 // This one only partially works. Appears to be an undocumented
2893 // "standard" convention that not all widgets adhear to. For
2894 // example, for some widgets backgrounds or non-client areas may
2895 // not be painted.
2896 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2897 break;
2898
2899 case 2:
2900 #endif
2901 // This one works much better, nearly all widgets and their
2902 // children are captured correctly[**]. Prior to the big
2903 // background erase changes that Vadim did in 2004-2005 this
2904 // method failed badly on XP with Themes activated, most native
2905 // widgets draw only partially, if at all. Without themes it
2906 // worked just like on Win2k. After those changes this method
2907 // works very well.
2908 //
2909 // ** For example the radio buttons in a wxRadioBox are not its
2910 // children by default, but you can capture it via the panel
2911 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2912 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2913 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2914 PRF_ERASEBKGND | PRF_OWNED );
2915 return true;
2916 #if 0
2917 break;
2918
2919 case 3:
2920 // This one is only defined in the latest SDK and is only
2921 // available on XP. MSDN says it is similar to sending WM_PRINT
2922 // so I expect that it will work similar to the above. Since it
2923 // is avaialble only on XP, it can't be compiled like this and
2924 // will have to be loaded dynamically.
2925 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2926
2927 // fall through
2928
2929 case 4:
2930 // Use PrintWindow if available, or fallback to WM_PRINT
2931 // otherwise. Unfortunately using PrintWindow is even worse than
2932 // WM_PRINT. For most native widgets nothing is drawn to the dc
2933 // at all, with or without Themes.
2934 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2935 static bool s_triedToLoad = false;
2936 static PrintWindow_t pfnPrintWindow = NULL;
2937 if ( !s_triedToLoad )
2938 {
2939
2940 s_triedToLoad = true;
2941 wxDynamicLibrary dllUser32(_T("user32.dll"));
2942 if ( dllUser32.IsLoaded() )
2943 {
2944 wxLogNull nolog; // Don't report errors here
2945 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2946 }
2947 }
2948 if (pfnPrintWindow)
2949 {
2950 //printf("Using PrintWindow\n");
2951 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2952 }
2953 else
2954 {
2955 //printf("Using WM_PRINT\n");
2956 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2957 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2958 PRF_ERASEBKGND | PRF_OWNED );
2959 }
2960 }
2961 #endif // 0
2962 #else
2963 return false;
2964 #endif // __WXMSW__
2965 }
2966
2967
2968
2969 #include <wx/tipdlg.h>
2970
2971
2972 SWIGINTERNINLINE PyObject *
2973 SWIG_From_size_t (size_t value)
2974 {
2975 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2976 }
2977
2978
2979 class wxPyTipProvider : public wxTipProvider {
2980 public:
2981 wxPyTipProvider(size_t currentTip)
2982 : wxTipProvider(currentTip) {}
2983
2984 DEC_PYCALLBACK_STRING__pure(GetTip);
2985 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2986 PYPRIVATE;
2987 };
2988
2989 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2990 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2991
2992
2993 SWIGINTERNINLINE int
2994 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2995 {
2996 unsigned long v;
2997 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2998 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2999 return res;
3000 }
3001
3002
3003 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3004
3005 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3006
3007 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3008 : wxTimer(owner, id)
3009 {
3010 if (owner == NULL)
3011 SetOwner(this);
3012 }
3013
3014 wxPyTimer::~wxPyTimer()
3015 {
3016 // printf("-=* ~wxPyTimer\n");
3017 }
3018
3019
3020
3021 SWIGINTERN swig_type_info*
3022 SWIG_pchar_descriptor()
3023 {
3024 static int init = 0;
3025 static swig_type_info* info = 0;
3026 if (!init) {
3027 info = SWIG_TypeQuery("_p_char");
3028 init = 1;
3029 }
3030 return info;
3031 }
3032
3033
3034 SWIGINTERNINLINE PyObject *
3035 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3036 {
3037 if (carray) {
3038 if (size > INT_MAX) {
3039 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3040 return pchar_descriptor ?
3041 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3042 } else {
3043 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3044 }
3045 } else {
3046 return SWIG_Py_Void();
3047 }
3048 }
3049
3050
3051 SWIGINTERNINLINE PyObject *
3052 SWIG_FromCharPtr(const char *cptr)
3053 {
3054 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3055 }
3056
3057
3058 SWIGINTERN int
3059 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3060 {
3061 unsigned long v;
3062 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3063 if (SWIG_IsOK(res)) {
3064 if ((v > UINT_MAX)) {
3065 return SWIG_OverflowError;
3066 } else {
3067 if (val) *val = static_cast< unsigned int >(v);
3068 }
3069 }
3070 return res;
3071 }
3072
3073 SWIGINTERN wxString wxLog_TimeStamp(){
3074 wxString msg;
3075 wxLog::TimeStamp(&msg);
3076 return msg;
3077 }
3078 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3079 // Make some wrappers that double any % signs so they are 'escaped'
3080 void wxPyLogFatalError(const wxString& msg)
3081 {
3082 wxString m(msg);
3083 m.Replace(wxT("%"), wxT("%%"));
3084 wxLogFatalError(m);
3085 }
3086
3087 void wxPyLogError(const wxString& msg)
3088 {
3089 wxString m(msg);
3090 m.Replace(wxT("%"), wxT("%%"));
3091 wxLogError(m);
3092 }
3093
3094 void wxPyLogWarning(const wxString& msg)
3095 {
3096 wxString m(msg);
3097 m.Replace(wxT("%"), wxT("%%"));
3098 wxLogWarning(m);
3099 }
3100
3101 void wxPyLogMessage(const wxString& msg)
3102 {
3103 wxString m(msg);
3104 m.Replace(wxT("%"), wxT("%%"));
3105 wxLogMessage(m);
3106 }
3107
3108 void wxPyLogInfo(const wxString& msg)
3109 {
3110 wxString m(msg);
3111 m.Replace(wxT("%"), wxT("%%"));
3112 wxLogInfo(m);
3113 }
3114
3115 void wxPyLogDebug(const wxString& msg)
3116 {
3117 wxString m(msg);
3118 m.Replace(wxT("%"), wxT("%%"));
3119 wxLogDebug(m);
3120 }
3121
3122 void wxPyLogVerbose(const wxString& msg)
3123 {
3124 wxString m(msg);
3125 m.Replace(wxT("%"), wxT("%%"));
3126 wxLogVerbose(m);
3127 }
3128
3129 void wxPyLogStatus(const wxString& msg)
3130 {
3131 wxString m(msg);
3132 m.Replace(wxT("%"), wxT("%%"));
3133 wxLogStatus(m);
3134 }
3135
3136 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3137 {
3138 wxString m(msg);
3139 m.Replace(wxT("%"), wxT("%%"));
3140 wxLogStatus(pFrame, m);
3141 }
3142
3143 void wxPyLogSysError(const wxString& msg)
3144 {
3145 wxString m(msg);
3146 m.Replace(wxT("%"), wxT("%%"));
3147 wxLogSysError(m);
3148 }
3149
3150 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3151 {
3152 wxString m(msg);
3153 m.Replace(wxT("%"), wxT("%%"));
3154 wxLogGeneric(level, m);
3155 }
3156
3157 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3158 {
3159 wxString m(msg);
3160 m.Replace(wxT("%"), wxT("%%"));
3161 wxLogTrace(mask, m);
3162 }
3163
3164 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3165 {
3166 wxString m(msg);
3167 m.Replace(wxT("%"), wxT("%%"));
3168 wxLogTrace(mask, m);
3169 }
3170
3171
3172
3173 // A wxLog class that can be derived from in wxPython
3174 class wxPyLog : public wxLog {
3175 public:
3176 wxPyLog() : wxLog() {}
3177
3178 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3179 bool found;
3180 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3181 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3182 PyObject* s = wx2PyString(szString);
3183 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3184 Py_DECREF(s);
3185 }
3186 wxPyEndBlockThreads(blocked);
3187 if (! found)
3188 wxLog::DoLog(level, szString, t);
3189 }
3190
3191 virtual void DoLogString(const wxChar *szString, time_t t) {
3192 bool found;
3193 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3194 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3195 PyObject* s = wx2PyString(szString);
3196 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3197 Py_DECREF(s);
3198 }
3199 wxPyEndBlockThreads(blocked);
3200 if (! found)
3201 wxLog::DoLogString(szString, t);
3202 }
3203
3204 DEC_PYCALLBACK_VOID_(Flush);
3205 PYPRIVATE;
3206 };
3207 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3208
3209
3210
3211
3212 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3213
3214
3215 #include <wx/joystick.h>
3216
3217
3218 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3219 // A C++ stub class for wxJoystick for platforms that don't have it.
3220 class wxJoystick : public wxObject {
3221 public:
3222 wxJoystick(int joystick = wxJOYSTICK1) {
3223 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3224 PyErr_SetString(PyExc_NotImplementedError,
3225 "wxJoystick is not available on this platform.");
3226 wxPyEndBlockThreads(blocked);
3227 }
3228 wxPoint GetPosition() { return wxPoint(-1,-1); }
3229 int GetZPosition() { return -1; }
3230 int GetButtonState() { return -1; }
3231 int GetPOVPosition() { return -1; }
3232 int GetPOVCTSPosition() { return -1; }
3233 int GetRudderPosition() { return -1; }
3234 int GetUPosition() { return -1; }
3235 int GetVPosition() { return -1; }
3236 int GetMovementThreshold() { return -1; }
3237 void SetMovementThreshold(int threshold) {}
3238
3239 bool IsOk(void) { return false; }
3240 int GetNumberJoysticks() { return -1; }
3241 int GetManufacturerId() { return -1; }
3242 int GetProductId() { return -1; }
3243 wxString GetProductName() { return wxEmptyString; }
3244 int GetXMin() { return -1; }
3245 int GetYMin() { return -1; }
3246 int GetZMin() { return -1; }
3247 int GetXMax() { return -1; }
3248 int GetYMax() { return -1; }
3249 int GetZMax() { return -1; }
3250 int GetNumberButtons() { return -1; }
3251 int GetNumberAxes() { return -1; }
3252 int GetMaxButtons() { return -1; }
3253 int GetMaxAxes() { return -1; }
3254 int GetPollingMin() { return -1; }
3255 int GetPollingMax() { return -1; }
3256 int GetRudderMin() { return -1; }
3257 int GetRudderMax() { return -1; }
3258 int GetUMin() { return -1; }
3259 int GetUMax() { return -1; }
3260 int GetVMin() { return -1; }
3261 int GetVMax() { return -1; }
3262
3263 bool HasRudder() { return false; }
3264 bool HasZ() { return false; }
3265 bool HasU() { return false; }
3266 bool HasV() { return false; }
3267 bool HasPOV() { return false; }
3268 bool HasPOV4Dir() { return false; }
3269 bool HasPOVCTS() { return false; }
3270
3271 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3272 bool ReleaseCapture() { return false; }
3273 };
3274 #endif
3275
3276
3277 #include <wx/sound.h>
3278
3279
3280 #if !wxUSE_SOUND
3281 // A C++ stub class for wxWave for platforms that don't have it.
3282 class wxSound : public wxObject
3283 {
3284 public:
3285 wxSound() {
3286 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3287 PyErr_SetString(PyExc_NotImplementedError,
3288 "wxSound is not available on this platform.");
3289 wxPyEndBlockThreads(blocked);
3290 }
3291 wxSound(const wxString&/*, bool*/) {
3292 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3293 PyErr_SetString(PyExc_NotImplementedError,
3294 "wxSound is not available on this platform.");
3295 wxPyEndBlockThreads(blocked);
3296 }
3297 wxSound(int, const wxByte*) {
3298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3299 PyErr_SetString(PyExc_NotImplementedError,
3300 "wxSound is not available on this platform.");
3301 wxPyEndBlockThreads(blocked);
3302 }
3303
3304 ~wxSound() {};
3305
3306 bool Create(const wxString&/*, bool*/) { return false; }
3307 bool Create(int, const wxByte*) { return false; };
3308 bool IsOk() { return false; };
3309 bool Play(unsigned) const { return false; }
3310 static bool Play(const wxString&, unsigned) { return false; }
3311 static void Stop() {}
3312 };
3313
3314 #endif
3315
3316 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3317 if (fileName.Length() == 0)
3318 return new wxSound;
3319 else
3320 return new wxSound(fileName);
3321 }
3322 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3323 unsigned char* buffer; int size;
3324 wxSound *sound = NULL;
3325
3326 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3327 if (!PyArg_Parse(data, "t#", &buffer, &size))
3328 goto done;
3329 sound = new wxSound(size, buffer);
3330 done:
3331 wxPyEndBlockThreads(blocked);
3332 return sound;
3333 }
3334 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3335 #ifndef __WXMAC__
3336 unsigned char* buffer;
3337 int size;
3338 bool rv = false;
3339
3340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3341 if (!PyArg_Parse(data, "t#", &buffer, &size))
3342 goto done;
3343 rv = self->Create(size, buffer);
3344 done:
3345 wxPyEndBlockThreads(blocked);
3346 return rv;
3347 #else
3348 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3349 PyErr_SetString(PyExc_NotImplementedError,
3350 "Create from data is not available on this platform.");
3351 wxPyEndBlockThreads(blocked);
3352 return false;
3353 #endif
3354 }
3355
3356 #include <wx/mimetype.h>
3357
3358 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3359 wxString str;
3360 if (self->GetMimeType(&str))
3361 return wx2PyString(str);
3362 else
3363 RETURN_NONE();
3364 }
3365 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3366 wxArrayString arr;
3367 if (self->GetMimeTypes(arr))
3368 return wxArrayString2PyList_helper(arr);
3369 else
3370 RETURN_NONE();
3371 }
3372 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3373 wxArrayString arr;
3374 if (self->GetExtensions(arr))
3375 return wxArrayString2PyList_helper(arr);
3376 else
3377 RETURN_NONE();
3378 }
3379 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3380 wxIconLocation loc;
3381 if (self->GetIcon(&loc))
3382 return new wxIcon(loc);
3383 else
3384 return NULL;
3385 }
3386 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3387 wxIconLocation loc;
3388 if (self->GetIcon(&loc)) {
3389 wxString iconFile = loc.GetFileName();
3390 int iconIndex = -1;
3391
3392
3393
3394 // Make a tuple and put the values in it
3395 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3396 PyObject* tuple = PyTuple_New(3);
3397 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3398 wxT("wxIcon"), true));
3399 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3400 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3401 wxPyEndBlockThreads(blocked);
3402 return tuple;
3403 }
3404 else
3405 RETURN_NONE();
3406 }
3407 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3408 wxString str;
3409 if (self->GetDescription(&str))
3410 return wx2PyString(str);
3411 else
3412 RETURN_NONE();
3413 }
3414 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3415 wxString str;
3416 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3417 return wx2PyString(str);
3418 else
3419 RETURN_NONE();
3420 }
3421 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3422 wxString str;
3423 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3424 return wx2PyString(str);
3425 else
3426 RETURN_NONE();
3427 }
3428 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3429 wxArrayString verbs;
3430 wxArrayString commands;
3431 if (self->GetAllCommands(&verbs, &commands,
3432 wxFileType::MessageParameters(filename, mimetype))) {
3433 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3434 PyObject* tuple = PyTuple_New(2);
3435 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3436 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3437 wxPyEndBlockThreads(blocked);
3438 return tuple;
3439 }
3440 else
3441 RETURN_NONE();
3442 }
3443 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3444 return wxFileType::ExpandCommand(command,
3445 wxFileType::MessageParameters(filename, mimetype));
3446 }
3447 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3448 wxArrayString arr;
3449 self->EnumAllFileTypes(arr);
3450 return wxArrayString2PyList_helper(arr);
3451 }
3452
3453 #include <wx/artprov.h>
3454
3455 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3456 static const wxString wxPyART_MENU(wxART_MENU);
3457 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3458 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3459 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3460 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3461 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3462 static const wxString wxPyART_OTHER(wxART_OTHER);
3463 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3464 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3465 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3466 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3467 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3468 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3469 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3470 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3471 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3472 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3473 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3474 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3475 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3476 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3477 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3478 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3479 static const wxString wxPyART_PRINT(wxART_PRINT);
3480 static const wxString wxPyART_HELP(wxART_HELP);
3481 static const wxString wxPyART_TIP(wxART_TIP);
3482 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3483 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3484 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3485 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3486 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3487 static const wxString wxPyART_CDROM(wxART_CDROM);
3488 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3489 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3490 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3491 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3492 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3493 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3494 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3495 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3496 static const wxString wxPyART_ERROR(wxART_ERROR);
3497 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3498 static const wxString wxPyART_WARNING(wxART_WARNING);
3499 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3500 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3501 static const wxString wxPyART_COPY(wxART_COPY);
3502 static const wxString wxPyART_CUT(wxART_CUT);
3503 static const wxString wxPyART_PASTE(wxART_PASTE);
3504 static const wxString wxPyART_DELETE(wxART_DELETE);
3505 static const wxString wxPyART_NEW(wxART_NEW);
3506 static const wxString wxPyART_UNDO(wxART_UNDO);
3507 static const wxString wxPyART_REDO(wxART_REDO);
3508 static const wxString wxPyART_QUIT(wxART_QUIT);
3509 static const wxString wxPyART_FIND(wxART_FIND);
3510 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3511 // Python aware wxArtProvider
3512 class wxPyArtProvider : public wxArtProvider {
3513 public:
3514
3515 virtual wxBitmap CreateBitmap(const wxArtID& id,
3516 const wxArtClient& client,
3517 const wxSize& size) {
3518 wxBitmap rval = wxNullBitmap;
3519 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3520 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3521 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3522 PyObject* ro;
3523 wxBitmap* ptr;
3524 PyObject* s1, *s2;
3525 s1 = wx2PyString(id);
3526 s2 = wx2PyString(client);
3527 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3528 Py_DECREF(so);
3529 Py_DECREF(s1);
3530 Py_DECREF(s2);
3531 if (ro) {
3532 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3533 rval = *ptr;
3534 Py_DECREF(ro);
3535 }
3536 }
3537 wxPyEndBlockThreads(blocked);
3538 return rval;
3539 }
3540
3541 PYPRIVATE;
3542 };
3543
3544 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3545
3546
3547
3548 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3549 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3550 PyObject* ret = PyTuple_New(3);
3551 if (ret) {
3552 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3553 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3554 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3555 }
3556 wxPyEndBlockThreads(blocked);
3557 return ret;
3558 }
3559
3560 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3561 bool cont;
3562 long index = 0;
3563 wxString value;
3564
3565 cont = self->GetFirstGroup(value, index);
3566 return __EnumerationHelper(cont, value, index);
3567 }
3568 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3569 bool cont;
3570 wxString value;
3571
3572 cont = self->GetNextGroup(value, index);
3573 return __EnumerationHelper(cont, value, index);
3574 }
3575 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3576 bool cont;
3577 long index = 0;
3578 wxString value;
3579
3580 cont = self->GetFirstEntry(value, index);
3581 return __EnumerationHelper(cont, value, index);
3582 }
3583 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3584 bool cont;
3585 wxString value;
3586
3587 cont = self->GetNextEntry(value, index);
3588 return __EnumerationHelper(cont, value, index);
3589 }
3590 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3591 long rv;
3592 self->Read(key, &rv, defaultVal);
3593 return rv;
3594 }
3595
3596 SWIGINTERN int
3597 SWIG_AsVal_double (PyObject *obj, double* val)
3598 {
3599 if (PyNumber_Check(obj)) {
3600 if (val) *val = PyFloat_AsDouble(obj);
3601 return SWIG_OK;
3602 }
3603 return SWIG_TypeError;
3604 }
3605
3606 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3607 double rv;
3608 self->Read(key, &rv, defaultVal);
3609 return rv;
3610 }
3611
3612 #define SWIG_From_double PyFloat_FromDouble
3613
3614 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3615 bool rv;
3616 self->Read(key, &rv, defaultVal);
3617 return rv;
3618 }
3619
3620 #include <wx/datetime.h>
3621
3622 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3623 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3624
3625 #define LOCAL_TZ wxDateTime::Local
3626
3627 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3628 wxString am;
3629 wxString pm;
3630 wxDateTime::GetAmPmStrings(&am, &pm);
3631 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3632 PyObject* tup = PyTuple_New(2);
3633 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3634 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3635 wxPyEndBlockThreads(blocked);
3636 return tup;
3637 }
3638
3639 SWIGINTERNINLINE PyObject *
3640 SWIG_From_unsigned_SS_int (unsigned int value)
3641 {
3642 return SWIG_From_unsigned_SS_long (value);
3643 }
3644
3645 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3646 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3647 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3648 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3649 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3650 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3651 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3652 return (*self < *other);
3653 }
3654 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3655 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3656 return (*self <= *other);
3657 }
3658 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3659 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3660 return (*self > *other);
3661 }
3662 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3663 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3664 return (*self >= *other);
3665 }
3666 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3667 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3668 return (*self == *other);
3669 }
3670 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3671 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3672 return (*self != *other);
3673 }
3674 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3675 const wxChar* rv;
3676 const wxChar* _date = date;
3677 rv = self->ParseRfc822Date(_date);
3678 if (rv == NULL) return -1;
3679 return rv - _date;
3680 }
3681 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3682 const wxChar* rv;
3683 const wxChar* _date = date;
3684 rv = self->ParseFormat(_date, format, dateDef);
3685 if (rv == NULL) return -1;
3686 return rv - _date;
3687 }
3688 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3689 const wxChar* rv;
3690 const wxChar* _datetime = datetime;
3691 rv = self->ParseDateTime(_datetime);
3692 if (rv == NULL) return -1;
3693 return rv - _datetime;
3694 }
3695 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3696 const wxChar* rv;
3697 const wxChar* _date = date;
3698 rv = self->ParseDate(_date);
3699 if (rv == NULL) return -1;
3700 return rv - _date;
3701 }
3702 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3703 const wxChar* rv;
3704 const wxChar* _time = time;
3705 rv = self->ParseTime(_time);
3706 if (rv == NULL) return -1;
3707 return rv - _time;
3708 }
3709 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3710 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3711 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3712 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3713 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3714 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3715 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3716 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3717 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3718 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3719 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3720 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3721 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3722 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3723 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3724 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3725
3726 #include <wx/dataobj.h>
3727
3728 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3729 size_t count = self->GetFormatCount(dir);
3730 wxDataFormat* formats = new wxDataFormat[count];
3731 self->GetAllFormats(formats, dir);
3732
3733 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3734 PyObject* list = PyList_New(count);
3735 for (size_t i=0; i<count; i++) {
3736 wxDataFormat* format = new wxDataFormat(formats[i]);
3737 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3738 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3739 }
3740 wxPyEndBlockThreads(blocked);
3741 delete [] formats;
3742 return list;
3743 }
3744 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3745 PyObject* rval = NULL;
3746 size_t size = self->GetDataSize(format);
3747 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3748 if (size) {
3749 char* buf = new char[size];
3750 if (self->GetDataHere(format, buf))
3751 rval = PyString_FromStringAndSize(buf, size);
3752 delete [] buf;
3753 }
3754 if (! rval) {
3755 rval = Py_None;
3756 Py_INCREF(rval);
3757 }
3758 wxPyEndBlockThreads(blocked);
3759 return rval;
3760 }
3761 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3762 bool rval;
3763 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3764 if (PyString_Check(data)) {
3765 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3766 }
3767 else {
3768 // raise a TypeError if not a string
3769 PyErr_SetString(PyExc_TypeError, "String expected.");
3770 rval = false;
3771 }
3772 wxPyEndBlockThreads(blocked);
3773 return rval;
3774 }
3775 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3776 PyObject* rval = NULL;
3777 size_t size = self->GetDataSize();
3778 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3779 if (size) {
3780 char* buf = new char[size];
3781 if (self->GetDataHere(buf))
3782 rval = PyString_FromStringAndSize(buf, size);
3783 delete [] buf;
3784 }
3785 if (! rval) {
3786 rval = Py_None;
3787 Py_INCREF(rval);
3788 }
3789 wxPyEndBlockThreads(blocked);
3790 return rval;
3791 }
3792 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3793 bool rval;
3794 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3795 if (PyString_Check(data)) {
3796 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3797 }
3798 else {
3799 // raise a TypeError if not a string
3800 PyErr_SetString(PyExc_TypeError, "String expected.");
3801 rval = false;
3802 }
3803 wxPyEndBlockThreads(blocked);
3804 return rval;
3805 }
3806 // Create a new class for wxPython to use
3807 class wxPyDataObjectSimple : public wxDataObjectSimple {
3808 public:
3809 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3810 : wxDataObjectSimple(format) {}
3811
3812 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3813 bool GetDataHere(void *buf) const;
3814 bool SetData(size_t len, const void *buf);
3815 PYPRIVATE;
3816 };
3817
3818 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3819
3820 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3821 // We need to get the data for this object and write it to buf. I think
3822 // the best way to do this for wxPython is to have the Python method
3823 // return either a string or None and then act appropriately with the
3824 // C++ version.
3825
3826 bool rval = false;
3827 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3828 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3829 PyObject* ro;
3830 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3831 if (ro) {
3832 rval = (ro != Py_None && PyString_Check(ro));
3833 if (rval)
3834 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3835 Py_DECREF(ro);
3836 }
3837 }
3838 wxPyEndBlockThreads(blocked);
3839 return rval;
3840 }
3841
3842 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3843 // For this one we simply need to make a string from buf and len
3844 // and send it to the Python method.
3845 bool rval = false;
3846 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3847 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3848 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3849 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3850 Py_DECREF(data);
3851 }
3852 wxPyEndBlockThreads(blocked);
3853 return rval;
3854 }
3855
3856 // Create a new class for wxPython to use
3857 class wxPyTextDataObject : public wxTextDataObject {
3858 public:
3859 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3860 : wxTextDataObject(text) {}
3861
3862 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3863 DEC_PYCALLBACK_STRING__const(GetText);
3864 DEC_PYCALLBACK__STRING(SetText);
3865 PYPRIVATE;
3866 };
3867
3868 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3869 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3870 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3871
3872
3873 // Create a new class for wxPython to use
3874 class wxPyBitmapDataObject : public wxBitmapDataObject {
3875 public:
3876 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3877 : wxBitmapDataObject(bitmap) {}
3878
3879 wxBitmap GetBitmap() const;
3880 void SetBitmap(const wxBitmap& bitmap);
3881 PYPRIVATE;
3882 };
3883
3884 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3885 wxBitmap* rval = &wxNullBitmap;
3886 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3887 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3888 PyObject* ro;
3889 wxBitmap* ptr;
3890 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3891 if (ro) {
3892 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3893 rval = ptr;
3894 Py_DECREF(ro);
3895 }
3896 }
3897 wxPyEndBlockThreads(blocked);
3898 return *rval;
3899 }
3900
3901 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3902 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3903 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3904 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3905 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3906 Py_DECREF(bo);
3907 }
3908 wxPyEndBlockThreads(blocked);
3909 }
3910
3911 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3912 return new wxCustomDataObject(wxDataFormat(formatName));
3913 }
3914 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3915 bool rval;
3916 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3917 if (PyString_Check(data)) {
3918 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3919 }
3920 else {
3921 // raise a TypeError if not a string
3922 PyErr_SetString(PyExc_TypeError, "String expected.");
3923 rval = false;
3924 }
3925 wxPyEndBlockThreads(blocked);
3926 return rval;
3927 }
3928 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3929 PyObject* obj;
3930 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3931 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3932 wxPyEndBlockThreads(blocked);
3933 return obj;
3934 }
3935
3936 #include <wx/metafile.h>
3937
3938
3939 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3940
3941
3942 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3943 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3944 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3945 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3946 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3947
3948
3949 class wxPyTextDropTarget : public wxTextDropTarget {
3950 public:
3951 wxPyTextDropTarget() {}
3952
3953 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3954
3955 DEC_PYCALLBACK__(OnLeave);
3956 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3957 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3958 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3959 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3960
3961 PYPRIVATE;
3962 };
3963
3964 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3965 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3966 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3967 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3968 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3969 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3970
3971
3972
3973 class wxPyFileDropTarget : public wxFileDropTarget {
3974 public:
3975 wxPyFileDropTarget() {}
3976
3977 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3978
3979 DEC_PYCALLBACK__(OnLeave);
3980 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3981 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3982 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3983 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3984
3985 PYPRIVATE;
3986 };
3987
3988 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3989 const wxArrayString& filenames) {
3990 bool rval = false;
3991 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3992 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3993 PyObject* list = wxArrayString2PyList_helper(filenames);
3994 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3995 Py_DECREF(list);
3996 }
3997 wxPyEndBlockThreads(blocked);
3998 return rval;
3999 }
4000
4001
4002
4003 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4004 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4005 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4006 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4007 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4008
4009
4010
4011
4012 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4013
4014 #include <wx/display.h>
4015 #include <wx/vidmode.h>
4016
4017 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4018 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4019
4020 #if !wxUSE_DISPLAY
4021 const wxVideoMode wxDefaultVideoMode;
4022 #endif
4023
4024 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4025 #if wxUSE_DISPLAY
4026 PyObject* pyList = NULL;
4027 wxArrayVideoModes arr = self->GetModes(mode);
4028 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4029 pyList = PyList_New(0);
4030 for (size_t i=0; i < arr.GetCount(); i++)
4031 {
4032 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4033 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4034 PyList_Append(pyList, pyObj);
4035 Py_DECREF(pyObj);
4036 }
4037 wxPyEndBlockThreads(blocked);
4038 return pyList;
4039 #else
4040 wxPyRaiseNotImplemented();
4041 return NULL;
4042 #endif
4043 }
4044 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4045 #if wxUSE_DISPLAY
4046 return self->GetCurrentMode();
4047 #else
4048 wxPyRaiseNotImplemented();
4049 return wxDefaultVideoMode;
4050 #endif
4051 }
4052 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4053 #if wxUSE_DISPLAY
4054 return self->ChangeMode(mode);
4055 #else
4056 wxPyRaiseNotImplemented();
4057 return false;
4058 #endif
4059 }
4060 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4061 #if wxUSE_DISPLAY
4062 self->ResetMode();
4063 #else
4064 wxPyRaiseNotImplemented();
4065 #endif
4066 }
4067
4068 #include <wx/stdpaths.h>
4069
4070 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4071 return (wxStandardPaths*) &wxStandardPaths::Get();
4072 }
4073 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4074 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
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 wxWindow *arg2 = (wxWindow *) NULL ;
9193 wxBusyInfo *result = 0 ;
9194 bool temp1 = false ;
9195 void *argp2 = 0 ;
9196 int res2 = 0 ;
9197 PyObject * obj0 = 0 ;
9198 PyObject * obj1 = 0 ;
9199 char * kwnames[] = {
9200 (char *) "message",(char *) "parent", NULL
9201 };
9202
9203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BusyInfo",kwnames,&obj0,&obj1)) SWIG_fail;
9204 {
9205 arg1 = wxString_in_helper(obj0);
9206 if (arg1 == NULL) SWIG_fail;
9207 temp1 = true;
9208 }
9209 if (obj1) {
9210 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
9211 if (!SWIG_IsOK(res2)) {
9212 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BusyInfo" "', expected argument " "2"" of type '" "wxWindow *""'");
9213 }
9214 arg2 = reinterpret_cast< wxWindow * >(argp2);
9215 }
9216 {
9217 if (!wxPyCheckForApp()) SWIG_fail;
9218 PyThreadState* __tstate = wxPyBeginAllowThreads();
9219 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1,arg2);
9220 wxPyEndAllowThreads(__tstate);
9221 if (PyErr_Occurred()) SWIG_fail;
9222 }
9223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9224 {
9225 if (temp1)
9226 delete arg1;
9227 }
9228 return resultobj;
9229 fail:
9230 {
9231 if (temp1)
9232 delete arg1;
9233 }
9234 return NULL;
9235 }
9236
9237
9238 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9239 PyObject *resultobj = 0;
9240 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9241 void *argp1 = 0 ;
9242 int res1 = 0 ;
9243 PyObject *swig_obj[1] ;
9244
9245 if (!args) SWIG_fail;
9246 swig_obj[0] = args;
9247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9248 if (!SWIG_IsOK(res1)) {
9249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9250 }
9251 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9252 {
9253 PyThreadState* __tstate = wxPyBeginAllowThreads();
9254 delete arg1;
9255
9256 wxPyEndAllowThreads(__tstate);
9257 if (PyErr_Occurred()) SWIG_fail;
9258 }
9259 resultobj = SWIG_Py_Void();
9260 return resultobj;
9261 fail:
9262 return NULL;
9263 }
9264
9265
9266 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9267 PyObject *obj;
9268 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9269 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9270 return SWIG_Py_Void();
9271 }
9272
9273 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9274 return SWIG_Python_InitShadowInstance(args);
9275 }
9276
9277 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9278 PyObject *resultobj = 0;
9279 wxStopWatch *result = 0 ;
9280
9281 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9282 {
9283 PyThreadState* __tstate = wxPyBeginAllowThreads();
9284 result = (wxStopWatch *)new wxStopWatch();
9285 wxPyEndAllowThreads(__tstate);
9286 if (PyErr_Occurred()) SWIG_fail;
9287 }
9288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9289 return resultobj;
9290 fail:
9291 return NULL;
9292 }
9293
9294
9295 SWIGINTERN PyObject *_wrap_delete_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9296 PyObject *resultobj = 0;
9297 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9298 void *argp1 = 0 ;
9299 int res1 = 0 ;
9300 PyObject *swig_obj[1] ;
9301
9302 if (!args) SWIG_fail;
9303 swig_obj[0] = args;
9304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, SWIG_POINTER_DISOWN | 0 );
9305 if (!SWIG_IsOK(res1)) {
9306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StopWatch" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9307 }
9308 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9309 {
9310 PyThreadState* __tstate = wxPyBeginAllowThreads();
9311 delete arg1;
9312
9313 wxPyEndAllowThreads(__tstate);
9314 if (PyErr_Occurred()) SWIG_fail;
9315 }
9316 resultobj = SWIG_Py_Void();
9317 return resultobj;
9318 fail:
9319 return NULL;
9320 }
9321
9322
9323 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9324 PyObject *resultobj = 0;
9325 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9326 long arg2 = (long) 0 ;
9327 void *argp1 = 0 ;
9328 int res1 = 0 ;
9329 long val2 ;
9330 int ecode2 = 0 ;
9331 PyObject * obj0 = 0 ;
9332 PyObject * obj1 = 0 ;
9333 char * kwnames[] = {
9334 (char *) "self",(char *) "t0", NULL
9335 };
9336
9337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9339 if (!SWIG_IsOK(res1)) {
9340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9341 }
9342 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9343 if (obj1) {
9344 ecode2 = SWIG_AsVal_long(obj1, &val2);
9345 if (!SWIG_IsOK(ecode2)) {
9346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9347 }
9348 arg2 = static_cast< long >(val2);
9349 }
9350 {
9351 PyThreadState* __tstate = wxPyBeginAllowThreads();
9352 (arg1)->Start(arg2);
9353 wxPyEndAllowThreads(__tstate);
9354 if (PyErr_Occurred()) SWIG_fail;
9355 }
9356 resultobj = SWIG_Py_Void();
9357 return resultobj;
9358 fail:
9359 return NULL;
9360 }
9361
9362
9363 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9364 PyObject *resultobj = 0;
9365 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9366 void *argp1 = 0 ;
9367 int res1 = 0 ;
9368 PyObject *swig_obj[1] ;
9369
9370 if (!args) SWIG_fail;
9371 swig_obj[0] = args;
9372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9373 if (!SWIG_IsOK(res1)) {
9374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9375 }
9376 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9377 {
9378 PyThreadState* __tstate = wxPyBeginAllowThreads();
9379 (arg1)->Pause();
9380 wxPyEndAllowThreads(__tstate);
9381 if (PyErr_Occurred()) SWIG_fail;
9382 }
9383 resultobj = SWIG_Py_Void();
9384 return resultobj;
9385 fail:
9386 return NULL;
9387 }
9388
9389
9390 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9391 PyObject *resultobj = 0;
9392 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9393 void *argp1 = 0 ;
9394 int res1 = 0 ;
9395 PyObject *swig_obj[1] ;
9396
9397 if (!args) SWIG_fail;
9398 swig_obj[0] = args;
9399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9400 if (!SWIG_IsOK(res1)) {
9401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9402 }
9403 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9404 {
9405 PyThreadState* __tstate = wxPyBeginAllowThreads();
9406 (arg1)->Resume();
9407 wxPyEndAllowThreads(__tstate);
9408 if (PyErr_Occurred()) SWIG_fail;
9409 }
9410 resultobj = SWIG_Py_Void();
9411 return resultobj;
9412 fail:
9413 return NULL;
9414 }
9415
9416
9417 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9418 PyObject *resultobj = 0;
9419 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9420 long result;
9421 void *argp1 = 0 ;
9422 int res1 = 0 ;
9423 PyObject *swig_obj[1] ;
9424
9425 if (!args) SWIG_fail;
9426 swig_obj[0] = args;
9427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9428 if (!SWIG_IsOK(res1)) {
9429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9430 }
9431 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9432 {
9433 PyThreadState* __tstate = wxPyBeginAllowThreads();
9434 result = (long)((wxStopWatch const *)arg1)->Time();
9435 wxPyEndAllowThreads(__tstate);
9436 if (PyErr_Occurred()) SWIG_fail;
9437 }
9438 resultobj = SWIG_From_long(static_cast< long >(result));
9439 return resultobj;
9440 fail:
9441 return NULL;
9442 }
9443
9444
9445 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9446 PyObject *obj;
9447 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9448 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9449 return SWIG_Py_Void();
9450 }
9451
9452 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9453 return SWIG_Python_InitShadowInstance(args);
9454 }
9455
9456 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9457 PyObject *resultobj = 0;
9458 int arg1 = (int) 9 ;
9459 int arg2 = (int) wxID_FILE1 ;
9460 wxFileHistory *result = 0 ;
9461 int val1 ;
9462 int ecode1 = 0 ;
9463 int val2 ;
9464 int ecode2 = 0 ;
9465 PyObject * obj0 = 0 ;
9466 PyObject * obj1 = 0 ;
9467 char * kwnames[] = {
9468 (char *) "maxFiles",(char *) "idBase", NULL
9469 };
9470
9471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9472 if (obj0) {
9473 ecode1 = SWIG_AsVal_int(obj0, &val1);
9474 if (!SWIG_IsOK(ecode1)) {
9475 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9476 }
9477 arg1 = static_cast< int >(val1);
9478 }
9479 if (obj1) {
9480 ecode2 = SWIG_AsVal_int(obj1, &val2);
9481 if (!SWIG_IsOK(ecode2)) {
9482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9483 }
9484 arg2 = static_cast< int >(val2);
9485 }
9486 {
9487 PyThreadState* __tstate = wxPyBeginAllowThreads();
9488 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9489 wxPyEndAllowThreads(__tstate);
9490 if (PyErr_Occurred()) SWIG_fail;
9491 }
9492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9493 return resultobj;
9494 fail:
9495 return NULL;
9496 }
9497
9498
9499 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9500 PyObject *resultobj = 0;
9501 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9502 void *argp1 = 0 ;
9503 int res1 = 0 ;
9504 PyObject *swig_obj[1] ;
9505
9506 if (!args) SWIG_fail;
9507 swig_obj[0] = args;
9508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9509 if (!SWIG_IsOK(res1)) {
9510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9511 }
9512 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9513 {
9514 PyThreadState* __tstate = wxPyBeginAllowThreads();
9515 delete arg1;
9516
9517 wxPyEndAllowThreads(__tstate);
9518 if (PyErr_Occurred()) SWIG_fail;
9519 }
9520 resultobj = SWIG_Py_Void();
9521 return resultobj;
9522 fail:
9523 return NULL;
9524 }
9525
9526
9527 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9528 PyObject *resultobj = 0;
9529 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9530 wxString *arg2 = 0 ;
9531 void *argp1 = 0 ;
9532 int res1 = 0 ;
9533 bool temp2 = false ;
9534 PyObject * obj0 = 0 ;
9535 PyObject * obj1 = 0 ;
9536 char * kwnames[] = {
9537 (char *) "self",(char *) "file", NULL
9538 };
9539
9540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9542 if (!SWIG_IsOK(res1)) {
9543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9544 }
9545 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9546 {
9547 arg2 = wxString_in_helper(obj1);
9548 if (arg2 == NULL) SWIG_fail;
9549 temp2 = true;
9550 }
9551 {
9552 PyThreadState* __tstate = wxPyBeginAllowThreads();
9553 (arg1)->AddFileToHistory((wxString const &)*arg2);
9554 wxPyEndAllowThreads(__tstate);
9555 if (PyErr_Occurred()) SWIG_fail;
9556 }
9557 resultobj = SWIG_Py_Void();
9558 {
9559 if (temp2)
9560 delete arg2;
9561 }
9562 return resultobj;
9563 fail:
9564 {
9565 if (temp2)
9566 delete arg2;
9567 }
9568 return NULL;
9569 }
9570
9571
9572 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9573 PyObject *resultobj = 0;
9574 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9575 int arg2 ;
9576 void *argp1 = 0 ;
9577 int res1 = 0 ;
9578 int val2 ;
9579 int ecode2 = 0 ;
9580 PyObject * obj0 = 0 ;
9581 PyObject * obj1 = 0 ;
9582 char * kwnames[] = {
9583 (char *) "self",(char *) "i", NULL
9584 };
9585
9586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9588 if (!SWIG_IsOK(res1)) {
9589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9590 }
9591 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9592 ecode2 = SWIG_AsVal_int(obj1, &val2);
9593 if (!SWIG_IsOK(ecode2)) {
9594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9595 }
9596 arg2 = static_cast< int >(val2);
9597 {
9598 PyThreadState* __tstate = wxPyBeginAllowThreads();
9599 (arg1)->RemoveFileFromHistory(arg2);
9600 wxPyEndAllowThreads(__tstate);
9601 if (PyErr_Occurred()) SWIG_fail;
9602 }
9603 resultobj = SWIG_Py_Void();
9604 return resultobj;
9605 fail:
9606 return NULL;
9607 }
9608
9609
9610 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9611 PyObject *resultobj = 0;
9612 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9613 int result;
9614 void *argp1 = 0 ;
9615 int res1 = 0 ;
9616 PyObject *swig_obj[1] ;
9617
9618 if (!args) SWIG_fail;
9619 swig_obj[0] = args;
9620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9621 if (!SWIG_IsOK(res1)) {
9622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9623 }
9624 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9625 {
9626 PyThreadState* __tstate = wxPyBeginAllowThreads();
9627 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9628 wxPyEndAllowThreads(__tstate);
9629 if (PyErr_Occurred()) SWIG_fail;
9630 }
9631 resultobj = SWIG_From_int(static_cast< int >(result));
9632 return resultobj;
9633 fail:
9634 return NULL;
9635 }
9636
9637
9638 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9639 PyObject *resultobj = 0;
9640 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9641 wxMenu *arg2 = (wxMenu *) 0 ;
9642 void *argp1 = 0 ;
9643 int res1 = 0 ;
9644 void *argp2 = 0 ;
9645 int res2 = 0 ;
9646 PyObject * obj0 = 0 ;
9647 PyObject * obj1 = 0 ;
9648 char * kwnames[] = {
9649 (char *) "self",(char *) "menu", NULL
9650 };
9651
9652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9654 if (!SWIG_IsOK(res1)) {
9655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9656 }
9657 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9658 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9659 if (!SWIG_IsOK(res2)) {
9660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9661 }
9662 arg2 = reinterpret_cast< wxMenu * >(argp2);
9663 {
9664 PyThreadState* __tstate = wxPyBeginAllowThreads();
9665 (arg1)->UseMenu(arg2);
9666 wxPyEndAllowThreads(__tstate);
9667 if (PyErr_Occurred()) SWIG_fail;
9668 }
9669 resultobj = SWIG_Py_Void();
9670 return resultobj;
9671 fail:
9672 return NULL;
9673 }
9674
9675
9676 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9677 PyObject *resultobj = 0;
9678 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9679 wxMenu *arg2 = (wxMenu *) 0 ;
9680 void *argp1 = 0 ;
9681 int res1 = 0 ;
9682 void *argp2 = 0 ;
9683 int res2 = 0 ;
9684 PyObject * obj0 = 0 ;
9685 PyObject * obj1 = 0 ;
9686 char * kwnames[] = {
9687 (char *) "self",(char *) "menu", NULL
9688 };
9689
9690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9692 if (!SWIG_IsOK(res1)) {
9693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9694 }
9695 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9696 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9697 if (!SWIG_IsOK(res2)) {
9698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9699 }
9700 arg2 = reinterpret_cast< wxMenu * >(argp2);
9701 {
9702 PyThreadState* __tstate = wxPyBeginAllowThreads();
9703 (arg1)->RemoveMenu(arg2);
9704 wxPyEndAllowThreads(__tstate);
9705 if (PyErr_Occurred()) SWIG_fail;
9706 }
9707 resultobj = SWIG_Py_Void();
9708 return resultobj;
9709 fail:
9710 return NULL;
9711 }
9712
9713
9714 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9715 PyObject *resultobj = 0;
9716 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9717 wxConfigBase *arg2 = 0 ;
9718 void *argp1 = 0 ;
9719 int res1 = 0 ;
9720 void *argp2 = 0 ;
9721 int res2 = 0 ;
9722 PyObject * obj0 = 0 ;
9723 PyObject * obj1 = 0 ;
9724 char * kwnames[] = {
9725 (char *) "self",(char *) "config", NULL
9726 };
9727
9728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9730 if (!SWIG_IsOK(res1)) {
9731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9732 }
9733 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9734 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9735 if (!SWIG_IsOK(res2)) {
9736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9737 }
9738 if (!argp2) {
9739 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9740 }
9741 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9742 {
9743 PyThreadState* __tstate = wxPyBeginAllowThreads();
9744 (arg1)->Load(*arg2);
9745 wxPyEndAllowThreads(__tstate);
9746 if (PyErr_Occurred()) SWIG_fail;
9747 }
9748 resultobj = SWIG_Py_Void();
9749 return resultobj;
9750 fail:
9751 return NULL;
9752 }
9753
9754
9755 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9756 PyObject *resultobj = 0;
9757 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9758 wxConfigBase *arg2 = 0 ;
9759 void *argp1 = 0 ;
9760 int res1 = 0 ;
9761 void *argp2 = 0 ;
9762 int res2 = 0 ;
9763 PyObject * obj0 = 0 ;
9764 PyObject * obj1 = 0 ;
9765 char * kwnames[] = {
9766 (char *) "self",(char *) "config", NULL
9767 };
9768
9769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9771 if (!SWIG_IsOK(res1)) {
9772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9773 }
9774 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9775 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9776 if (!SWIG_IsOK(res2)) {
9777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9778 }
9779 if (!argp2) {
9780 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9781 }
9782 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9783 {
9784 PyThreadState* __tstate = wxPyBeginAllowThreads();
9785 (arg1)->Save(*arg2);
9786 wxPyEndAllowThreads(__tstate);
9787 if (PyErr_Occurred()) SWIG_fail;
9788 }
9789 resultobj = SWIG_Py_Void();
9790 return resultobj;
9791 fail:
9792 return NULL;
9793 }
9794
9795
9796 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9797 PyObject *resultobj = 0;
9798 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9799 void *argp1 = 0 ;
9800 int res1 = 0 ;
9801 PyObject *swig_obj[1] ;
9802
9803 if (!args) SWIG_fail;
9804 swig_obj[0] = args;
9805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9806 if (!SWIG_IsOK(res1)) {
9807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9808 }
9809 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9810 {
9811 PyThreadState* __tstate = wxPyBeginAllowThreads();
9812 (arg1)->AddFilesToMenu();
9813 wxPyEndAllowThreads(__tstate);
9814 if (PyErr_Occurred()) SWIG_fail;
9815 }
9816 resultobj = SWIG_Py_Void();
9817 return resultobj;
9818 fail:
9819 return NULL;
9820 }
9821
9822
9823 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9824 PyObject *resultobj = 0;
9825 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9826 wxMenu *arg2 = (wxMenu *) 0 ;
9827 void *argp1 = 0 ;
9828 int res1 = 0 ;
9829 void *argp2 = 0 ;
9830 int res2 = 0 ;
9831 PyObject * obj0 = 0 ;
9832 PyObject * obj1 = 0 ;
9833 char * kwnames[] = {
9834 (char *) "self",(char *) "menu", NULL
9835 };
9836
9837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9839 if (!SWIG_IsOK(res1)) {
9840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9841 }
9842 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9843 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9844 if (!SWIG_IsOK(res2)) {
9845 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9846 }
9847 arg2 = reinterpret_cast< wxMenu * >(argp2);
9848 {
9849 PyThreadState* __tstate = wxPyBeginAllowThreads();
9850 (arg1)->AddFilesToMenu(arg2);
9851 wxPyEndAllowThreads(__tstate);
9852 if (PyErr_Occurred()) SWIG_fail;
9853 }
9854 resultobj = SWIG_Py_Void();
9855 return resultobj;
9856 fail:
9857 return NULL;
9858 }
9859
9860
9861 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9862 PyObject *resultobj = 0;
9863 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9864 int arg2 ;
9865 wxString result;
9866 void *argp1 = 0 ;
9867 int res1 = 0 ;
9868 int val2 ;
9869 int ecode2 = 0 ;
9870 PyObject * obj0 = 0 ;
9871 PyObject * obj1 = 0 ;
9872 char * kwnames[] = {
9873 (char *) "self",(char *) "i", NULL
9874 };
9875
9876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9878 if (!SWIG_IsOK(res1)) {
9879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9880 }
9881 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9882 ecode2 = SWIG_AsVal_int(obj1, &val2);
9883 if (!SWIG_IsOK(ecode2)) {
9884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9885 }
9886 arg2 = static_cast< int >(val2);
9887 {
9888 PyThreadState* __tstate = wxPyBeginAllowThreads();
9889 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9890 wxPyEndAllowThreads(__tstate);
9891 if (PyErr_Occurred()) SWIG_fail;
9892 }
9893 {
9894 #if wxUSE_UNICODE
9895 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9896 #else
9897 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9898 #endif
9899 }
9900 return resultobj;
9901 fail:
9902 return NULL;
9903 }
9904
9905
9906 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9907 PyObject *resultobj = 0;
9908 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9909 int result;
9910 void *argp1 = 0 ;
9911 int res1 = 0 ;
9912 PyObject *swig_obj[1] ;
9913
9914 if (!args) SWIG_fail;
9915 swig_obj[0] = args;
9916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9917 if (!SWIG_IsOK(res1)) {
9918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9919 }
9920 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9921 {
9922 PyThreadState* __tstate = wxPyBeginAllowThreads();
9923 result = (int)((wxFileHistory const *)arg1)->GetCount();
9924 wxPyEndAllowThreads(__tstate);
9925 if (PyErr_Occurred()) SWIG_fail;
9926 }
9927 resultobj = SWIG_From_int(static_cast< int >(result));
9928 return resultobj;
9929 fail:
9930 return NULL;
9931 }
9932
9933
9934 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9935 PyObject *obj;
9936 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9937 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9938 return SWIG_Py_Void();
9939 }
9940
9941 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9942 return SWIG_Python_InitShadowInstance(args);
9943 }
9944
9945 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9946 PyObject *resultobj = 0;
9947 wxString *arg1 = 0 ;
9948 wxString const &arg2_defvalue = wxPyEmptyString ;
9949 wxString *arg2 = (wxString *) &arg2_defvalue ;
9950 wxSingleInstanceChecker *result = 0 ;
9951 bool temp1 = false ;
9952 bool temp2 = false ;
9953 PyObject * obj0 = 0 ;
9954 PyObject * obj1 = 0 ;
9955 char * kwnames[] = {
9956 (char *) "name",(char *) "path", NULL
9957 };
9958
9959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9960 {
9961 arg1 = wxString_in_helper(obj0);
9962 if (arg1 == NULL) SWIG_fail;
9963 temp1 = true;
9964 }
9965 if (obj1) {
9966 {
9967 arg2 = wxString_in_helper(obj1);
9968 if (arg2 == NULL) SWIG_fail;
9969 temp2 = true;
9970 }
9971 }
9972 {
9973 PyThreadState* __tstate = wxPyBeginAllowThreads();
9974 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9975 wxPyEndAllowThreads(__tstate);
9976 if (PyErr_Occurred()) SWIG_fail;
9977 }
9978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9979 {
9980 if (temp1)
9981 delete arg1;
9982 }
9983 {
9984 if (temp2)
9985 delete arg2;
9986 }
9987 return resultobj;
9988 fail:
9989 {
9990 if (temp1)
9991 delete arg1;
9992 }
9993 {
9994 if (temp2)
9995 delete arg2;
9996 }
9997 return NULL;
9998 }
9999
10000
10001 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10002 PyObject *resultobj = 0;
10003 wxSingleInstanceChecker *result = 0 ;
10004
10005 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
10006 {
10007 PyThreadState* __tstate = wxPyBeginAllowThreads();
10008 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
10009 wxPyEndAllowThreads(__tstate);
10010 if (PyErr_Occurred()) SWIG_fail;
10011 }
10012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
10013 return resultobj;
10014 fail:
10015 return NULL;
10016 }
10017
10018
10019 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10020 PyObject *resultobj = 0;
10021 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10022 void *argp1 = 0 ;
10023 int res1 = 0 ;
10024 PyObject *swig_obj[1] ;
10025
10026 if (!args) SWIG_fail;
10027 swig_obj[0] = args;
10028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
10029 if (!SWIG_IsOK(res1)) {
10030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10031 }
10032 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10033 {
10034 PyThreadState* __tstate = wxPyBeginAllowThreads();
10035 delete arg1;
10036
10037 wxPyEndAllowThreads(__tstate);
10038 if (PyErr_Occurred()) SWIG_fail;
10039 }
10040 resultobj = SWIG_Py_Void();
10041 return resultobj;
10042 fail:
10043 return NULL;
10044 }
10045
10046
10047 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10048 PyObject *resultobj = 0;
10049 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10050 wxString *arg2 = 0 ;
10051 wxString const &arg3_defvalue = wxPyEmptyString ;
10052 wxString *arg3 = (wxString *) &arg3_defvalue ;
10053 bool result;
10054 void *argp1 = 0 ;
10055 int res1 = 0 ;
10056 bool temp2 = false ;
10057 bool temp3 = false ;
10058 PyObject * obj0 = 0 ;
10059 PyObject * obj1 = 0 ;
10060 PyObject * obj2 = 0 ;
10061 char * kwnames[] = {
10062 (char *) "self",(char *) "name",(char *) "path", NULL
10063 };
10064
10065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10067 if (!SWIG_IsOK(res1)) {
10068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10069 }
10070 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10071 {
10072 arg2 = wxString_in_helper(obj1);
10073 if (arg2 == NULL) SWIG_fail;
10074 temp2 = true;
10075 }
10076 if (obj2) {
10077 {
10078 arg3 = wxString_in_helper(obj2);
10079 if (arg3 == NULL) SWIG_fail;
10080 temp3 = true;
10081 }
10082 }
10083 {
10084 PyThreadState* __tstate = wxPyBeginAllowThreads();
10085 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10086 wxPyEndAllowThreads(__tstate);
10087 if (PyErr_Occurred()) SWIG_fail;
10088 }
10089 {
10090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10091 }
10092 {
10093 if (temp2)
10094 delete arg2;
10095 }
10096 {
10097 if (temp3)
10098 delete arg3;
10099 }
10100 return resultobj;
10101 fail:
10102 {
10103 if (temp2)
10104 delete arg2;
10105 }
10106 {
10107 if (temp3)
10108 delete arg3;
10109 }
10110 return NULL;
10111 }
10112
10113
10114 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10115 PyObject *resultobj = 0;
10116 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10117 bool result;
10118 void *argp1 = 0 ;
10119 int res1 = 0 ;
10120 PyObject *swig_obj[1] ;
10121
10122 if (!args) SWIG_fail;
10123 swig_obj[0] = args;
10124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10125 if (!SWIG_IsOK(res1)) {
10126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10127 }
10128 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10129 {
10130 PyThreadState* __tstate = wxPyBeginAllowThreads();
10131 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10132 wxPyEndAllowThreads(__tstate);
10133 if (PyErr_Occurred()) SWIG_fail;
10134 }
10135 {
10136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10137 }
10138 return resultobj;
10139 fail:
10140 return NULL;
10141 }
10142
10143
10144 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10145 PyObject *obj;
10146 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10147 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10148 return SWIG_Py_Void();
10149 }
10150
10151 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10152 return SWIG_Python_InitShadowInstance(args);
10153 }
10154
10155 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10156 PyObject *resultobj = 0;
10157 wxPlatformInfo *result = 0 ;
10158
10159 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10160 {
10161 PyThreadState* __tstate = wxPyBeginAllowThreads();
10162 result = (wxPlatformInfo *)new wxPlatformInfo();
10163 wxPyEndAllowThreads(__tstate);
10164 if (PyErr_Occurred()) SWIG_fail;
10165 }
10166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10167 return resultobj;
10168 fail:
10169 return NULL;
10170 }
10171
10172
10173 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10174 PyObject *resultobj = 0;
10175 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10176 wxPlatformInfo *arg2 = 0 ;
10177 bool result;
10178 void *argp1 = 0 ;
10179 int res1 = 0 ;
10180 void *argp2 = 0 ;
10181 int res2 = 0 ;
10182 PyObject * obj0 = 0 ;
10183 PyObject * obj1 = 0 ;
10184 char * kwnames[] = {
10185 (char *) "self",(char *) "t", NULL
10186 };
10187
10188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10190 if (!SWIG_IsOK(res1)) {
10191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10192 }
10193 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10194 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10195 if (!SWIG_IsOK(res2)) {
10196 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10197 }
10198 if (!argp2) {
10199 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10200 }
10201 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10202 {
10203 PyThreadState* __tstate = wxPyBeginAllowThreads();
10204 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10205 wxPyEndAllowThreads(__tstate);
10206 if (PyErr_Occurred()) SWIG_fail;
10207 }
10208 {
10209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10210 }
10211 return resultobj;
10212 fail:
10213 return NULL;
10214 }
10215
10216
10217 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10218 PyObject *resultobj = 0;
10219 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10220 wxPlatformInfo *arg2 = 0 ;
10221 bool result;
10222 void *argp1 = 0 ;
10223 int res1 = 0 ;
10224 void *argp2 = 0 ;
10225 int res2 = 0 ;
10226 PyObject * obj0 = 0 ;
10227 PyObject * obj1 = 0 ;
10228 char * kwnames[] = {
10229 (char *) "self",(char *) "t", NULL
10230 };
10231
10232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10234 if (!SWIG_IsOK(res1)) {
10235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10236 }
10237 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10238 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10239 if (!SWIG_IsOK(res2)) {
10240 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10241 }
10242 if (!argp2) {
10243 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10244 }
10245 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10246 {
10247 PyThreadState* __tstate = wxPyBeginAllowThreads();
10248 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10249 wxPyEndAllowThreads(__tstate);
10250 if (PyErr_Occurred()) SWIG_fail;
10251 }
10252 {
10253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10254 }
10255 return resultobj;
10256 fail:
10257 return NULL;
10258 }
10259
10260
10261 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10262 PyObject *resultobj = 0;
10263 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10264 int result;
10265 void *argp1 = 0 ;
10266 int res1 = 0 ;
10267 PyObject *swig_obj[1] ;
10268
10269 if (!args) SWIG_fail;
10270 swig_obj[0] = args;
10271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10272 if (!SWIG_IsOK(res1)) {
10273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10274 }
10275 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10276 {
10277 PyThreadState* __tstate = wxPyBeginAllowThreads();
10278 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10279 wxPyEndAllowThreads(__tstate);
10280 if (PyErr_Occurred()) SWIG_fail;
10281 }
10282 resultobj = SWIG_From_int(static_cast< int >(result));
10283 return resultobj;
10284 fail:
10285 return NULL;
10286 }
10287
10288
10289 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10290 PyObject *resultobj = 0;
10291 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10292 int result;
10293 void *argp1 = 0 ;
10294 int res1 = 0 ;
10295 PyObject *swig_obj[1] ;
10296
10297 if (!args) SWIG_fail;
10298 swig_obj[0] = args;
10299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10300 if (!SWIG_IsOK(res1)) {
10301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10302 }
10303 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10304 {
10305 PyThreadState* __tstate = wxPyBeginAllowThreads();
10306 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10307 wxPyEndAllowThreads(__tstate);
10308 if (PyErr_Occurred()) SWIG_fail;
10309 }
10310 resultobj = SWIG_From_int(static_cast< int >(result));
10311 return resultobj;
10312 fail:
10313 return NULL;
10314 }
10315
10316
10317 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10318 PyObject *resultobj = 0;
10319 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10320 int arg2 ;
10321 int arg3 ;
10322 bool result;
10323 void *argp1 = 0 ;
10324 int res1 = 0 ;
10325 int val2 ;
10326 int ecode2 = 0 ;
10327 int val3 ;
10328 int ecode3 = 0 ;
10329 PyObject * obj0 = 0 ;
10330 PyObject * obj1 = 0 ;
10331 PyObject * obj2 = 0 ;
10332 char * kwnames[] = {
10333 (char *) "self",(char *) "major",(char *) "minor", NULL
10334 };
10335
10336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10338 if (!SWIG_IsOK(res1)) {
10339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10340 }
10341 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10342 ecode2 = SWIG_AsVal_int(obj1, &val2);
10343 if (!SWIG_IsOK(ecode2)) {
10344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10345 }
10346 arg2 = static_cast< int >(val2);
10347 ecode3 = SWIG_AsVal_int(obj2, &val3);
10348 if (!SWIG_IsOK(ecode3)) {
10349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10350 }
10351 arg3 = static_cast< int >(val3);
10352 {
10353 PyThreadState* __tstate = wxPyBeginAllowThreads();
10354 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10355 wxPyEndAllowThreads(__tstate);
10356 if (PyErr_Occurred()) SWIG_fail;
10357 }
10358 {
10359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10360 }
10361 return resultobj;
10362 fail:
10363 return NULL;
10364 }
10365
10366
10367 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10368 PyObject *resultobj = 0;
10369 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10370 int result;
10371 void *argp1 = 0 ;
10372 int res1 = 0 ;
10373 PyObject *swig_obj[1] ;
10374
10375 if (!args) SWIG_fail;
10376 swig_obj[0] = args;
10377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10378 if (!SWIG_IsOK(res1)) {
10379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10380 }
10381 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10382 {
10383 PyThreadState* __tstate = wxPyBeginAllowThreads();
10384 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10385 wxPyEndAllowThreads(__tstate);
10386 if (PyErr_Occurred()) SWIG_fail;
10387 }
10388 resultobj = SWIG_From_int(static_cast< int >(result));
10389 return resultobj;
10390 fail:
10391 return NULL;
10392 }
10393
10394
10395 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10396 PyObject *resultobj = 0;
10397 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10398 int result;
10399 void *argp1 = 0 ;
10400 int res1 = 0 ;
10401 PyObject *swig_obj[1] ;
10402
10403 if (!args) SWIG_fail;
10404 swig_obj[0] = args;
10405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10406 if (!SWIG_IsOK(res1)) {
10407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10408 }
10409 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10410 {
10411 PyThreadState* __tstate = wxPyBeginAllowThreads();
10412 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10413 wxPyEndAllowThreads(__tstate);
10414 if (PyErr_Occurred()) SWIG_fail;
10415 }
10416 resultobj = SWIG_From_int(static_cast< int >(result));
10417 return resultobj;
10418 fail:
10419 return NULL;
10420 }
10421
10422
10423 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10424 PyObject *resultobj = 0;
10425 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10426 int arg2 ;
10427 int arg3 ;
10428 bool result;
10429 void *argp1 = 0 ;
10430 int res1 = 0 ;
10431 int val2 ;
10432 int ecode2 = 0 ;
10433 int val3 ;
10434 int ecode3 = 0 ;
10435 PyObject * obj0 = 0 ;
10436 PyObject * obj1 = 0 ;
10437 PyObject * obj2 = 0 ;
10438 char * kwnames[] = {
10439 (char *) "self",(char *) "major",(char *) "minor", NULL
10440 };
10441
10442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10444 if (!SWIG_IsOK(res1)) {
10445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10446 }
10447 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10448 ecode2 = SWIG_AsVal_int(obj1, &val2);
10449 if (!SWIG_IsOK(ecode2)) {
10450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10451 }
10452 arg2 = static_cast< int >(val2);
10453 ecode3 = SWIG_AsVal_int(obj2, &val3);
10454 if (!SWIG_IsOK(ecode3)) {
10455 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10456 }
10457 arg3 = static_cast< int >(val3);
10458 {
10459 PyThreadState* __tstate = wxPyBeginAllowThreads();
10460 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10461 wxPyEndAllowThreads(__tstate);
10462 if (PyErr_Occurred()) SWIG_fail;
10463 }
10464 {
10465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10466 }
10467 return resultobj;
10468 fail:
10469 return NULL;
10470 }
10471
10472
10473 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10474 PyObject *resultobj = 0;
10475 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10476 bool result;
10477 void *argp1 = 0 ;
10478 int res1 = 0 ;
10479 PyObject *swig_obj[1] ;
10480
10481 if (!args) SWIG_fail;
10482 swig_obj[0] = args;
10483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10484 if (!SWIG_IsOK(res1)) {
10485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10486 }
10487 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10488 {
10489 PyThreadState* __tstate = wxPyBeginAllowThreads();
10490 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10491 wxPyEndAllowThreads(__tstate);
10492 if (PyErr_Occurred()) SWIG_fail;
10493 }
10494 {
10495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10496 }
10497 return resultobj;
10498 fail:
10499 return NULL;
10500 }
10501
10502
10503 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10504 PyObject *resultobj = 0;
10505 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10506 wxOperatingSystemId result;
10507 void *argp1 = 0 ;
10508 int res1 = 0 ;
10509 PyObject *swig_obj[1] ;
10510
10511 if (!args) SWIG_fail;
10512 swig_obj[0] = args;
10513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10514 if (!SWIG_IsOK(res1)) {
10515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10516 }
10517 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10518 {
10519 PyThreadState* __tstate = wxPyBeginAllowThreads();
10520 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10521 wxPyEndAllowThreads(__tstate);
10522 if (PyErr_Occurred()) SWIG_fail;
10523 }
10524 resultobj = SWIG_From_int(static_cast< int >(result));
10525 return resultobj;
10526 fail:
10527 return NULL;
10528 }
10529
10530
10531 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10532 PyObject *resultobj = 0;
10533 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10534 wxPortId result;
10535 void *argp1 = 0 ;
10536 int res1 = 0 ;
10537 PyObject *swig_obj[1] ;
10538
10539 if (!args) SWIG_fail;
10540 swig_obj[0] = args;
10541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10542 if (!SWIG_IsOK(res1)) {
10543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10544 }
10545 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10546 {
10547 PyThreadState* __tstate = wxPyBeginAllowThreads();
10548 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10549 wxPyEndAllowThreads(__tstate);
10550 if (PyErr_Occurred()) SWIG_fail;
10551 }
10552 resultobj = SWIG_From_int(static_cast< int >(result));
10553 return resultobj;
10554 fail:
10555 return NULL;
10556 }
10557
10558
10559 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10560 PyObject *resultobj = 0;
10561 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10562 wxArchitecture result;
10563 void *argp1 = 0 ;
10564 int res1 = 0 ;
10565 PyObject *swig_obj[1] ;
10566
10567 if (!args) SWIG_fail;
10568 swig_obj[0] = args;
10569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10570 if (!SWIG_IsOK(res1)) {
10571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10572 }
10573 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10574 {
10575 PyThreadState* __tstate = wxPyBeginAllowThreads();
10576 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10577 wxPyEndAllowThreads(__tstate);
10578 if (PyErr_Occurred()) SWIG_fail;
10579 }
10580 resultobj = SWIG_From_int(static_cast< int >(result));
10581 return resultobj;
10582 fail:
10583 return NULL;
10584 }
10585
10586
10587 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10588 PyObject *resultobj = 0;
10589 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10590 wxEndianness result;
10591 void *argp1 = 0 ;
10592 int res1 = 0 ;
10593 PyObject *swig_obj[1] ;
10594
10595 if (!args) SWIG_fail;
10596 swig_obj[0] = args;
10597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10598 if (!SWIG_IsOK(res1)) {
10599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10600 }
10601 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10602 {
10603 PyThreadState* __tstate = wxPyBeginAllowThreads();
10604 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10605 wxPyEndAllowThreads(__tstate);
10606 if (PyErr_Occurred()) SWIG_fail;
10607 }
10608 resultobj = SWIG_From_int(static_cast< int >(result));
10609 return resultobj;
10610 fail:
10611 return NULL;
10612 }
10613
10614
10615 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10616 PyObject *resultobj = 0;
10617 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10618 wxString result;
10619 void *argp1 = 0 ;
10620 int res1 = 0 ;
10621 PyObject *swig_obj[1] ;
10622
10623 if (!args) SWIG_fail;
10624 swig_obj[0] = args;
10625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10626 if (!SWIG_IsOK(res1)) {
10627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10628 }
10629 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10630 {
10631 PyThreadState* __tstate = wxPyBeginAllowThreads();
10632 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10633 wxPyEndAllowThreads(__tstate);
10634 if (PyErr_Occurred()) SWIG_fail;
10635 }
10636 {
10637 #if wxUSE_UNICODE
10638 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10639 #else
10640 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10641 #endif
10642 }
10643 return resultobj;
10644 fail:
10645 return NULL;
10646 }
10647
10648
10649 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10650 PyObject *resultobj = 0;
10651 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10652 wxString result;
10653 void *argp1 = 0 ;
10654 int res1 = 0 ;
10655 PyObject *swig_obj[1] ;
10656
10657 if (!args) SWIG_fail;
10658 swig_obj[0] = args;
10659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10660 if (!SWIG_IsOK(res1)) {
10661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10662 }
10663 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10664 {
10665 PyThreadState* __tstate = wxPyBeginAllowThreads();
10666 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10667 wxPyEndAllowThreads(__tstate);
10668 if (PyErr_Occurred()) SWIG_fail;
10669 }
10670 {
10671 #if wxUSE_UNICODE
10672 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10673 #else
10674 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10675 #endif
10676 }
10677 return resultobj;
10678 fail:
10679 return NULL;
10680 }
10681
10682
10683 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10684 PyObject *resultobj = 0;
10685 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10686 wxString result;
10687 void *argp1 = 0 ;
10688 int res1 = 0 ;
10689 PyObject *swig_obj[1] ;
10690
10691 if (!args) SWIG_fail;
10692 swig_obj[0] = args;
10693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10694 if (!SWIG_IsOK(res1)) {
10695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10696 }
10697 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10698 {
10699 PyThreadState* __tstate = wxPyBeginAllowThreads();
10700 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10701 wxPyEndAllowThreads(__tstate);
10702 if (PyErr_Occurred()) SWIG_fail;
10703 }
10704 {
10705 #if wxUSE_UNICODE
10706 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10707 #else
10708 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10709 #endif
10710 }
10711 return resultobj;
10712 fail:
10713 return NULL;
10714 }
10715
10716
10717 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10718 PyObject *resultobj = 0;
10719 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10720 wxString result;
10721 void *argp1 = 0 ;
10722 int res1 = 0 ;
10723 PyObject *swig_obj[1] ;
10724
10725 if (!args) SWIG_fail;
10726 swig_obj[0] = args;
10727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10728 if (!SWIG_IsOK(res1)) {
10729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10730 }
10731 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10732 {
10733 PyThreadState* __tstate = wxPyBeginAllowThreads();
10734 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10735 wxPyEndAllowThreads(__tstate);
10736 if (PyErr_Occurred()) SWIG_fail;
10737 }
10738 {
10739 #if wxUSE_UNICODE
10740 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10741 #else
10742 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10743 #endif
10744 }
10745 return resultobj;
10746 fail:
10747 return NULL;
10748 }
10749
10750
10751 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10752 PyObject *resultobj = 0;
10753 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10754 wxString result;
10755 void *argp1 = 0 ;
10756 int res1 = 0 ;
10757 PyObject *swig_obj[1] ;
10758
10759 if (!args) SWIG_fail;
10760 swig_obj[0] = args;
10761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10762 if (!SWIG_IsOK(res1)) {
10763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10764 }
10765 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10766 {
10767 PyThreadState* __tstate = wxPyBeginAllowThreads();
10768 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10769 wxPyEndAllowThreads(__tstate);
10770 if (PyErr_Occurred()) SWIG_fail;
10771 }
10772 {
10773 #if wxUSE_UNICODE
10774 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10775 #else
10776 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10777 #endif
10778 }
10779 return resultobj;
10780 fail:
10781 return NULL;
10782 }
10783
10784
10785 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10786 PyObject *resultobj = 0;
10787 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10788 wxString result;
10789 void *argp1 = 0 ;
10790 int res1 = 0 ;
10791 PyObject *swig_obj[1] ;
10792
10793 if (!args) SWIG_fail;
10794 swig_obj[0] = args;
10795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10796 if (!SWIG_IsOK(res1)) {
10797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10798 }
10799 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10800 {
10801 PyThreadState* __tstate = wxPyBeginAllowThreads();
10802 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10803 wxPyEndAllowThreads(__tstate);
10804 if (PyErr_Occurred()) SWIG_fail;
10805 }
10806 {
10807 #if wxUSE_UNICODE
10808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10809 #else
10810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10811 #endif
10812 }
10813 return resultobj;
10814 fail:
10815 return NULL;
10816 }
10817
10818
10819 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10820 PyObject *resultobj = 0;
10821 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10822 int arg2 ;
10823 int arg3 ;
10824 void *argp1 = 0 ;
10825 int res1 = 0 ;
10826 int val2 ;
10827 int ecode2 = 0 ;
10828 int val3 ;
10829 int ecode3 = 0 ;
10830 PyObject * obj0 = 0 ;
10831 PyObject * obj1 = 0 ;
10832 PyObject * obj2 = 0 ;
10833 char * kwnames[] = {
10834 (char *) "self",(char *) "major",(char *) "minor", NULL
10835 };
10836
10837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10839 if (!SWIG_IsOK(res1)) {
10840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10841 }
10842 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10843 ecode2 = SWIG_AsVal_int(obj1, &val2);
10844 if (!SWIG_IsOK(ecode2)) {
10845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10846 }
10847 arg2 = static_cast< int >(val2);
10848 ecode3 = SWIG_AsVal_int(obj2, &val3);
10849 if (!SWIG_IsOK(ecode3)) {
10850 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10851 }
10852 arg3 = static_cast< int >(val3);
10853 {
10854 PyThreadState* __tstate = wxPyBeginAllowThreads();
10855 (arg1)->SetOSVersion(arg2,arg3);
10856 wxPyEndAllowThreads(__tstate);
10857 if (PyErr_Occurred()) SWIG_fail;
10858 }
10859 resultobj = SWIG_Py_Void();
10860 return resultobj;
10861 fail:
10862 return NULL;
10863 }
10864
10865
10866 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10867 PyObject *resultobj = 0;
10868 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10869 int arg2 ;
10870 int arg3 ;
10871 void *argp1 = 0 ;
10872 int res1 = 0 ;
10873 int val2 ;
10874 int ecode2 = 0 ;
10875 int val3 ;
10876 int ecode3 = 0 ;
10877 PyObject * obj0 = 0 ;
10878 PyObject * obj1 = 0 ;
10879 PyObject * obj2 = 0 ;
10880 char * kwnames[] = {
10881 (char *) "self",(char *) "major",(char *) "minor", NULL
10882 };
10883
10884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10886 if (!SWIG_IsOK(res1)) {
10887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10888 }
10889 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10890 ecode2 = SWIG_AsVal_int(obj1, &val2);
10891 if (!SWIG_IsOK(ecode2)) {
10892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10893 }
10894 arg2 = static_cast< int >(val2);
10895 ecode3 = SWIG_AsVal_int(obj2, &val3);
10896 if (!SWIG_IsOK(ecode3)) {
10897 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10898 }
10899 arg3 = static_cast< int >(val3);
10900 {
10901 PyThreadState* __tstate = wxPyBeginAllowThreads();
10902 (arg1)->SetToolkitVersion(arg2,arg3);
10903 wxPyEndAllowThreads(__tstate);
10904 if (PyErr_Occurred()) SWIG_fail;
10905 }
10906 resultobj = SWIG_Py_Void();
10907 return resultobj;
10908 fail:
10909 return NULL;
10910 }
10911
10912
10913 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10914 PyObject *resultobj = 0;
10915 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10916 wxOperatingSystemId arg2 ;
10917 void *argp1 = 0 ;
10918 int res1 = 0 ;
10919 int val2 ;
10920 int ecode2 = 0 ;
10921 PyObject * obj0 = 0 ;
10922 PyObject * obj1 = 0 ;
10923 char * kwnames[] = {
10924 (char *) "self",(char *) "n", NULL
10925 };
10926
10927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10929 if (!SWIG_IsOK(res1)) {
10930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10931 }
10932 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10933 ecode2 = SWIG_AsVal_int(obj1, &val2);
10934 if (!SWIG_IsOK(ecode2)) {
10935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10936 }
10937 arg2 = static_cast< wxOperatingSystemId >(val2);
10938 {
10939 PyThreadState* __tstate = wxPyBeginAllowThreads();
10940 (arg1)->SetOperatingSystemId(arg2);
10941 wxPyEndAllowThreads(__tstate);
10942 if (PyErr_Occurred()) SWIG_fail;
10943 }
10944 resultobj = SWIG_Py_Void();
10945 return resultobj;
10946 fail:
10947 return NULL;
10948 }
10949
10950
10951 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10952 PyObject *resultobj = 0;
10953 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10954 wxPortId arg2 ;
10955 void *argp1 = 0 ;
10956 int res1 = 0 ;
10957 int val2 ;
10958 int ecode2 = 0 ;
10959 PyObject * obj0 = 0 ;
10960 PyObject * obj1 = 0 ;
10961 char * kwnames[] = {
10962 (char *) "self",(char *) "n", NULL
10963 };
10964
10965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10967 if (!SWIG_IsOK(res1)) {
10968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10969 }
10970 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10971 ecode2 = SWIG_AsVal_int(obj1, &val2);
10972 if (!SWIG_IsOK(ecode2)) {
10973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10974 }
10975 arg2 = static_cast< wxPortId >(val2);
10976 {
10977 PyThreadState* __tstate = wxPyBeginAllowThreads();
10978 (arg1)->SetPortId(arg2);
10979 wxPyEndAllowThreads(__tstate);
10980 if (PyErr_Occurred()) SWIG_fail;
10981 }
10982 resultobj = SWIG_Py_Void();
10983 return resultobj;
10984 fail:
10985 return NULL;
10986 }
10987
10988
10989 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10990 PyObject *resultobj = 0;
10991 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10992 wxArchitecture arg2 ;
10993 void *argp1 = 0 ;
10994 int res1 = 0 ;
10995 int val2 ;
10996 int ecode2 = 0 ;
10997 PyObject * obj0 = 0 ;
10998 PyObject * obj1 = 0 ;
10999 char * kwnames[] = {
11000 (char *) "self",(char *) "n", NULL
11001 };
11002
11003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
11004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11005 if (!SWIG_IsOK(res1)) {
11006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11007 }
11008 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11009 ecode2 = SWIG_AsVal_int(obj1, &val2);
11010 if (!SWIG_IsOK(ecode2)) {
11011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
11012 }
11013 arg2 = static_cast< wxArchitecture >(val2);
11014 {
11015 PyThreadState* __tstate = wxPyBeginAllowThreads();
11016 (arg1)->SetArchitecture(arg2);
11017 wxPyEndAllowThreads(__tstate);
11018 if (PyErr_Occurred()) SWIG_fail;
11019 }
11020 resultobj = SWIG_Py_Void();
11021 return resultobj;
11022 fail:
11023 return NULL;
11024 }
11025
11026
11027 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11028 PyObject *resultobj = 0;
11029 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11030 wxEndianness arg2 ;
11031 void *argp1 = 0 ;
11032 int res1 = 0 ;
11033 int val2 ;
11034 int ecode2 = 0 ;
11035 PyObject * obj0 = 0 ;
11036 PyObject * obj1 = 0 ;
11037 char * kwnames[] = {
11038 (char *) "self",(char *) "n", NULL
11039 };
11040
11041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
11042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11043 if (!SWIG_IsOK(res1)) {
11044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11045 }
11046 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11047 ecode2 = SWIG_AsVal_int(obj1, &val2);
11048 if (!SWIG_IsOK(ecode2)) {
11049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11050 }
11051 arg2 = static_cast< wxEndianness >(val2);
11052 {
11053 PyThreadState* __tstate = wxPyBeginAllowThreads();
11054 (arg1)->SetEndianness(arg2);
11055 wxPyEndAllowThreads(__tstate);
11056 if (PyErr_Occurred()) SWIG_fail;
11057 }
11058 resultobj = SWIG_Py_Void();
11059 return resultobj;
11060 fail:
11061 return NULL;
11062 }
11063
11064
11065 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11066 PyObject *resultobj = 0;
11067 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11068 bool result;
11069 void *argp1 = 0 ;
11070 int res1 = 0 ;
11071 PyObject *swig_obj[1] ;
11072
11073 if (!args) SWIG_fail;
11074 swig_obj[0] = args;
11075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11076 if (!SWIG_IsOK(res1)) {
11077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11078 }
11079 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11080 {
11081 PyThreadState* __tstate = wxPyBeginAllowThreads();
11082 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11083 wxPyEndAllowThreads(__tstate);
11084 if (PyErr_Occurred()) SWIG_fail;
11085 }
11086 {
11087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11088 }
11089 return resultobj;
11090 fail:
11091 return NULL;
11092 }
11093
11094
11095 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11096 PyObject *obj;
11097 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11098 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11099 return SWIG_Py_Void();
11100 }
11101
11102 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11103 return SWIG_Python_InitShadowInstance(args);
11104 }
11105
11106 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11107 PyObject *resultobj = 0;
11108 wxWindow *arg1 = (wxWindow *) 0 ;
11109 wxDC *arg2 = 0 ;
11110 bool result;
11111 void *argp1 = 0 ;
11112 int res1 = 0 ;
11113 void *argp2 = 0 ;
11114 int res2 = 0 ;
11115 PyObject * obj0 = 0 ;
11116 PyObject * obj1 = 0 ;
11117 char * kwnames[] = {
11118 (char *) "window",(char *) "dc", NULL
11119 };
11120
11121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11123 if (!SWIG_IsOK(res1)) {
11124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11125 }
11126 arg1 = reinterpret_cast< wxWindow * >(argp1);
11127 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11128 if (!SWIG_IsOK(res2)) {
11129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11130 }
11131 if (!argp2) {
11132 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11133 }
11134 arg2 = reinterpret_cast< wxDC * >(argp2);
11135 {
11136 PyThreadState* __tstate = wxPyBeginAllowThreads();
11137 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11138 wxPyEndAllowThreads(__tstate);
11139 if (PyErr_Occurred()) SWIG_fail;
11140 }
11141 {
11142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11143 }
11144 return resultobj;
11145 fail:
11146 return NULL;
11147 }
11148
11149
11150 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11151 PyObject *resultobj = 0;
11152 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11153 void *argp1 = 0 ;
11154 int res1 = 0 ;
11155 PyObject *swig_obj[1] ;
11156
11157 if (!args) SWIG_fail;
11158 swig_obj[0] = args;
11159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11160 if (!SWIG_IsOK(res1)) {
11161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11162 }
11163 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11164 {
11165 PyThreadState* __tstate = wxPyBeginAllowThreads();
11166 delete arg1;
11167
11168 wxPyEndAllowThreads(__tstate);
11169 if (PyErr_Occurred()) SWIG_fail;
11170 }
11171 resultobj = SWIG_Py_Void();
11172 return resultobj;
11173 fail:
11174 return NULL;
11175 }
11176
11177
11178 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11179 PyObject *resultobj = 0;
11180 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11181 wxString result;
11182 void *argp1 = 0 ;
11183 int res1 = 0 ;
11184 PyObject *swig_obj[1] ;
11185
11186 if (!args) SWIG_fail;
11187 swig_obj[0] = args;
11188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11189 if (!SWIG_IsOK(res1)) {
11190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11191 }
11192 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11193 {
11194 PyThreadState* __tstate = wxPyBeginAllowThreads();
11195 result = (arg1)->GetTip();
11196 wxPyEndAllowThreads(__tstate);
11197 if (PyErr_Occurred()) SWIG_fail;
11198 }
11199 {
11200 #if wxUSE_UNICODE
11201 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11202 #else
11203 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11204 #endif
11205 }
11206 return resultobj;
11207 fail:
11208 return NULL;
11209 }
11210
11211
11212 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11213 PyObject *resultobj = 0;
11214 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11215 size_t result;
11216 void *argp1 = 0 ;
11217 int res1 = 0 ;
11218 PyObject *swig_obj[1] ;
11219
11220 if (!args) SWIG_fail;
11221 swig_obj[0] = args;
11222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11223 if (!SWIG_IsOK(res1)) {
11224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11225 }
11226 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11227 {
11228 PyThreadState* __tstate = wxPyBeginAllowThreads();
11229 result = (size_t)(arg1)->GetCurrentTip();
11230 wxPyEndAllowThreads(__tstate);
11231 if (PyErr_Occurred()) SWIG_fail;
11232 }
11233 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11234 return resultobj;
11235 fail:
11236 return NULL;
11237 }
11238
11239
11240 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11241 PyObject *resultobj = 0;
11242 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11243 wxString *arg2 = 0 ;
11244 wxString result;
11245 void *argp1 = 0 ;
11246 int res1 = 0 ;
11247 bool temp2 = false ;
11248 PyObject * obj0 = 0 ;
11249 PyObject * obj1 = 0 ;
11250 char * kwnames[] = {
11251 (char *) "self",(char *) "tip", NULL
11252 };
11253
11254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11256 if (!SWIG_IsOK(res1)) {
11257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11258 }
11259 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11260 {
11261 arg2 = wxString_in_helper(obj1);
11262 if (arg2 == NULL) SWIG_fail;
11263 temp2 = true;
11264 }
11265 {
11266 PyThreadState* __tstate = wxPyBeginAllowThreads();
11267 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11268 wxPyEndAllowThreads(__tstate);
11269 if (PyErr_Occurred()) SWIG_fail;
11270 }
11271 {
11272 #if wxUSE_UNICODE
11273 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11274 #else
11275 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11276 #endif
11277 }
11278 {
11279 if (temp2)
11280 delete arg2;
11281 }
11282 return resultobj;
11283 fail:
11284 {
11285 if (temp2)
11286 delete arg2;
11287 }
11288 return NULL;
11289 }
11290
11291
11292 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11293 PyObject *obj;
11294 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11295 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11296 return SWIG_Py_Void();
11297 }
11298
11299 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11300 PyObject *resultobj = 0;
11301 size_t arg1 ;
11302 wxPyTipProvider *result = 0 ;
11303 size_t val1 ;
11304 int ecode1 = 0 ;
11305 PyObject * obj0 = 0 ;
11306 char * kwnames[] = {
11307 (char *) "currentTip", NULL
11308 };
11309
11310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11311 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11312 if (!SWIG_IsOK(ecode1)) {
11313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11314 }
11315 arg1 = static_cast< size_t >(val1);
11316 {
11317 PyThreadState* __tstate = wxPyBeginAllowThreads();
11318 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11319 wxPyEndAllowThreads(__tstate);
11320 if (PyErr_Occurred()) SWIG_fail;
11321 }
11322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11323 return resultobj;
11324 fail:
11325 return NULL;
11326 }
11327
11328
11329 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11330 PyObject *resultobj = 0;
11331 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11332 PyObject *arg2 = (PyObject *) 0 ;
11333 PyObject *arg3 = (PyObject *) 0 ;
11334 void *argp1 = 0 ;
11335 int res1 = 0 ;
11336 PyObject * obj0 = 0 ;
11337 PyObject * obj1 = 0 ;
11338 PyObject * obj2 = 0 ;
11339 char * kwnames[] = {
11340 (char *) "self",(char *) "self",(char *) "_class", NULL
11341 };
11342
11343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11345 if (!SWIG_IsOK(res1)) {
11346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11347 }
11348 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11349 arg2 = obj1;
11350 arg3 = obj2;
11351 {
11352 PyThreadState* __tstate = wxPyBeginAllowThreads();
11353 (arg1)->_setCallbackInfo(arg2,arg3);
11354 wxPyEndAllowThreads(__tstate);
11355 if (PyErr_Occurred()) SWIG_fail;
11356 }
11357 resultobj = SWIG_Py_Void();
11358 return resultobj;
11359 fail:
11360 return NULL;
11361 }
11362
11363
11364 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11365 PyObject *obj;
11366 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11367 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11368 return SWIG_Py_Void();
11369 }
11370
11371 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11372 return SWIG_Python_InitShadowInstance(args);
11373 }
11374
11375 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11376 PyObject *resultobj = 0;
11377 wxWindow *arg1 = (wxWindow *) 0 ;
11378 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11379 bool arg3 = (bool) true ;
11380 bool result;
11381 void *argp1 = 0 ;
11382 int res1 = 0 ;
11383 void *argp2 = 0 ;
11384 int res2 = 0 ;
11385 bool val3 ;
11386 int ecode3 = 0 ;
11387 PyObject * obj0 = 0 ;
11388 PyObject * obj1 = 0 ;
11389 PyObject * obj2 = 0 ;
11390 char * kwnames[] = {
11391 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11392 };
11393
11394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11396 if (!SWIG_IsOK(res1)) {
11397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11398 }
11399 arg1 = reinterpret_cast< wxWindow * >(argp1);
11400 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11401 if (!SWIG_IsOK(res2)) {
11402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11403 }
11404 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11405 if (obj2) {
11406 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11407 if (!SWIG_IsOK(ecode3)) {
11408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11409 }
11410 arg3 = static_cast< bool >(val3);
11411 }
11412 {
11413 if (!wxPyCheckForApp()) SWIG_fail;
11414 PyThreadState* __tstate = wxPyBeginAllowThreads();
11415 result = (bool)wxShowTip(arg1,arg2,arg3);
11416 wxPyEndAllowThreads(__tstate);
11417 if (PyErr_Occurred()) SWIG_fail;
11418 }
11419 {
11420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11421 }
11422 return resultobj;
11423 fail:
11424 return NULL;
11425 }
11426
11427
11428 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11429 PyObject *resultobj = 0;
11430 wxString *arg1 = 0 ;
11431 size_t arg2 ;
11432 wxTipProvider *result = 0 ;
11433 bool temp1 = false ;
11434 size_t val2 ;
11435 int ecode2 = 0 ;
11436 PyObject * obj0 = 0 ;
11437 PyObject * obj1 = 0 ;
11438 char * kwnames[] = {
11439 (char *) "filename",(char *) "currentTip", NULL
11440 };
11441
11442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11443 {
11444 arg1 = wxString_in_helper(obj0);
11445 if (arg1 == NULL) SWIG_fail;
11446 temp1 = true;
11447 }
11448 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11449 if (!SWIG_IsOK(ecode2)) {
11450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11451 }
11452 arg2 = static_cast< size_t >(val2);
11453 {
11454 if (!wxPyCheckForApp()) SWIG_fail;
11455 PyThreadState* __tstate = wxPyBeginAllowThreads();
11456 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11457 wxPyEndAllowThreads(__tstate);
11458 if (PyErr_Occurred()) SWIG_fail;
11459 }
11460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11461 {
11462 if (temp1)
11463 delete arg1;
11464 }
11465 return resultobj;
11466 fail:
11467 {
11468 if (temp1)
11469 delete arg1;
11470 }
11471 return NULL;
11472 }
11473
11474
11475 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11476 PyObject *resultobj = 0;
11477 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11478 int arg2 = (int) wxID_ANY ;
11479 wxPyTimer *result = 0 ;
11480 void *argp1 = 0 ;
11481 int res1 = 0 ;
11482 int val2 ;
11483 int ecode2 = 0 ;
11484 PyObject * obj0 = 0 ;
11485 PyObject * obj1 = 0 ;
11486 char * kwnames[] = {
11487 (char *) "owner",(char *) "id", NULL
11488 };
11489
11490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11491 if (obj0) {
11492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11493 if (!SWIG_IsOK(res1)) {
11494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11495 }
11496 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11497 }
11498 if (obj1) {
11499 ecode2 = SWIG_AsVal_int(obj1, &val2);
11500 if (!SWIG_IsOK(ecode2)) {
11501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11502 }
11503 arg2 = static_cast< int >(val2);
11504 }
11505 {
11506 if (!wxPyCheckForApp()) SWIG_fail;
11507 PyThreadState* __tstate = wxPyBeginAllowThreads();
11508 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11509 wxPyEndAllowThreads(__tstate);
11510 if (PyErr_Occurred()) SWIG_fail;
11511 }
11512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11513 return resultobj;
11514 fail:
11515 return NULL;
11516 }
11517
11518
11519 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11520 PyObject *resultobj = 0;
11521 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11522 void *argp1 = 0 ;
11523 int res1 = 0 ;
11524 PyObject *swig_obj[1] ;
11525
11526 if (!args) SWIG_fail;
11527 swig_obj[0] = args;
11528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11529 if (!SWIG_IsOK(res1)) {
11530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11531 }
11532 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11533 {
11534 PyThreadState* __tstate = wxPyBeginAllowThreads();
11535 delete arg1;
11536
11537 wxPyEndAllowThreads(__tstate);
11538 if (PyErr_Occurred()) SWIG_fail;
11539 }
11540 resultobj = SWIG_Py_Void();
11541 return resultobj;
11542 fail:
11543 return NULL;
11544 }
11545
11546
11547 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11548 PyObject *resultobj = 0;
11549 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11550 PyObject *arg2 = (PyObject *) 0 ;
11551 PyObject *arg3 = (PyObject *) 0 ;
11552 int arg4 = (int) 0 ;
11553 void *argp1 = 0 ;
11554 int res1 = 0 ;
11555 int val4 ;
11556 int ecode4 = 0 ;
11557 PyObject * obj0 = 0 ;
11558 PyObject * obj1 = 0 ;
11559 PyObject * obj2 = 0 ;
11560 PyObject * obj3 = 0 ;
11561 char * kwnames[] = {
11562 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11563 };
11564
11565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11567 if (!SWIG_IsOK(res1)) {
11568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11569 }
11570 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11571 arg2 = obj1;
11572 arg3 = obj2;
11573 if (obj3) {
11574 ecode4 = SWIG_AsVal_int(obj3, &val4);
11575 if (!SWIG_IsOK(ecode4)) {
11576 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11577 }
11578 arg4 = static_cast< int >(val4);
11579 }
11580 {
11581 PyThreadState* __tstate = wxPyBeginAllowThreads();
11582 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11583 wxPyEndAllowThreads(__tstate);
11584 if (PyErr_Occurred()) SWIG_fail;
11585 }
11586 resultobj = SWIG_Py_Void();
11587 return resultobj;
11588 fail:
11589 return NULL;
11590 }
11591
11592
11593 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11594 PyObject *resultobj = 0;
11595 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11596 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11597 int arg3 = (int) wxID_ANY ;
11598 void *argp1 = 0 ;
11599 int res1 = 0 ;
11600 void *argp2 = 0 ;
11601 int res2 = 0 ;
11602 int val3 ;
11603 int ecode3 = 0 ;
11604 PyObject * obj0 = 0 ;
11605 PyObject * obj1 = 0 ;
11606 PyObject * obj2 = 0 ;
11607 char * kwnames[] = {
11608 (char *) "self",(char *) "owner",(char *) "id", NULL
11609 };
11610
11611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11613 if (!SWIG_IsOK(res1)) {
11614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11615 }
11616 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11617 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11618 if (!SWIG_IsOK(res2)) {
11619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11620 }
11621 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11622 if (obj2) {
11623 ecode3 = SWIG_AsVal_int(obj2, &val3);
11624 if (!SWIG_IsOK(ecode3)) {
11625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11626 }
11627 arg3 = static_cast< int >(val3);
11628 }
11629 {
11630 PyThreadState* __tstate = wxPyBeginAllowThreads();
11631 (arg1)->SetOwner(arg2,arg3);
11632 wxPyEndAllowThreads(__tstate);
11633 if (PyErr_Occurred()) SWIG_fail;
11634 }
11635 resultobj = SWIG_Py_Void();
11636 return resultobj;
11637 fail:
11638 return NULL;
11639 }
11640
11641
11642 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11643 PyObject *resultobj = 0;
11644 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11645 wxEvtHandler *result = 0 ;
11646 void *argp1 = 0 ;
11647 int res1 = 0 ;
11648 PyObject *swig_obj[1] ;
11649
11650 if (!args) SWIG_fail;
11651 swig_obj[0] = args;
11652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11653 if (!SWIG_IsOK(res1)) {
11654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11655 }
11656 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11657 {
11658 PyThreadState* __tstate = wxPyBeginAllowThreads();
11659 result = (wxEvtHandler *)(arg1)->GetOwner();
11660 wxPyEndAllowThreads(__tstate);
11661 if (PyErr_Occurred()) SWIG_fail;
11662 }
11663 {
11664 resultobj = wxPyMake_wxObject(result, 0);
11665 }
11666 return resultobj;
11667 fail:
11668 return NULL;
11669 }
11670
11671
11672 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11673 PyObject *resultobj = 0;
11674 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11675 int arg2 = (int) -1 ;
11676 bool arg3 = (bool) false ;
11677 bool result;
11678 void *argp1 = 0 ;
11679 int res1 = 0 ;
11680 int val2 ;
11681 int ecode2 = 0 ;
11682 bool val3 ;
11683 int ecode3 = 0 ;
11684 PyObject * obj0 = 0 ;
11685 PyObject * obj1 = 0 ;
11686 PyObject * obj2 = 0 ;
11687 char * kwnames[] = {
11688 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11689 };
11690
11691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11693 if (!SWIG_IsOK(res1)) {
11694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11695 }
11696 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11697 if (obj1) {
11698 ecode2 = SWIG_AsVal_int(obj1, &val2);
11699 if (!SWIG_IsOK(ecode2)) {
11700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11701 }
11702 arg2 = static_cast< int >(val2);
11703 }
11704 if (obj2) {
11705 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11706 if (!SWIG_IsOK(ecode3)) {
11707 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11708 }
11709 arg3 = static_cast< bool >(val3);
11710 }
11711 {
11712 PyThreadState* __tstate = wxPyBeginAllowThreads();
11713 result = (bool)(arg1)->Start(arg2,arg3);
11714 wxPyEndAllowThreads(__tstate);
11715 if (PyErr_Occurred()) SWIG_fail;
11716 }
11717 {
11718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11719 }
11720 return resultobj;
11721 fail:
11722 return NULL;
11723 }
11724
11725
11726 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11727 PyObject *resultobj = 0;
11728 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11729 void *argp1 = 0 ;
11730 int res1 = 0 ;
11731 PyObject *swig_obj[1] ;
11732
11733 if (!args) SWIG_fail;
11734 swig_obj[0] = args;
11735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11736 if (!SWIG_IsOK(res1)) {
11737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11738 }
11739 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11740 {
11741 PyThreadState* __tstate = wxPyBeginAllowThreads();
11742 (arg1)->Stop();
11743 wxPyEndAllowThreads(__tstate);
11744 if (PyErr_Occurred()) SWIG_fail;
11745 }
11746 resultobj = SWIG_Py_Void();
11747 return resultobj;
11748 fail:
11749 return NULL;
11750 }
11751
11752
11753 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11754 PyObject *resultobj = 0;
11755 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11756 void *argp1 = 0 ;
11757 int res1 = 0 ;
11758 PyObject *swig_obj[1] ;
11759
11760 if (!args) SWIG_fail;
11761 swig_obj[0] = args;
11762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11763 if (!SWIG_IsOK(res1)) {
11764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11765 }
11766 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11767 {
11768 PyThreadState* __tstate = wxPyBeginAllowThreads();
11769 (arg1)->Notify();
11770 wxPyEndAllowThreads(__tstate);
11771 if (PyErr_Occurred()) SWIG_fail;
11772 }
11773 resultobj = SWIG_Py_Void();
11774 return resultobj;
11775 fail:
11776 return NULL;
11777 }
11778
11779
11780 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11781 PyObject *resultobj = 0;
11782 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11783 bool result;
11784 void *argp1 = 0 ;
11785 int res1 = 0 ;
11786 PyObject *swig_obj[1] ;
11787
11788 if (!args) SWIG_fail;
11789 swig_obj[0] = args;
11790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11791 if (!SWIG_IsOK(res1)) {
11792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11793 }
11794 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11795 {
11796 PyThreadState* __tstate = wxPyBeginAllowThreads();
11797 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11798 wxPyEndAllowThreads(__tstate);
11799 if (PyErr_Occurred()) SWIG_fail;
11800 }
11801 {
11802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11803 }
11804 return resultobj;
11805 fail:
11806 return NULL;
11807 }
11808
11809
11810 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11811 PyObject *resultobj = 0;
11812 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11813 int result;
11814 void *argp1 = 0 ;
11815 int res1 = 0 ;
11816 PyObject *swig_obj[1] ;
11817
11818 if (!args) SWIG_fail;
11819 swig_obj[0] = args;
11820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11821 if (!SWIG_IsOK(res1)) {
11822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11823 }
11824 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11825 {
11826 PyThreadState* __tstate = wxPyBeginAllowThreads();
11827 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11828 wxPyEndAllowThreads(__tstate);
11829 if (PyErr_Occurred()) SWIG_fail;
11830 }
11831 resultobj = SWIG_From_int(static_cast< int >(result));
11832 return resultobj;
11833 fail:
11834 return NULL;
11835 }
11836
11837
11838 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11839 PyObject *resultobj = 0;
11840 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11841 int result;
11842 void *argp1 = 0 ;
11843 int res1 = 0 ;
11844 PyObject *swig_obj[1] ;
11845
11846 if (!args) SWIG_fail;
11847 swig_obj[0] = args;
11848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11849 if (!SWIG_IsOK(res1)) {
11850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11851 }
11852 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11853 {
11854 PyThreadState* __tstate = wxPyBeginAllowThreads();
11855 result = (int)((wxPyTimer const *)arg1)->GetId();
11856 wxPyEndAllowThreads(__tstate);
11857 if (PyErr_Occurred()) SWIG_fail;
11858 }
11859 resultobj = SWIG_From_int(static_cast< int >(result));
11860 return resultobj;
11861 fail:
11862 return NULL;
11863 }
11864
11865
11866 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11867 PyObject *resultobj = 0;
11868 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11869 bool result;
11870 void *argp1 = 0 ;
11871 int res1 = 0 ;
11872 PyObject *swig_obj[1] ;
11873
11874 if (!args) SWIG_fail;
11875 swig_obj[0] = args;
11876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11877 if (!SWIG_IsOK(res1)) {
11878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11879 }
11880 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11881 {
11882 PyThreadState* __tstate = wxPyBeginAllowThreads();
11883 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11884 wxPyEndAllowThreads(__tstate);
11885 if (PyErr_Occurred()) SWIG_fail;
11886 }
11887 {
11888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11889 }
11890 return resultobj;
11891 fail:
11892 return NULL;
11893 }
11894
11895
11896 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11897 PyObject *obj;
11898 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11899 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11900 return SWIG_Py_Void();
11901 }
11902
11903 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11904 return SWIG_Python_InitShadowInstance(args);
11905 }
11906
11907 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11908 PyObject *resultobj = 0;
11909 int arg1 = (int) 0 ;
11910 int arg2 = (int) 0 ;
11911 wxTimerEvent *result = 0 ;
11912 int val1 ;
11913 int ecode1 = 0 ;
11914 int val2 ;
11915 int ecode2 = 0 ;
11916 PyObject * obj0 = 0 ;
11917 PyObject * obj1 = 0 ;
11918 char * kwnames[] = {
11919 (char *) "timerid",(char *) "interval", NULL
11920 };
11921
11922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11923 if (obj0) {
11924 ecode1 = SWIG_AsVal_int(obj0, &val1);
11925 if (!SWIG_IsOK(ecode1)) {
11926 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11927 }
11928 arg1 = static_cast< int >(val1);
11929 }
11930 if (obj1) {
11931 ecode2 = SWIG_AsVal_int(obj1, &val2);
11932 if (!SWIG_IsOK(ecode2)) {
11933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11934 }
11935 arg2 = static_cast< int >(val2);
11936 }
11937 {
11938 PyThreadState* __tstate = wxPyBeginAllowThreads();
11939 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11940 wxPyEndAllowThreads(__tstate);
11941 if (PyErr_Occurred()) SWIG_fail;
11942 }
11943 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11944 return resultobj;
11945 fail:
11946 return NULL;
11947 }
11948
11949
11950 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11951 PyObject *resultobj = 0;
11952 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11953 int result;
11954 void *argp1 = 0 ;
11955 int res1 = 0 ;
11956 PyObject *swig_obj[1] ;
11957
11958 if (!args) SWIG_fail;
11959 swig_obj[0] = args;
11960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11961 if (!SWIG_IsOK(res1)) {
11962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11963 }
11964 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11965 {
11966 PyThreadState* __tstate = wxPyBeginAllowThreads();
11967 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11968 wxPyEndAllowThreads(__tstate);
11969 if (PyErr_Occurred()) SWIG_fail;
11970 }
11971 resultobj = SWIG_From_int(static_cast< int >(result));
11972 return resultobj;
11973 fail:
11974 return NULL;
11975 }
11976
11977
11978 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11979 PyObject *obj;
11980 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11981 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11982 return SWIG_Py_Void();
11983 }
11984
11985 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11986 return SWIG_Python_InitShadowInstance(args);
11987 }
11988
11989 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11990 PyObject *resultobj = 0;
11991 wxTimer *arg1 = 0 ;
11992 wxTimerRunner *result = 0 ;
11993 void *argp1 = 0 ;
11994 int res1 = 0 ;
11995
11996 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11998 if (!SWIG_IsOK(res1)) {
11999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12000 }
12001 if (!argp1) {
12002 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12003 }
12004 arg1 = reinterpret_cast< wxTimer * >(argp1);
12005 {
12006 if (!wxPyCheckForApp()) SWIG_fail;
12007 PyThreadState* __tstate = wxPyBeginAllowThreads();
12008 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
12009 wxPyEndAllowThreads(__tstate);
12010 if (PyErr_Occurred()) SWIG_fail;
12011 }
12012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12013 return resultobj;
12014 fail:
12015 return NULL;
12016 }
12017
12018
12019 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12020 PyObject *resultobj = 0;
12021 wxTimer *arg1 = 0 ;
12022 int arg2 ;
12023 bool arg3 = (bool) false ;
12024 wxTimerRunner *result = 0 ;
12025 void *argp1 = 0 ;
12026 int res1 = 0 ;
12027 int val2 ;
12028 int ecode2 = 0 ;
12029 bool val3 ;
12030 int ecode3 = 0 ;
12031
12032 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
12033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
12034 if (!SWIG_IsOK(res1)) {
12035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12036 }
12037 if (!argp1) {
12038 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12039 }
12040 arg1 = reinterpret_cast< wxTimer * >(argp1);
12041 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12042 if (!SWIG_IsOK(ecode2)) {
12043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
12044 }
12045 arg2 = static_cast< int >(val2);
12046 if (swig_obj[2]) {
12047 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12048 if (!SWIG_IsOK(ecode3)) {
12049 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12050 }
12051 arg3 = static_cast< bool >(val3);
12052 }
12053 {
12054 if (!wxPyCheckForApp()) SWIG_fail;
12055 PyThreadState* __tstate = wxPyBeginAllowThreads();
12056 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12057 wxPyEndAllowThreads(__tstate);
12058 if (PyErr_Occurred()) SWIG_fail;
12059 }
12060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12061 return resultobj;
12062 fail:
12063 return NULL;
12064 }
12065
12066
12067 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12068 int argc;
12069 PyObject *argv[4];
12070
12071 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12072 --argc;
12073 if (argc == 1) {
12074 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12075 }
12076 if ((argc >= 2) && (argc <= 3)) {
12077 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12078 }
12079
12080 fail:
12081 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12082 return NULL;
12083 }
12084
12085
12086 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12087 PyObject *resultobj = 0;
12088 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12089 void *argp1 = 0 ;
12090 int res1 = 0 ;
12091 PyObject *swig_obj[1] ;
12092
12093 if (!args) SWIG_fail;
12094 swig_obj[0] = args;
12095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12096 if (!SWIG_IsOK(res1)) {
12097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12098 }
12099 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12100 {
12101 PyThreadState* __tstate = wxPyBeginAllowThreads();
12102 delete arg1;
12103
12104 wxPyEndAllowThreads(__tstate);
12105 if (PyErr_Occurred()) SWIG_fail;
12106 }
12107 resultobj = SWIG_Py_Void();
12108 return resultobj;
12109 fail:
12110 return NULL;
12111 }
12112
12113
12114 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12115 PyObject *resultobj = 0;
12116 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12117 int arg2 ;
12118 bool arg3 = (bool) false ;
12119 void *argp1 = 0 ;
12120 int res1 = 0 ;
12121 int val2 ;
12122 int ecode2 = 0 ;
12123 bool val3 ;
12124 int ecode3 = 0 ;
12125 PyObject * obj0 = 0 ;
12126 PyObject * obj1 = 0 ;
12127 PyObject * obj2 = 0 ;
12128 char * kwnames[] = {
12129 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12130 };
12131
12132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12134 if (!SWIG_IsOK(res1)) {
12135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12136 }
12137 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12138 ecode2 = SWIG_AsVal_int(obj1, &val2);
12139 if (!SWIG_IsOK(ecode2)) {
12140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12141 }
12142 arg2 = static_cast< int >(val2);
12143 if (obj2) {
12144 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12145 if (!SWIG_IsOK(ecode3)) {
12146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12147 }
12148 arg3 = static_cast< bool >(val3);
12149 }
12150 {
12151 PyThreadState* __tstate = wxPyBeginAllowThreads();
12152 (arg1)->Start(arg2,arg3);
12153 wxPyEndAllowThreads(__tstate);
12154 if (PyErr_Occurred()) SWIG_fail;
12155 }
12156 resultobj = SWIG_Py_Void();
12157 return resultobj;
12158 fail:
12159 return NULL;
12160 }
12161
12162
12163 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12164 PyObject *obj;
12165 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12166 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12167 return SWIG_Py_Void();
12168 }
12169
12170 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12171 return SWIG_Python_InitShadowInstance(args);
12172 }
12173
12174 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12175 PyObject *resultobj = 0;
12176 wxLog *result = 0 ;
12177
12178 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12179 {
12180 PyThreadState* __tstate = wxPyBeginAllowThreads();
12181 result = (wxLog *)new wxLog();
12182 wxPyEndAllowThreads(__tstate);
12183 if (PyErr_Occurred()) SWIG_fail;
12184 }
12185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12186 return resultobj;
12187 fail:
12188 return NULL;
12189 }
12190
12191
12192 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12193 PyObject *resultobj = 0;
12194 wxLog *arg1 = (wxLog *) 0 ;
12195 void *argp1 = 0 ;
12196 int res1 = 0 ;
12197 PyObject *swig_obj[1] ;
12198
12199 if (!args) SWIG_fail;
12200 swig_obj[0] = args;
12201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12202 if (!SWIG_IsOK(res1)) {
12203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12204 }
12205 arg1 = reinterpret_cast< wxLog * >(argp1);
12206 {
12207 PyThreadState* __tstate = wxPyBeginAllowThreads();
12208 delete arg1;
12209
12210 wxPyEndAllowThreads(__tstate);
12211 if (PyErr_Occurred()) SWIG_fail;
12212 }
12213 resultobj = SWIG_Py_Void();
12214 return resultobj;
12215 fail:
12216 return NULL;
12217 }
12218
12219
12220 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12221 PyObject *resultobj = 0;
12222 bool result;
12223
12224 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12225 {
12226 PyThreadState* __tstate = wxPyBeginAllowThreads();
12227 result = (bool)wxLog::IsEnabled();
12228 wxPyEndAllowThreads(__tstate);
12229 if (PyErr_Occurred()) SWIG_fail;
12230 }
12231 {
12232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12233 }
12234 return resultobj;
12235 fail:
12236 return NULL;
12237 }
12238
12239
12240 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12241 PyObject *resultobj = 0;
12242 bool arg1 = (bool) true ;
12243 bool result;
12244 bool val1 ;
12245 int ecode1 = 0 ;
12246 PyObject * obj0 = 0 ;
12247 char * kwnames[] = {
12248 (char *) "doIt", NULL
12249 };
12250
12251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12252 if (obj0) {
12253 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12254 if (!SWIG_IsOK(ecode1)) {
12255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12256 }
12257 arg1 = static_cast< bool >(val1);
12258 }
12259 {
12260 PyThreadState* __tstate = wxPyBeginAllowThreads();
12261 result = (bool)wxLog::EnableLogging(arg1);
12262 wxPyEndAllowThreads(__tstate);
12263 if (PyErr_Occurred()) SWIG_fail;
12264 }
12265 {
12266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12267 }
12268 return resultobj;
12269 fail:
12270 return NULL;
12271 }
12272
12273
12274 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12275 PyObject *resultobj = 0;
12276 wxLogLevel arg1 ;
12277 wxChar *arg2 = (wxChar *) 0 ;
12278 time_t arg3 ;
12279 unsigned long val1 ;
12280 int ecode1 = 0 ;
12281 void *argp2 = 0 ;
12282 int res2 = 0 ;
12283 unsigned int val3 ;
12284 int ecode3 = 0 ;
12285 PyObject * obj0 = 0 ;
12286 PyObject * obj1 = 0 ;
12287 PyObject * obj2 = 0 ;
12288 char * kwnames[] = {
12289 (char *) "level",(char *) "szString",(char *) "t", NULL
12290 };
12291
12292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12293 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12294 if (!SWIG_IsOK(ecode1)) {
12295 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12296 }
12297 arg1 = static_cast< wxLogLevel >(val1);
12298 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12299 if (!SWIG_IsOK(res2)) {
12300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12301 }
12302 arg2 = reinterpret_cast< wxChar * >(argp2);
12303 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12304 if (!SWIG_IsOK(ecode3)) {
12305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12306 }
12307 arg3 = static_cast< time_t >(val3);
12308 {
12309 PyThreadState* __tstate = wxPyBeginAllowThreads();
12310 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12311 wxPyEndAllowThreads(__tstate);
12312 if (PyErr_Occurred()) SWIG_fail;
12313 }
12314 resultobj = SWIG_Py_Void();
12315 return resultobj;
12316 fail:
12317 return NULL;
12318 }
12319
12320
12321 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12322 PyObject *resultobj = 0;
12323 wxLog *arg1 = (wxLog *) 0 ;
12324 void *argp1 = 0 ;
12325 int res1 = 0 ;
12326 PyObject *swig_obj[1] ;
12327
12328 if (!args) SWIG_fail;
12329 swig_obj[0] = args;
12330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12331 if (!SWIG_IsOK(res1)) {
12332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12333 }
12334 arg1 = reinterpret_cast< wxLog * >(argp1);
12335 {
12336 PyThreadState* __tstate = wxPyBeginAllowThreads();
12337 (arg1)->Flush();
12338 wxPyEndAllowThreads(__tstate);
12339 if (PyErr_Occurred()) SWIG_fail;
12340 }
12341 resultobj = SWIG_Py_Void();
12342 return resultobj;
12343 fail:
12344 return NULL;
12345 }
12346
12347
12348 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12349 PyObject *resultobj = 0;
12350
12351 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12352 {
12353 PyThreadState* __tstate = wxPyBeginAllowThreads();
12354 wxLog::FlushActive();
12355 wxPyEndAllowThreads(__tstate);
12356 if (PyErr_Occurred()) SWIG_fail;
12357 }
12358 resultobj = SWIG_Py_Void();
12359 return resultobj;
12360 fail:
12361 return NULL;
12362 }
12363
12364
12365 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12366 PyObject *resultobj = 0;
12367 wxLog *result = 0 ;
12368
12369 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12370 {
12371 PyThreadState* __tstate = wxPyBeginAllowThreads();
12372 result = (wxLog *)wxLog::GetActiveTarget();
12373 wxPyEndAllowThreads(__tstate);
12374 if (PyErr_Occurred()) SWIG_fail;
12375 }
12376 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12377 return resultobj;
12378 fail:
12379 return NULL;
12380 }
12381
12382
12383 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12384 PyObject *resultobj = 0;
12385 wxLog *arg1 = (wxLog *) 0 ;
12386 wxLog *result = 0 ;
12387 int res1 = 0 ;
12388 PyObject * obj0 = 0 ;
12389 char * kwnames[] = {
12390 (char *) "pLogger", NULL
12391 };
12392
12393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12394 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12395 if (!SWIG_IsOK(res1)) {
12396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12397 }
12398 {
12399 PyThreadState* __tstate = wxPyBeginAllowThreads();
12400 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12401 wxPyEndAllowThreads(__tstate);
12402 if (PyErr_Occurred()) SWIG_fail;
12403 }
12404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12405 return resultobj;
12406 fail:
12407 return NULL;
12408 }
12409
12410
12411 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12412 PyObject *resultobj = 0;
12413
12414 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12415 {
12416 PyThreadState* __tstate = wxPyBeginAllowThreads();
12417 wxLog::Suspend();
12418 wxPyEndAllowThreads(__tstate);
12419 if (PyErr_Occurred()) SWIG_fail;
12420 }
12421 resultobj = SWIG_Py_Void();
12422 return resultobj;
12423 fail:
12424 return NULL;
12425 }
12426
12427
12428 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12429 PyObject *resultobj = 0;
12430
12431 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12432 {
12433 PyThreadState* __tstate = wxPyBeginAllowThreads();
12434 wxLog::Resume();
12435 wxPyEndAllowThreads(__tstate);
12436 if (PyErr_Occurred()) SWIG_fail;
12437 }
12438 resultobj = SWIG_Py_Void();
12439 return resultobj;
12440 fail:
12441 return NULL;
12442 }
12443
12444
12445 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12446 PyObject *resultobj = 0;
12447 bool arg1 = (bool) true ;
12448 bool val1 ;
12449 int ecode1 = 0 ;
12450 PyObject * obj0 = 0 ;
12451 char * kwnames[] = {
12452 (char *) "bVerbose", NULL
12453 };
12454
12455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12456 if (obj0) {
12457 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12458 if (!SWIG_IsOK(ecode1)) {
12459 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12460 }
12461 arg1 = static_cast< bool >(val1);
12462 }
12463 {
12464 PyThreadState* __tstate = wxPyBeginAllowThreads();
12465 wxLog::SetVerbose(arg1);
12466 wxPyEndAllowThreads(__tstate);
12467 if (PyErr_Occurred()) SWIG_fail;
12468 }
12469 resultobj = SWIG_Py_Void();
12470 return resultobj;
12471 fail:
12472 return NULL;
12473 }
12474
12475
12476 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12477 PyObject *resultobj = 0;
12478 wxLogLevel arg1 ;
12479 unsigned long val1 ;
12480 int ecode1 = 0 ;
12481 PyObject * obj0 = 0 ;
12482 char * kwnames[] = {
12483 (char *) "logLevel", NULL
12484 };
12485
12486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12487 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12488 if (!SWIG_IsOK(ecode1)) {
12489 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12490 }
12491 arg1 = static_cast< wxLogLevel >(val1);
12492 {
12493 PyThreadState* __tstate = wxPyBeginAllowThreads();
12494 wxLog::SetLogLevel(arg1);
12495 wxPyEndAllowThreads(__tstate);
12496 if (PyErr_Occurred()) SWIG_fail;
12497 }
12498 resultobj = SWIG_Py_Void();
12499 return resultobj;
12500 fail:
12501 return NULL;
12502 }
12503
12504
12505 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12506 PyObject *resultobj = 0;
12507
12508 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12509 {
12510 PyThreadState* __tstate = wxPyBeginAllowThreads();
12511 wxLog::DontCreateOnDemand();
12512 wxPyEndAllowThreads(__tstate);
12513 if (PyErr_Occurred()) SWIG_fail;
12514 }
12515 resultobj = SWIG_Py_Void();
12516 return resultobj;
12517 fail:
12518 return NULL;
12519 }
12520
12521
12522 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12523 PyObject *resultobj = 0;
12524 bool arg1 = (bool) true ;
12525 bool val1 ;
12526 int ecode1 = 0 ;
12527 PyObject * obj0 = 0 ;
12528 char * kwnames[] = {
12529 (char *) "bRepetCounting", NULL
12530 };
12531
12532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12533 if (obj0) {
12534 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12535 if (!SWIG_IsOK(ecode1)) {
12536 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12537 }
12538 arg1 = static_cast< bool >(val1);
12539 }
12540 {
12541 PyThreadState* __tstate = wxPyBeginAllowThreads();
12542 wxLog::SetRepetitionCounting(arg1);
12543 wxPyEndAllowThreads(__tstate);
12544 if (PyErr_Occurred()) SWIG_fail;
12545 }
12546 resultobj = SWIG_Py_Void();
12547 return resultobj;
12548 fail:
12549 return NULL;
12550 }
12551
12552
12553 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12554 PyObject *resultobj = 0;
12555 bool result;
12556
12557 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12558 {
12559 PyThreadState* __tstate = wxPyBeginAllowThreads();
12560 result = (bool)wxLog::GetRepetitionCounting();
12561 wxPyEndAllowThreads(__tstate);
12562 if (PyErr_Occurred()) SWIG_fail;
12563 }
12564 {
12565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12566 }
12567 return resultobj;
12568 fail:
12569 return NULL;
12570 }
12571
12572
12573 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12574 PyObject *resultobj = 0;
12575 wxTraceMask arg1 ;
12576 unsigned long val1 ;
12577 int ecode1 = 0 ;
12578 PyObject * obj0 = 0 ;
12579 char * kwnames[] = {
12580 (char *) "ulMask", NULL
12581 };
12582
12583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12584 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12585 if (!SWIG_IsOK(ecode1)) {
12586 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12587 }
12588 arg1 = static_cast< wxTraceMask >(val1);
12589 {
12590 PyThreadState* __tstate = wxPyBeginAllowThreads();
12591 wxLog::SetTraceMask(arg1);
12592 wxPyEndAllowThreads(__tstate);
12593 if (PyErr_Occurred()) SWIG_fail;
12594 }
12595 resultobj = SWIG_Py_Void();
12596 return resultobj;
12597 fail:
12598 return NULL;
12599 }
12600
12601
12602 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12603 PyObject *resultobj = 0;
12604 wxString *arg1 = 0 ;
12605 bool temp1 = false ;
12606 PyObject * obj0 = 0 ;
12607 char * kwnames[] = {
12608 (char *) "str", NULL
12609 };
12610
12611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12612 {
12613 arg1 = wxString_in_helper(obj0);
12614 if (arg1 == NULL) SWIG_fail;
12615 temp1 = true;
12616 }
12617 {
12618 PyThreadState* __tstate = wxPyBeginAllowThreads();
12619 wxLog::AddTraceMask((wxString const &)*arg1);
12620 wxPyEndAllowThreads(__tstate);
12621 if (PyErr_Occurred()) SWIG_fail;
12622 }
12623 resultobj = SWIG_Py_Void();
12624 {
12625 if (temp1)
12626 delete arg1;
12627 }
12628 return resultobj;
12629 fail:
12630 {
12631 if (temp1)
12632 delete arg1;
12633 }
12634 return NULL;
12635 }
12636
12637
12638 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12639 PyObject *resultobj = 0;
12640 wxString *arg1 = 0 ;
12641 bool temp1 = false ;
12642 PyObject * obj0 = 0 ;
12643 char * kwnames[] = {
12644 (char *) "str", NULL
12645 };
12646
12647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12648 {
12649 arg1 = wxString_in_helper(obj0);
12650 if (arg1 == NULL) SWIG_fail;
12651 temp1 = true;
12652 }
12653 {
12654 PyThreadState* __tstate = wxPyBeginAllowThreads();
12655 wxLog::RemoveTraceMask((wxString const &)*arg1);
12656 wxPyEndAllowThreads(__tstate);
12657 if (PyErr_Occurred()) SWIG_fail;
12658 }
12659 resultobj = SWIG_Py_Void();
12660 {
12661 if (temp1)
12662 delete arg1;
12663 }
12664 return resultobj;
12665 fail:
12666 {
12667 if (temp1)
12668 delete arg1;
12669 }
12670 return NULL;
12671 }
12672
12673
12674 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12675 PyObject *resultobj = 0;
12676
12677 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12678 {
12679 PyThreadState* __tstate = wxPyBeginAllowThreads();
12680 wxLog::ClearTraceMasks();
12681 wxPyEndAllowThreads(__tstate);
12682 if (PyErr_Occurred()) SWIG_fail;
12683 }
12684 resultobj = SWIG_Py_Void();
12685 return resultobj;
12686 fail:
12687 return NULL;
12688 }
12689
12690
12691 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12692 PyObject *resultobj = 0;
12693 wxArrayString *result = 0 ;
12694
12695 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12696 {
12697 PyThreadState* __tstate = wxPyBeginAllowThreads();
12698 {
12699 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12700 result = (wxArrayString *) &_result_ref;
12701 }
12702 wxPyEndAllowThreads(__tstate);
12703 if (PyErr_Occurred()) SWIG_fail;
12704 }
12705 {
12706 resultobj = wxArrayString2PyList_helper(*result);
12707 }
12708 return resultobj;
12709 fail:
12710 return NULL;
12711 }
12712
12713
12714 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12715 PyObject *resultobj = 0;
12716 wxChar *arg1 = (wxChar *) 0 ;
12717 void *argp1 = 0 ;
12718 int res1 = 0 ;
12719 PyObject * obj0 = 0 ;
12720 char * kwnames[] = {
12721 (char *) "ts", NULL
12722 };
12723
12724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12726 if (!SWIG_IsOK(res1)) {
12727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12728 }
12729 arg1 = reinterpret_cast< wxChar * >(argp1);
12730 {
12731 PyThreadState* __tstate = wxPyBeginAllowThreads();
12732 wxLog::SetTimestamp((wxChar const *)arg1);
12733 wxPyEndAllowThreads(__tstate);
12734 if (PyErr_Occurred()) SWIG_fail;
12735 }
12736 resultobj = SWIG_Py_Void();
12737 return resultobj;
12738 fail:
12739 return NULL;
12740 }
12741
12742
12743 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12744 PyObject *resultobj = 0;
12745 bool result;
12746
12747 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12748 {
12749 PyThreadState* __tstate = wxPyBeginAllowThreads();
12750 result = (bool)wxLog::GetVerbose();
12751 wxPyEndAllowThreads(__tstate);
12752 if (PyErr_Occurred()) SWIG_fail;
12753 }
12754 {
12755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12756 }
12757 return resultobj;
12758 fail:
12759 return NULL;
12760 }
12761
12762
12763 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12764 PyObject *resultobj = 0;
12765 wxTraceMask result;
12766
12767 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12768 {
12769 PyThreadState* __tstate = wxPyBeginAllowThreads();
12770 result = (wxTraceMask)wxLog::GetTraceMask();
12771 wxPyEndAllowThreads(__tstate);
12772 if (PyErr_Occurred()) SWIG_fail;
12773 }
12774 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12775 return resultobj;
12776 fail:
12777 return NULL;
12778 }
12779
12780
12781 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12782 PyObject *resultobj = 0;
12783 wxChar *arg1 = (wxChar *) 0 ;
12784 bool result;
12785 void *argp1 = 0 ;
12786 int res1 = 0 ;
12787 PyObject * obj0 = 0 ;
12788 char * kwnames[] = {
12789 (char *) "mask", NULL
12790 };
12791
12792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12794 if (!SWIG_IsOK(res1)) {
12795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12796 }
12797 arg1 = reinterpret_cast< wxChar * >(argp1);
12798 {
12799 PyThreadState* __tstate = wxPyBeginAllowThreads();
12800 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12801 wxPyEndAllowThreads(__tstate);
12802 if (PyErr_Occurred()) SWIG_fail;
12803 }
12804 {
12805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12806 }
12807 return resultobj;
12808 fail:
12809 return NULL;
12810 }
12811
12812
12813 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12814 PyObject *resultobj = 0;
12815 wxLogLevel result;
12816
12817 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12818 {
12819 PyThreadState* __tstate = wxPyBeginAllowThreads();
12820 result = (wxLogLevel)wxLog::GetLogLevel();
12821 wxPyEndAllowThreads(__tstate);
12822 if (PyErr_Occurred()) SWIG_fail;
12823 }
12824 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12825 return resultobj;
12826 fail:
12827 return NULL;
12828 }
12829
12830
12831 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12832 PyObject *resultobj = 0;
12833 wxChar *result = 0 ;
12834
12835 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12836 {
12837 PyThreadState* __tstate = wxPyBeginAllowThreads();
12838 result = (wxChar *)wxLog::GetTimestamp();
12839 wxPyEndAllowThreads(__tstate);
12840 if (PyErr_Occurred()) SWIG_fail;
12841 }
12842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12843 return resultobj;
12844 fail:
12845 return NULL;
12846 }
12847
12848
12849 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12850 PyObject *resultobj = 0;
12851 wxString result;
12852
12853 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12854 {
12855 PyThreadState* __tstate = wxPyBeginAllowThreads();
12856 result = wxLog_TimeStamp();
12857 wxPyEndAllowThreads(__tstate);
12858 if (PyErr_Occurred()) SWIG_fail;
12859 }
12860 {
12861 #if wxUSE_UNICODE
12862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12863 #else
12864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12865 #endif
12866 }
12867 return resultobj;
12868 fail:
12869 return NULL;
12870 }
12871
12872
12873 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12874 PyObject *resultobj = 0;
12875 wxLog *arg1 = (wxLog *) 0 ;
12876 void *argp1 = 0 ;
12877 int res1 = 0 ;
12878 PyObject *swig_obj[1] ;
12879
12880 if (!args) SWIG_fail;
12881 swig_obj[0] = args;
12882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12883 if (!SWIG_IsOK(res1)) {
12884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12885 }
12886 arg1 = reinterpret_cast< wxLog * >(argp1);
12887 {
12888 PyThreadState* __tstate = wxPyBeginAllowThreads();
12889 wxLog_Destroy(arg1);
12890 wxPyEndAllowThreads(__tstate);
12891 if (PyErr_Occurred()) SWIG_fail;
12892 }
12893 resultobj = SWIG_Py_Void();
12894 return resultobj;
12895 fail:
12896 return NULL;
12897 }
12898
12899
12900 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12901 PyObject *obj;
12902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12903 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12904 return SWIG_Py_Void();
12905 }
12906
12907 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12908 return SWIG_Python_InitShadowInstance(args);
12909 }
12910
12911 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12912 PyObject *resultobj = 0;
12913 wxLogStderr *result = 0 ;
12914
12915 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12916 {
12917 PyThreadState* __tstate = wxPyBeginAllowThreads();
12918 result = (wxLogStderr *)new wxLogStderr();
12919 wxPyEndAllowThreads(__tstate);
12920 if (PyErr_Occurred()) SWIG_fail;
12921 }
12922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12923 return resultobj;
12924 fail:
12925 return NULL;
12926 }
12927
12928
12929 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12930 PyObject *obj;
12931 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12932 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12933 return SWIG_Py_Void();
12934 }
12935
12936 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12937 return SWIG_Python_InitShadowInstance(args);
12938 }
12939
12940 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12941 PyObject *resultobj = 0;
12942 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12943 wxLogTextCtrl *result = 0 ;
12944 void *argp1 = 0 ;
12945 int res1 = 0 ;
12946 PyObject * obj0 = 0 ;
12947 char * kwnames[] = {
12948 (char *) "pTextCtrl", NULL
12949 };
12950
12951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12953 if (!SWIG_IsOK(res1)) {
12954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12955 }
12956 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12957 {
12958 PyThreadState* __tstate = wxPyBeginAllowThreads();
12959 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12960 wxPyEndAllowThreads(__tstate);
12961 if (PyErr_Occurred()) SWIG_fail;
12962 }
12963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12964 return resultobj;
12965 fail:
12966 return NULL;
12967 }
12968
12969
12970 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12971 PyObject *obj;
12972 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12973 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12974 return SWIG_Py_Void();
12975 }
12976
12977 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12978 return SWIG_Python_InitShadowInstance(args);
12979 }
12980
12981 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12982 PyObject *resultobj = 0;
12983 wxLogGui *result = 0 ;
12984
12985 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12986 {
12987 PyThreadState* __tstate = wxPyBeginAllowThreads();
12988 result = (wxLogGui *)new wxLogGui();
12989 wxPyEndAllowThreads(__tstate);
12990 if (PyErr_Occurred()) SWIG_fail;
12991 }
12992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12993 return resultobj;
12994 fail:
12995 return NULL;
12996 }
12997
12998
12999 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13000 PyObject *obj;
13001 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13002 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
13003 return SWIG_Py_Void();
13004 }
13005
13006 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13007 return SWIG_Python_InitShadowInstance(args);
13008 }
13009
13010 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13011 PyObject *resultobj = 0;
13012 wxFrame *arg1 = (wxFrame *) 0 ;
13013 wxString *arg2 = 0 ;
13014 bool arg3 = (bool) true ;
13015 bool arg4 = (bool) true ;
13016 wxLogWindow *result = 0 ;
13017 void *argp1 = 0 ;
13018 int res1 = 0 ;
13019 bool temp2 = false ;
13020 bool val3 ;
13021 int ecode3 = 0 ;
13022 bool val4 ;
13023 int ecode4 = 0 ;
13024 PyObject * obj0 = 0 ;
13025 PyObject * obj1 = 0 ;
13026 PyObject * obj2 = 0 ;
13027 PyObject * obj3 = 0 ;
13028 char * kwnames[] = {
13029 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
13030 };
13031
13032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13034 if (!SWIG_IsOK(res1)) {
13035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
13036 }
13037 arg1 = reinterpret_cast< wxFrame * >(argp1);
13038 {
13039 arg2 = wxString_in_helper(obj1);
13040 if (arg2 == NULL) SWIG_fail;
13041 temp2 = true;
13042 }
13043 if (obj2) {
13044 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13045 if (!SWIG_IsOK(ecode3)) {
13046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13047 }
13048 arg3 = static_cast< bool >(val3);
13049 }
13050 if (obj3) {
13051 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13052 if (!SWIG_IsOK(ecode4)) {
13053 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13054 }
13055 arg4 = static_cast< bool >(val4);
13056 }
13057 {
13058 PyThreadState* __tstate = wxPyBeginAllowThreads();
13059 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13060 wxPyEndAllowThreads(__tstate);
13061 if (PyErr_Occurred()) SWIG_fail;
13062 }
13063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13064 {
13065 if (temp2)
13066 delete arg2;
13067 }
13068 return resultobj;
13069 fail:
13070 {
13071 if (temp2)
13072 delete arg2;
13073 }
13074 return NULL;
13075 }
13076
13077
13078 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13079 PyObject *resultobj = 0;
13080 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13081 bool arg2 = (bool) true ;
13082 void *argp1 = 0 ;
13083 int res1 = 0 ;
13084 bool val2 ;
13085 int ecode2 = 0 ;
13086 PyObject * obj0 = 0 ;
13087 PyObject * obj1 = 0 ;
13088 char * kwnames[] = {
13089 (char *) "self",(char *) "bShow", NULL
13090 };
13091
13092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13094 if (!SWIG_IsOK(res1)) {
13095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13096 }
13097 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13098 if (obj1) {
13099 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13100 if (!SWIG_IsOK(ecode2)) {
13101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13102 }
13103 arg2 = static_cast< bool >(val2);
13104 }
13105 {
13106 PyThreadState* __tstate = wxPyBeginAllowThreads();
13107 (arg1)->Show(arg2);
13108 wxPyEndAllowThreads(__tstate);
13109 if (PyErr_Occurred()) SWIG_fail;
13110 }
13111 resultobj = SWIG_Py_Void();
13112 return resultobj;
13113 fail:
13114 return NULL;
13115 }
13116
13117
13118 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13119 PyObject *resultobj = 0;
13120 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13121 wxFrame *result = 0 ;
13122 void *argp1 = 0 ;
13123 int res1 = 0 ;
13124 PyObject *swig_obj[1] ;
13125
13126 if (!args) SWIG_fail;
13127 swig_obj[0] = args;
13128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13129 if (!SWIG_IsOK(res1)) {
13130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13131 }
13132 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13133 {
13134 PyThreadState* __tstate = wxPyBeginAllowThreads();
13135 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13136 wxPyEndAllowThreads(__tstate);
13137 if (PyErr_Occurred()) SWIG_fail;
13138 }
13139 {
13140 resultobj = wxPyMake_wxObject(result, (bool)0);
13141 }
13142 return resultobj;
13143 fail:
13144 return NULL;
13145 }
13146
13147
13148 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13149 PyObject *resultobj = 0;
13150 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13151 wxLog *result = 0 ;
13152 void *argp1 = 0 ;
13153 int res1 = 0 ;
13154 PyObject *swig_obj[1] ;
13155
13156 if (!args) SWIG_fail;
13157 swig_obj[0] = args;
13158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13159 if (!SWIG_IsOK(res1)) {
13160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13161 }
13162 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13163 {
13164 PyThreadState* __tstate = wxPyBeginAllowThreads();
13165 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13166 wxPyEndAllowThreads(__tstate);
13167 if (PyErr_Occurred()) SWIG_fail;
13168 }
13169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13170 return resultobj;
13171 fail:
13172 return NULL;
13173 }
13174
13175
13176 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13177 PyObject *resultobj = 0;
13178 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13179 bool result;
13180 void *argp1 = 0 ;
13181 int res1 = 0 ;
13182 PyObject *swig_obj[1] ;
13183
13184 if (!args) SWIG_fail;
13185 swig_obj[0] = args;
13186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13187 if (!SWIG_IsOK(res1)) {
13188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13189 }
13190 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13191 {
13192 PyThreadState* __tstate = wxPyBeginAllowThreads();
13193 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13194 wxPyEndAllowThreads(__tstate);
13195 if (PyErr_Occurred()) SWIG_fail;
13196 }
13197 {
13198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13199 }
13200 return resultobj;
13201 fail:
13202 return NULL;
13203 }
13204
13205
13206 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13207 PyObject *resultobj = 0;
13208 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13209 bool arg2 ;
13210 void *argp1 = 0 ;
13211 int res1 = 0 ;
13212 bool val2 ;
13213 int ecode2 = 0 ;
13214 PyObject * obj0 = 0 ;
13215 PyObject * obj1 = 0 ;
13216 char * kwnames[] = {
13217 (char *) "self",(char *) "bDoPass", NULL
13218 };
13219
13220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13222 if (!SWIG_IsOK(res1)) {
13223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13224 }
13225 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13226 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13227 if (!SWIG_IsOK(ecode2)) {
13228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13229 }
13230 arg2 = static_cast< bool >(val2);
13231 {
13232 PyThreadState* __tstate = wxPyBeginAllowThreads();
13233 (arg1)->PassMessages(arg2);
13234 wxPyEndAllowThreads(__tstate);
13235 if (PyErr_Occurred()) SWIG_fail;
13236 }
13237 resultobj = SWIG_Py_Void();
13238 return resultobj;
13239 fail:
13240 return NULL;
13241 }
13242
13243
13244 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13245 PyObject *obj;
13246 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13247 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13248 return SWIG_Py_Void();
13249 }
13250
13251 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13252 return SWIG_Python_InitShadowInstance(args);
13253 }
13254
13255 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13256 PyObject *resultobj = 0;
13257 wxLog *arg1 = (wxLog *) 0 ;
13258 wxLogChain *result = 0 ;
13259 void *argp1 = 0 ;
13260 int res1 = 0 ;
13261 PyObject * obj0 = 0 ;
13262 char * kwnames[] = {
13263 (char *) "logger", NULL
13264 };
13265
13266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13268 if (!SWIG_IsOK(res1)) {
13269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13270 }
13271 arg1 = reinterpret_cast< wxLog * >(argp1);
13272 {
13273 PyThreadState* __tstate = wxPyBeginAllowThreads();
13274 result = (wxLogChain *)new wxLogChain(arg1);
13275 wxPyEndAllowThreads(__tstate);
13276 if (PyErr_Occurred()) SWIG_fail;
13277 }
13278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13279 return resultobj;
13280 fail:
13281 return NULL;
13282 }
13283
13284
13285 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13286 PyObject *resultobj = 0;
13287 wxLogChain *arg1 = (wxLogChain *) 0 ;
13288 wxLog *arg2 = (wxLog *) 0 ;
13289 void *argp1 = 0 ;
13290 int res1 = 0 ;
13291 void *argp2 = 0 ;
13292 int res2 = 0 ;
13293 PyObject * obj0 = 0 ;
13294 PyObject * obj1 = 0 ;
13295 char * kwnames[] = {
13296 (char *) "self",(char *) "logger", NULL
13297 };
13298
13299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13301 if (!SWIG_IsOK(res1)) {
13302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13303 }
13304 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13305 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13306 if (!SWIG_IsOK(res2)) {
13307 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13308 }
13309 arg2 = reinterpret_cast< wxLog * >(argp2);
13310 {
13311 PyThreadState* __tstate = wxPyBeginAllowThreads();
13312 (arg1)->SetLog(arg2);
13313 wxPyEndAllowThreads(__tstate);
13314 if (PyErr_Occurred()) SWIG_fail;
13315 }
13316 resultobj = SWIG_Py_Void();
13317 return resultobj;
13318 fail:
13319 return NULL;
13320 }
13321
13322
13323 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13324 PyObject *resultobj = 0;
13325 wxLogChain *arg1 = (wxLogChain *) 0 ;
13326 bool arg2 ;
13327 void *argp1 = 0 ;
13328 int res1 = 0 ;
13329 bool val2 ;
13330 int ecode2 = 0 ;
13331 PyObject * obj0 = 0 ;
13332 PyObject * obj1 = 0 ;
13333 char * kwnames[] = {
13334 (char *) "self",(char *) "bDoPass", NULL
13335 };
13336
13337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13339 if (!SWIG_IsOK(res1)) {
13340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13341 }
13342 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13343 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13344 if (!SWIG_IsOK(ecode2)) {
13345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13346 }
13347 arg2 = static_cast< bool >(val2);
13348 {
13349 PyThreadState* __tstate = wxPyBeginAllowThreads();
13350 (arg1)->PassMessages(arg2);
13351 wxPyEndAllowThreads(__tstate);
13352 if (PyErr_Occurred()) SWIG_fail;
13353 }
13354 resultobj = SWIG_Py_Void();
13355 return resultobj;
13356 fail:
13357 return NULL;
13358 }
13359
13360
13361 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13362 PyObject *resultobj = 0;
13363 wxLogChain *arg1 = (wxLogChain *) 0 ;
13364 bool result;
13365 void *argp1 = 0 ;
13366 int res1 = 0 ;
13367 PyObject *swig_obj[1] ;
13368
13369 if (!args) SWIG_fail;
13370 swig_obj[0] = args;
13371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13372 if (!SWIG_IsOK(res1)) {
13373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13374 }
13375 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13376 {
13377 PyThreadState* __tstate = wxPyBeginAllowThreads();
13378 result = (bool)(arg1)->IsPassingMessages();
13379 wxPyEndAllowThreads(__tstate);
13380 if (PyErr_Occurred()) SWIG_fail;
13381 }
13382 {
13383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13384 }
13385 return resultobj;
13386 fail:
13387 return NULL;
13388 }
13389
13390
13391 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13392 PyObject *resultobj = 0;
13393 wxLogChain *arg1 = (wxLogChain *) 0 ;
13394 wxLog *result = 0 ;
13395 void *argp1 = 0 ;
13396 int res1 = 0 ;
13397 PyObject *swig_obj[1] ;
13398
13399 if (!args) SWIG_fail;
13400 swig_obj[0] = args;
13401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13402 if (!SWIG_IsOK(res1)) {
13403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13404 }
13405 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13406 {
13407 PyThreadState* __tstate = wxPyBeginAllowThreads();
13408 result = (wxLog *)(arg1)->GetOldLog();
13409 wxPyEndAllowThreads(__tstate);
13410 if (PyErr_Occurred()) SWIG_fail;
13411 }
13412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13413 return resultobj;
13414 fail:
13415 return NULL;
13416 }
13417
13418
13419 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13420 PyObject *obj;
13421 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13422 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13423 return SWIG_Py_Void();
13424 }
13425
13426 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13427 return SWIG_Python_InitShadowInstance(args);
13428 }
13429
13430 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13431 PyObject *resultobj = 0;
13432 wxLogBuffer *result = 0 ;
13433
13434 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13435 {
13436 PyThreadState* __tstate = wxPyBeginAllowThreads();
13437 result = (wxLogBuffer *)new wxLogBuffer();
13438 wxPyEndAllowThreads(__tstate);
13439 if (PyErr_Occurred()) SWIG_fail;
13440 }
13441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13442 return resultobj;
13443 fail:
13444 return NULL;
13445 }
13446
13447
13448 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13449 PyObject *resultobj = 0;
13450 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13451 wxString *result = 0 ;
13452 void *argp1 = 0 ;
13453 int res1 = 0 ;
13454 PyObject *swig_obj[1] ;
13455
13456 if (!args) SWIG_fail;
13457 swig_obj[0] = args;
13458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13459 if (!SWIG_IsOK(res1)) {
13460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13461 }
13462 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13463 {
13464 PyThreadState* __tstate = wxPyBeginAllowThreads();
13465 {
13466 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13467 result = (wxString *) &_result_ref;
13468 }
13469 wxPyEndAllowThreads(__tstate);
13470 if (PyErr_Occurred()) SWIG_fail;
13471 }
13472 {
13473 #if wxUSE_UNICODE
13474 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13475 #else
13476 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13477 #endif
13478 }
13479 return resultobj;
13480 fail:
13481 return NULL;
13482 }
13483
13484
13485 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13486 PyObject *obj;
13487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13488 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13489 return SWIG_Py_Void();
13490 }
13491
13492 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13493 return SWIG_Python_InitShadowInstance(args);
13494 }
13495
13496 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13497 PyObject *resultobj = 0;
13498 unsigned long result;
13499
13500 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13501 {
13502 PyThreadState* __tstate = wxPyBeginAllowThreads();
13503 result = (unsigned long)wxSysErrorCode();
13504 wxPyEndAllowThreads(__tstate);
13505 if (PyErr_Occurred()) SWIG_fail;
13506 }
13507 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13508 return resultobj;
13509 fail:
13510 return NULL;
13511 }
13512
13513
13514 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13515 PyObject *resultobj = 0;
13516 unsigned long arg1 = (unsigned long) 0 ;
13517 wxString result;
13518 unsigned long val1 ;
13519 int ecode1 = 0 ;
13520 PyObject * obj0 = 0 ;
13521 char * kwnames[] = {
13522 (char *) "nErrCode", NULL
13523 };
13524
13525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13526 if (obj0) {
13527 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13528 if (!SWIG_IsOK(ecode1)) {
13529 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13530 }
13531 arg1 = static_cast< unsigned long >(val1);
13532 }
13533 {
13534 PyThreadState* __tstate = wxPyBeginAllowThreads();
13535 result = wxSysErrorMsg(arg1);
13536 wxPyEndAllowThreads(__tstate);
13537 if (PyErr_Occurred()) SWIG_fail;
13538 }
13539 {
13540 #if wxUSE_UNICODE
13541 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13542 #else
13543 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13544 #endif
13545 }
13546 return resultobj;
13547 fail:
13548 return NULL;
13549 }
13550
13551
13552 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13553 PyObject *resultobj = 0;
13554 wxString *arg1 = 0 ;
13555 bool temp1 = false ;
13556 PyObject * obj0 = 0 ;
13557 char * kwnames[] = {
13558 (char *) "msg", NULL
13559 };
13560
13561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13562 {
13563 arg1 = wxString_in_helper(obj0);
13564 if (arg1 == NULL) SWIG_fail;
13565 temp1 = true;
13566 }
13567 {
13568 PyThreadState* __tstate = wxPyBeginAllowThreads();
13569 wxPyLogFatalError((wxString const &)*arg1);
13570 wxPyEndAllowThreads(__tstate);
13571 if (PyErr_Occurred()) SWIG_fail;
13572 }
13573 resultobj = SWIG_Py_Void();
13574 {
13575 if (temp1)
13576 delete arg1;
13577 }
13578 return resultobj;
13579 fail:
13580 {
13581 if (temp1)
13582 delete arg1;
13583 }
13584 return NULL;
13585 }
13586
13587
13588 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13589 PyObject *resultobj = 0;
13590 wxString *arg1 = 0 ;
13591 bool temp1 = false ;
13592 PyObject * obj0 = 0 ;
13593 char * kwnames[] = {
13594 (char *) "msg", NULL
13595 };
13596
13597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13598 {
13599 arg1 = wxString_in_helper(obj0);
13600 if (arg1 == NULL) SWIG_fail;
13601 temp1 = true;
13602 }
13603 {
13604 PyThreadState* __tstate = wxPyBeginAllowThreads();
13605 wxPyLogError((wxString const &)*arg1);
13606 wxPyEndAllowThreads(__tstate);
13607 if (PyErr_Occurred()) SWIG_fail;
13608 }
13609 resultobj = SWIG_Py_Void();
13610 {
13611 if (temp1)
13612 delete arg1;
13613 }
13614 return resultobj;
13615 fail:
13616 {
13617 if (temp1)
13618 delete arg1;
13619 }
13620 return NULL;
13621 }
13622
13623
13624 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13625 PyObject *resultobj = 0;
13626 wxString *arg1 = 0 ;
13627 bool temp1 = false ;
13628 PyObject * obj0 = 0 ;
13629 char * kwnames[] = {
13630 (char *) "msg", NULL
13631 };
13632
13633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13634 {
13635 arg1 = wxString_in_helper(obj0);
13636 if (arg1 == NULL) SWIG_fail;
13637 temp1 = true;
13638 }
13639 {
13640 PyThreadState* __tstate = wxPyBeginAllowThreads();
13641 wxPyLogWarning((wxString const &)*arg1);
13642 wxPyEndAllowThreads(__tstate);
13643 if (PyErr_Occurred()) SWIG_fail;
13644 }
13645 resultobj = SWIG_Py_Void();
13646 {
13647 if (temp1)
13648 delete arg1;
13649 }
13650 return resultobj;
13651 fail:
13652 {
13653 if (temp1)
13654 delete arg1;
13655 }
13656 return NULL;
13657 }
13658
13659
13660 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13661 PyObject *resultobj = 0;
13662 wxString *arg1 = 0 ;
13663 bool temp1 = false ;
13664 PyObject * obj0 = 0 ;
13665 char * kwnames[] = {
13666 (char *) "msg", NULL
13667 };
13668
13669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13670 {
13671 arg1 = wxString_in_helper(obj0);
13672 if (arg1 == NULL) SWIG_fail;
13673 temp1 = true;
13674 }
13675 {
13676 PyThreadState* __tstate = wxPyBeginAllowThreads();
13677 wxPyLogMessage((wxString const &)*arg1);
13678 wxPyEndAllowThreads(__tstate);
13679 if (PyErr_Occurred()) SWIG_fail;
13680 }
13681 resultobj = SWIG_Py_Void();
13682 {
13683 if (temp1)
13684 delete arg1;
13685 }
13686 return resultobj;
13687 fail:
13688 {
13689 if (temp1)
13690 delete arg1;
13691 }
13692 return NULL;
13693 }
13694
13695
13696 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13697 PyObject *resultobj = 0;
13698 wxString *arg1 = 0 ;
13699 bool temp1 = false ;
13700 PyObject * obj0 = 0 ;
13701 char * kwnames[] = {
13702 (char *) "msg", NULL
13703 };
13704
13705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13706 {
13707 arg1 = wxString_in_helper(obj0);
13708 if (arg1 == NULL) SWIG_fail;
13709 temp1 = true;
13710 }
13711 {
13712 PyThreadState* __tstate = wxPyBeginAllowThreads();
13713 wxPyLogInfo((wxString const &)*arg1);
13714 wxPyEndAllowThreads(__tstate);
13715 if (PyErr_Occurred()) SWIG_fail;
13716 }
13717 resultobj = SWIG_Py_Void();
13718 {
13719 if (temp1)
13720 delete arg1;
13721 }
13722 return resultobj;
13723 fail:
13724 {
13725 if (temp1)
13726 delete arg1;
13727 }
13728 return NULL;
13729 }
13730
13731
13732 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13733 PyObject *resultobj = 0;
13734 wxString *arg1 = 0 ;
13735 bool temp1 = false ;
13736 PyObject * obj0 = 0 ;
13737 char * kwnames[] = {
13738 (char *) "msg", NULL
13739 };
13740
13741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13742 {
13743 arg1 = wxString_in_helper(obj0);
13744 if (arg1 == NULL) SWIG_fail;
13745 temp1 = true;
13746 }
13747 {
13748 PyThreadState* __tstate = wxPyBeginAllowThreads();
13749 wxPyLogDebug((wxString const &)*arg1);
13750 wxPyEndAllowThreads(__tstate);
13751 if (PyErr_Occurred()) SWIG_fail;
13752 }
13753 resultobj = SWIG_Py_Void();
13754 {
13755 if (temp1)
13756 delete arg1;
13757 }
13758 return resultobj;
13759 fail:
13760 {
13761 if (temp1)
13762 delete arg1;
13763 }
13764 return NULL;
13765 }
13766
13767
13768 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13769 PyObject *resultobj = 0;
13770 wxString *arg1 = 0 ;
13771 bool temp1 = false ;
13772 PyObject * obj0 = 0 ;
13773 char * kwnames[] = {
13774 (char *) "msg", NULL
13775 };
13776
13777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13778 {
13779 arg1 = wxString_in_helper(obj0);
13780 if (arg1 == NULL) SWIG_fail;
13781 temp1 = true;
13782 }
13783 {
13784 PyThreadState* __tstate = wxPyBeginAllowThreads();
13785 wxPyLogVerbose((wxString const &)*arg1);
13786 wxPyEndAllowThreads(__tstate);
13787 if (PyErr_Occurred()) SWIG_fail;
13788 }
13789 resultobj = SWIG_Py_Void();
13790 {
13791 if (temp1)
13792 delete arg1;
13793 }
13794 return resultobj;
13795 fail:
13796 {
13797 if (temp1)
13798 delete arg1;
13799 }
13800 return NULL;
13801 }
13802
13803
13804 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13805 PyObject *resultobj = 0;
13806 wxString *arg1 = 0 ;
13807 bool temp1 = false ;
13808 PyObject * obj0 = 0 ;
13809 char * kwnames[] = {
13810 (char *) "msg", NULL
13811 };
13812
13813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13814 {
13815 arg1 = wxString_in_helper(obj0);
13816 if (arg1 == NULL) SWIG_fail;
13817 temp1 = true;
13818 }
13819 {
13820 PyThreadState* __tstate = wxPyBeginAllowThreads();
13821 wxPyLogStatus((wxString const &)*arg1);
13822 wxPyEndAllowThreads(__tstate);
13823 if (PyErr_Occurred()) SWIG_fail;
13824 }
13825 resultobj = SWIG_Py_Void();
13826 {
13827 if (temp1)
13828 delete arg1;
13829 }
13830 return resultobj;
13831 fail:
13832 {
13833 if (temp1)
13834 delete arg1;
13835 }
13836 return NULL;
13837 }
13838
13839
13840 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13841 PyObject *resultobj = 0;
13842 wxFrame *arg1 = (wxFrame *) 0 ;
13843 wxString *arg2 = 0 ;
13844 void *argp1 = 0 ;
13845 int res1 = 0 ;
13846 bool temp2 = false ;
13847 PyObject * obj0 = 0 ;
13848 PyObject * obj1 = 0 ;
13849 char * kwnames[] = {
13850 (char *) "pFrame",(char *) "msg", NULL
13851 };
13852
13853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13855 if (!SWIG_IsOK(res1)) {
13856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13857 }
13858 arg1 = reinterpret_cast< wxFrame * >(argp1);
13859 {
13860 arg2 = wxString_in_helper(obj1);
13861 if (arg2 == NULL) SWIG_fail;
13862 temp2 = true;
13863 }
13864 {
13865 PyThreadState* __tstate = wxPyBeginAllowThreads();
13866 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13867 wxPyEndAllowThreads(__tstate);
13868 if (PyErr_Occurred()) SWIG_fail;
13869 }
13870 resultobj = SWIG_Py_Void();
13871 {
13872 if (temp2)
13873 delete arg2;
13874 }
13875 return resultobj;
13876 fail:
13877 {
13878 if (temp2)
13879 delete arg2;
13880 }
13881 return NULL;
13882 }
13883
13884
13885 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13886 PyObject *resultobj = 0;
13887 wxString *arg1 = 0 ;
13888 bool temp1 = false ;
13889 PyObject * obj0 = 0 ;
13890 char * kwnames[] = {
13891 (char *) "msg", NULL
13892 };
13893
13894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13895 {
13896 arg1 = wxString_in_helper(obj0);
13897 if (arg1 == NULL) SWIG_fail;
13898 temp1 = true;
13899 }
13900 {
13901 PyThreadState* __tstate = wxPyBeginAllowThreads();
13902 wxPyLogSysError((wxString const &)*arg1);
13903 wxPyEndAllowThreads(__tstate);
13904 if (PyErr_Occurred()) SWIG_fail;
13905 }
13906 resultobj = SWIG_Py_Void();
13907 {
13908 if (temp1)
13909 delete arg1;
13910 }
13911 return resultobj;
13912 fail:
13913 {
13914 if (temp1)
13915 delete arg1;
13916 }
13917 return NULL;
13918 }
13919
13920
13921 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13922 PyObject *resultobj = 0;
13923 unsigned long arg1 ;
13924 wxString *arg2 = 0 ;
13925 unsigned long val1 ;
13926 int ecode1 = 0 ;
13927 bool temp2 = false ;
13928 PyObject * obj0 = 0 ;
13929 PyObject * obj1 = 0 ;
13930 char * kwnames[] = {
13931 (char *) "level",(char *) "msg", NULL
13932 };
13933
13934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13935 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13936 if (!SWIG_IsOK(ecode1)) {
13937 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13938 }
13939 arg1 = static_cast< unsigned long >(val1);
13940 {
13941 arg2 = wxString_in_helper(obj1);
13942 if (arg2 == NULL) SWIG_fail;
13943 temp2 = true;
13944 }
13945 {
13946 PyThreadState* __tstate = wxPyBeginAllowThreads();
13947 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13948 wxPyEndAllowThreads(__tstate);
13949 if (PyErr_Occurred()) SWIG_fail;
13950 }
13951 resultobj = SWIG_Py_Void();
13952 {
13953 if (temp2)
13954 delete arg2;
13955 }
13956 return resultobj;
13957 fail:
13958 {
13959 if (temp2)
13960 delete arg2;
13961 }
13962 return NULL;
13963 }
13964
13965
13966 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13967 PyObject *resultobj = 0;
13968 unsigned long arg1 ;
13969 wxString *arg2 = 0 ;
13970 unsigned long val1 ;
13971 int ecode1 = 0 ;
13972 bool temp2 = false ;
13973
13974 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13975 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13976 if (!SWIG_IsOK(ecode1)) {
13977 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13978 }
13979 arg1 = static_cast< unsigned long >(val1);
13980 {
13981 arg2 = wxString_in_helper(swig_obj[1]);
13982 if (arg2 == NULL) SWIG_fail;
13983 temp2 = true;
13984 }
13985 {
13986 PyThreadState* __tstate = wxPyBeginAllowThreads();
13987 wxPyLogTrace(arg1,(wxString const &)*arg2);
13988 wxPyEndAllowThreads(__tstate);
13989 if (PyErr_Occurred()) SWIG_fail;
13990 }
13991 resultobj = SWIG_Py_Void();
13992 {
13993 if (temp2)
13994 delete arg2;
13995 }
13996 return resultobj;
13997 fail:
13998 {
13999 if (temp2)
14000 delete arg2;
14001 }
14002 return NULL;
14003 }
14004
14005
14006 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
14007 PyObject *resultobj = 0;
14008 wxString *arg1 = 0 ;
14009 wxString *arg2 = 0 ;
14010 bool temp1 = false ;
14011 bool temp2 = false ;
14012
14013 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
14014 {
14015 arg1 = wxString_in_helper(swig_obj[0]);
14016 if (arg1 == NULL) SWIG_fail;
14017 temp1 = true;
14018 }
14019 {
14020 arg2 = wxString_in_helper(swig_obj[1]);
14021 if (arg2 == NULL) SWIG_fail;
14022 temp2 = true;
14023 }
14024 {
14025 PyThreadState* __tstate = wxPyBeginAllowThreads();
14026 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
14027 wxPyEndAllowThreads(__tstate);
14028 if (PyErr_Occurred()) SWIG_fail;
14029 }
14030 resultobj = SWIG_Py_Void();
14031 {
14032 if (temp1)
14033 delete arg1;
14034 }
14035 {
14036 if (temp2)
14037 delete arg2;
14038 }
14039 return resultobj;
14040 fail:
14041 {
14042 if (temp1)
14043 delete arg1;
14044 }
14045 {
14046 if (temp2)
14047 delete arg2;
14048 }
14049 return NULL;
14050 }
14051
14052
14053 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14054 int argc;
14055 PyObject *argv[3];
14056
14057 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14058 --argc;
14059 if (argc == 2) {
14060 int _v = 0;
14061 {
14062 {
14063 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14064 }
14065 }
14066 if (!_v) goto check_1;
14067 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14068 }
14069 check_1:
14070
14071 if (argc == 2) {
14072 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14073 }
14074
14075 fail:
14076 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14077 return NULL;
14078 }
14079
14080
14081 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14082 PyObject *resultobj = 0;
14083 wxString *arg1 = 0 ;
14084 wxString *arg2 = 0 ;
14085 bool temp1 = false ;
14086 bool temp2 = false ;
14087 PyObject * obj0 = 0 ;
14088 PyObject * obj1 = 0 ;
14089 char * kwnames[] = {
14090 (char *) "title",(char *) "text", NULL
14091 };
14092
14093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14094 {
14095 arg1 = wxString_in_helper(obj0);
14096 if (arg1 == NULL) SWIG_fail;
14097 temp1 = true;
14098 }
14099 {
14100 arg2 = wxString_in_helper(obj1);
14101 if (arg2 == NULL) SWIG_fail;
14102 temp2 = true;
14103 }
14104 {
14105 PyThreadState* __tstate = wxPyBeginAllowThreads();
14106 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14107 wxPyEndAllowThreads(__tstate);
14108 if (PyErr_Occurred()) SWIG_fail;
14109 }
14110 resultobj = SWIG_Py_Void();
14111 {
14112 if (temp1)
14113 delete arg1;
14114 }
14115 {
14116 if (temp2)
14117 delete arg2;
14118 }
14119 return resultobj;
14120 fail:
14121 {
14122 if (temp1)
14123 delete arg1;
14124 }
14125 {
14126 if (temp2)
14127 delete arg2;
14128 }
14129 return NULL;
14130 }
14131
14132
14133 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14134 PyObject *resultobj = 0;
14135 wxLogNull *result = 0 ;
14136
14137 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14138 {
14139 PyThreadState* __tstate = wxPyBeginAllowThreads();
14140 result = (wxLogNull *)new wxLogNull();
14141 wxPyEndAllowThreads(__tstate);
14142 if (PyErr_Occurred()) SWIG_fail;
14143 }
14144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14145 return resultobj;
14146 fail:
14147 return NULL;
14148 }
14149
14150
14151 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14152 PyObject *resultobj = 0;
14153 wxLogNull *arg1 = (wxLogNull *) 0 ;
14154 void *argp1 = 0 ;
14155 int res1 = 0 ;
14156 PyObject *swig_obj[1] ;
14157
14158 if (!args) SWIG_fail;
14159 swig_obj[0] = args;
14160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14161 if (!SWIG_IsOK(res1)) {
14162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14163 }
14164 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14165 {
14166 PyThreadState* __tstate = wxPyBeginAllowThreads();
14167 delete arg1;
14168
14169 wxPyEndAllowThreads(__tstate);
14170 if (PyErr_Occurred()) SWIG_fail;
14171 }
14172 resultobj = SWIG_Py_Void();
14173 return resultobj;
14174 fail:
14175 return NULL;
14176 }
14177
14178
14179 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14180 PyObject *obj;
14181 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14182 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14183 return SWIG_Py_Void();
14184 }
14185
14186 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14187 return SWIG_Python_InitShadowInstance(args);
14188 }
14189
14190 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14191 PyObject *resultobj = 0;
14192 wxPyLog *result = 0 ;
14193
14194 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14195 {
14196 PyThreadState* __tstate = wxPyBeginAllowThreads();
14197 result = (wxPyLog *)new wxPyLog();
14198 wxPyEndAllowThreads(__tstate);
14199 if (PyErr_Occurred()) SWIG_fail;
14200 }
14201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14202 return resultobj;
14203 fail:
14204 return NULL;
14205 }
14206
14207
14208 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14209 PyObject *resultobj = 0;
14210 wxPyLog *arg1 = (wxPyLog *) 0 ;
14211 PyObject *arg2 = (PyObject *) 0 ;
14212 PyObject *arg3 = (PyObject *) 0 ;
14213 void *argp1 = 0 ;
14214 int res1 = 0 ;
14215 PyObject * obj0 = 0 ;
14216 PyObject * obj1 = 0 ;
14217 PyObject * obj2 = 0 ;
14218 char * kwnames[] = {
14219 (char *) "self",(char *) "self",(char *) "_class", NULL
14220 };
14221
14222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14224 if (!SWIG_IsOK(res1)) {
14225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14226 }
14227 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14228 arg2 = obj1;
14229 arg3 = obj2;
14230 {
14231 PyThreadState* __tstate = wxPyBeginAllowThreads();
14232 (arg1)->_setCallbackInfo(arg2,arg3);
14233 wxPyEndAllowThreads(__tstate);
14234 if (PyErr_Occurred()) SWIG_fail;
14235 }
14236 resultobj = SWIG_Py_Void();
14237 return resultobj;
14238 fail:
14239 return NULL;
14240 }
14241
14242
14243 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14244 PyObject *obj;
14245 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14246 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14247 return SWIG_Py_Void();
14248 }
14249
14250 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14251 return SWIG_Python_InitShadowInstance(args);
14252 }
14253
14254 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14255 PyObject *resultobj = 0;
14256 int arg1 ;
14257 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14258 int arg3 = (int) wxKILL_NOCHILDREN ;
14259 wxKillError result;
14260 int val1 ;
14261 int ecode1 = 0 ;
14262 int val2 ;
14263 int ecode2 = 0 ;
14264 int val3 ;
14265 int ecode3 = 0 ;
14266 PyObject * obj0 = 0 ;
14267 PyObject * obj1 = 0 ;
14268 PyObject * obj2 = 0 ;
14269 char * kwnames[] = {
14270 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14271 };
14272
14273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14274 ecode1 = SWIG_AsVal_int(obj0, &val1);
14275 if (!SWIG_IsOK(ecode1)) {
14276 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14277 }
14278 arg1 = static_cast< int >(val1);
14279 if (obj1) {
14280 ecode2 = SWIG_AsVal_int(obj1, &val2);
14281 if (!SWIG_IsOK(ecode2)) {
14282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14283 }
14284 arg2 = static_cast< wxSignal >(val2);
14285 }
14286 if (obj2) {
14287 ecode3 = SWIG_AsVal_int(obj2, &val3);
14288 if (!SWIG_IsOK(ecode3)) {
14289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14290 }
14291 arg3 = static_cast< int >(val3);
14292 }
14293 {
14294 PyThreadState* __tstate = wxPyBeginAllowThreads();
14295 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14296 wxPyEndAllowThreads(__tstate);
14297 if (PyErr_Occurred()) SWIG_fail;
14298 }
14299 resultobj = SWIG_From_int(static_cast< int >(result));
14300 return resultobj;
14301 fail:
14302 return NULL;
14303 }
14304
14305
14306 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14307 PyObject *resultobj = 0;
14308 int arg1 ;
14309 bool result;
14310 int val1 ;
14311 int ecode1 = 0 ;
14312 PyObject * obj0 = 0 ;
14313 char * kwnames[] = {
14314 (char *) "pid", NULL
14315 };
14316
14317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14318 ecode1 = SWIG_AsVal_int(obj0, &val1);
14319 if (!SWIG_IsOK(ecode1)) {
14320 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14321 }
14322 arg1 = static_cast< int >(val1);
14323 {
14324 PyThreadState* __tstate = wxPyBeginAllowThreads();
14325 result = (bool)wxPyProcess::Exists(arg1);
14326 wxPyEndAllowThreads(__tstate);
14327 if (PyErr_Occurred()) SWIG_fail;
14328 }
14329 {
14330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14331 }
14332 return resultobj;
14333 fail:
14334 return NULL;
14335 }
14336
14337
14338 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14339 PyObject *resultobj = 0;
14340 wxString *arg1 = 0 ;
14341 int arg2 = (int) wxEXEC_ASYNC ;
14342 wxPyProcess *result = 0 ;
14343 bool temp1 = false ;
14344 int val2 ;
14345 int ecode2 = 0 ;
14346 PyObject * obj0 = 0 ;
14347 PyObject * obj1 = 0 ;
14348 char * kwnames[] = {
14349 (char *) "cmd",(char *) "flags", NULL
14350 };
14351
14352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14353 {
14354 arg1 = wxString_in_helper(obj0);
14355 if (arg1 == NULL) SWIG_fail;
14356 temp1 = true;
14357 }
14358 if (obj1) {
14359 ecode2 = SWIG_AsVal_int(obj1, &val2);
14360 if (!SWIG_IsOK(ecode2)) {
14361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14362 }
14363 arg2 = static_cast< int >(val2);
14364 }
14365 {
14366 PyThreadState* __tstate = wxPyBeginAllowThreads();
14367 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14368 wxPyEndAllowThreads(__tstate);
14369 if (PyErr_Occurred()) SWIG_fail;
14370 }
14371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14372 {
14373 if (temp1)
14374 delete arg1;
14375 }
14376 return resultobj;
14377 fail:
14378 {
14379 if (temp1)
14380 delete arg1;
14381 }
14382 return NULL;
14383 }
14384
14385
14386 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14387 PyObject *resultobj = 0;
14388 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14389 int arg2 = (int) -1 ;
14390 wxPyProcess *result = 0 ;
14391 void *argp1 = 0 ;
14392 int res1 = 0 ;
14393 int val2 ;
14394 int ecode2 = 0 ;
14395 PyObject * obj0 = 0 ;
14396 PyObject * obj1 = 0 ;
14397 char * kwnames[] = {
14398 (char *) "parent",(char *) "id", NULL
14399 };
14400
14401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14402 if (obj0) {
14403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14404 if (!SWIG_IsOK(res1)) {
14405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14406 }
14407 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14408 }
14409 if (obj1) {
14410 ecode2 = SWIG_AsVal_int(obj1, &val2);
14411 if (!SWIG_IsOK(ecode2)) {
14412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14413 }
14414 arg2 = static_cast< int >(val2);
14415 }
14416 {
14417 PyThreadState* __tstate = wxPyBeginAllowThreads();
14418 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14419 wxPyEndAllowThreads(__tstate);
14420 if (PyErr_Occurred()) SWIG_fail;
14421 }
14422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14423 return resultobj;
14424 fail:
14425 return NULL;
14426 }
14427
14428
14429 SWIGINTERN PyObject *_wrap_delete_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14430 PyObject *resultobj = 0;
14431 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14432 void *argp1 = 0 ;
14433 int res1 = 0 ;
14434 PyObject *swig_obj[1] ;
14435
14436 if (!args) SWIG_fail;
14437 swig_obj[0] = args;
14438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, SWIG_POINTER_DISOWN | 0 );
14439 if (!SWIG_IsOK(res1)) {
14440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Process" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14441 }
14442 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14443 {
14444 PyThreadState* __tstate = wxPyBeginAllowThreads();
14445 delete arg1;
14446
14447 wxPyEndAllowThreads(__tstate);
14448 if (PyErr_Occurred()) SWIG_fail;
14449 }
14450 resultobj = SWIG_Py_Void();
14451 return resultobj;
14452 fail:
14453 return NULL;
14454 }
14455
14456
14457 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14458 PyObject *resultobj = 0;
14459 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14460 PyObject *arg2 = (PyObject *) 0 ;
14461 PyObject *arg3 = (PyObject *) 0 ;
14462 void *argp1 = 0 ;
14463 int res1 = 0 ;
14464 PyObject * obj0 = 0 ;
14465 PyObject * obj1 = 0 ;
14466 PyObject * obj2 = 0 ;
14467 char * kwnames[] = {
14468 (char *) "self",(char *) "self",(char *) "_class", NULL
14469 };
14470
14471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14473 if (!SWIG_IsOK(res1)) {
14474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14475 }
14476 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14477 arg2 = obj1;
14478 arg3 = obj2;
14479 {
14480 PyThreadState* __tstate = wxPyBeginAllowThreads();
14481 (arg1)->_setCallbackInfo(arg2,arg3);
14482 wxPyEndAllowThreads(__tstate);
14483 if (PyErr_Occurred()) SWIG_fail;
14484 }
14485 resultobj = SWIG_Py_Void();
14486 return resultobj;
14487 fail:
14488 return NULL;
14489 }
14490
14491
14492 SWIGINTERN PyObject *_wrap_Process_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14493 PyObject *resultobj = 0;
14494 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14495 long result;
14496 void *argp1 = 0 ;
14497 int res1 = 0 ;
14498 PyObject *swig_obj[1] ;
14499
14500 if (!args) SWIG_fail;
14501 swig_obj[0] = args;
14502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14503 if (!SWIG_IsOK(res1)) {
14504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetPid" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14505 }
14506 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14507 {
14508 PyThreadState* __tstate = wxPyBeginAllowThreads();
14509 result = (long)((wxPyProcess const *)arg1)->GetPid();
14510 wxPyEndAllowThreads(__tstate);
14511 if (PyErr_Occurred()) SWIG_fail;
14512 }
14513 resultobj = SWIG_From_long(static_cast< long >(result));
14514 return resultobj;
14515 fail:
14516 return NULL;
14517 }
14518
14519
14520 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14521 PyObject *resultobj = 0;
14522 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14523 int arg2 ;
14524 int arg3 ;
14525 void *argp1 = 0 ;
14526 int res1 = 0 ;
14527 int val2 ;
14528 int ecode2 = 0 ;
14529 int val3 ;
14530 int ecode3 = 0 ;
14531 PyObject * obj0 = 0 ;
14532 PyObject * obj1 = 0 ;
14533 PyObject * obj2 = 0 ;
14534 char * kwnames[] = {
14535 (char *) "self",(char *) "pid",(char *) "status", NULL
14536 };
14537
14538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14540 if (!SWIG_IsOK(res1)) {
14541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14542 }
14543 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14544 ecode2 = SWIG_AsVal_int(obj1, &val2);
14545 if (!SWIG_IsOK(ecode2)) {
14546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14547 }
14548 arg2 = static_cast< int >(val2);
14549 ecode3 = SWIG_AsVal_int(obj2, &val3);
14550 if (!SWIG_IsOK(ecode3)) {
14551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14552 }
14553 arg3 = static_cast< int >(val3);
14554 {
14555 PyThreadState* __tstate = wxPyBeginAllowThreads();
14556 (arg1)->OnTerminate(arg2,arg3);
14557 wxPyEndAllowThreads(__tstate);
14558 if (PyErr_Occurred()) SWIG_fail;
14559 }
14560 resultobj = SWIG_Py_Void();
14561 return resultobj;
14562 fail:
14563 return NULL;
14564 }
14565
14566
14567 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14568 PyObject *resultobj = 0;
14569 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14570 void *argp1 = 0 ;
14571 int res1 = 0 ;
14572 PyObject *swig_obj[1] ;
14573
14574 if (!args) SWIG_fail;
14575 swig_obj[0] = args;
14576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14577 if (!SWIG_IsOK(res1)) {
14578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14579 }
14580 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14581 {
14582 PyThreadState* __tstate = wxPyBeginAllowThreads();
14583 (arg1)->Redirect();
14584 wxPyEndAllowThreads(__tstate);
14585 if (PyErr_Occurred()) SWIG_fail;
14586 }
14587 resultobj = SWIG_Py_Void();
14588 return resultobj;
14589 fail:
14590 return NULL;
14591 }
14592
14593
14594 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14595 PyObject *resultobj = 0;
14596 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14597 bool result;
14598 void *argp1 = 0 ;
14599 int res1 = 0 ;
14600 PyObject *swig_obj[1] ;
14601
14602 if (!args) SWIG_fail;
14603 swig_obj[0] = args;
14604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14605 if (!SWIG_IsOK(res1)) {
14606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14607 }
14608 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14609 {
14610 PyThreadState* __tstate = wxPyBeginAllowThreads();
14611 result = (bool)(arg1)->IsRedirected();
14612 wxPyEndAllowThreads(__tstate);
14613 if (PyErr_Occurred()) SWIG_fail;
14614 }
14615 {
14616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14617 }
14618 return resultobj;
14619 fail:
14620 return NULL;
14621 }
14622
14623
14624 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14625 PyObject *resultobj = 0;
14626 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14627 void *argp1 = 0 ;
14628 int res1 = 0 ;
14629 PyObject *swig_obj[1] ;
14630
14631 if (!args) SWIG_fail;
14632 swig_obj[0] = args;
14633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14634 if (!SWIG_IsOK(res1)) {
14635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14636 }
14637 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14638 {
14639 PyThreadState* __tstate = wxPyBeginAllowThreads();
14640 (arg1)->Detach();
14641 wxPyEndAllowThreads(__tstate);
14642 if (PyErr_Occurred()) SWIG_fail;
14643 }
14644 resultobj = SWIG_Py_Void();
14645 return resultobj;
14646 fail:
14647 return NULL;
14648 }
14649
14650
14651 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14652 PyObject *resultobj = 0;
14653 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14654 wxInputStream *result = 0 ;
14655 void *argp1 = 0 ;
14656 int res1 = 0 ;
14657 PyObject *swig_obj[1] ;
14658
14659 if (!args) SWIG_fail;
14660 swig_obj[0] = args;
14661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14662 if (!SWIG_IsOK(res1)) {
14663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14664 }
14665 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14666 {
14667 PyThreadState* __tstate = wxPyBeginAllowThreads();
14668 result = (wxInputStream *)(arg1)->GetInputStream();
14669 wxPyEndAllowThreads(__tstate);
14670 if (PyErr_Occurred()) SWIG_fail;
14671 }
14672 {
14673 wxPyInputStream * _ptr = NULL;
14674
14675 if (result) {
14676 _ptr = new wxPyInputStream(result);
14677 }
14678 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14679 }
14680 return resultobj;
14681 fail:
14682 return NULL;
14683 }
14684
14685
14686 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14687 PyObject *resultobj = 0;
14688 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14689 wxInputStream *result = 0 ;
14690 void *argp1 = 0 ;
14691 int res1 = 0 ;
14692 PyObject *swig_obj[1] ;
14693
14694 if (!args) SWIG_fail;
14695 swig_obj[0] = args;
14696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14697 if (!SWIG_IsOK(res1)) {
14698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14699 }
14700 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14701 {
14702 PyThreadState* __tstate = wxPyBeginAllowThreads();
14703 result = (wxInputStream *)(arg1)->GetErrorStream();
14704 wxPyEndAllowThreads(__tstate);
14705 if (PyErr_Occurred()) SWIG_fail;
14706 }
14707 {
14708 wxPyInputStream * _ptr = NULL;
14709
14710 if (result) {
14711 _ptr = new wxPyInputStream(result);
14712 }
14713 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14714 }
14715 return resultobj;
14716 fail:
14717 return NULL;
14718 }
14719
14720
14721 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14722 PyObject *resultobj = 0;
14723 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14724 wxOutputStream *result = 0 ;
14725 void *argp1 = 0 ;
14726 int res1 = 0 ;
14727 PyObject *swig_obj[1] ;
14728
14729 if (!args) SWIG_fail;
14730 swig_obj[0] = args;
14731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14732 if (!SWIG_IsOK(res1)) {
14733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14734 }
14735 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14736 {
14737 PyThreadState* __tstate = wxPyBeginAllowThreads();
14738 result = (wxOutputStream *)(arg1)->GetOutputStream();
14739 wxPyEndAllowThreads(__tstate);
14740 if (PyErr_Occurred()) SWIG_fail;
14741 }
14742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14743 return resultobj;
14744 fail:
14745 return NULL;
14746 }
14747
14748
14749 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14750 PyObject *resultobj = 0;
14751 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14752 void *argp1 = 0 ;
14753 int res1 = 0 ;
14754 PyObject *swig_obj[1] ;
14755
14756 if (!args) SWIG_fail;
14757 swig_obj[0] = args;
14758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14759 if (!SWIG_IsOK(res1)) {
14760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14761 }
14762 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14763 {
14764 PyThreadState* __tstate = wxPyBeginAllowThreads();
14765 (arg1)->CloseOutput();
14766 wxPyEndAllowThreads(__tstate);
14767 if (PyErr_Occurred()) SWIG_fail;
14768 }
14769 resultobj = SWIG_Py_Void();
14770 return resultobj;
14771 fail:
14772 return NULL;
14773 }
14774
14775
14776 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14777 PyObject *resultobj = 0;
14778 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14779 bool result;
14780 void *argp1 = 0 ;
14781 int res1 = 0 ;
14782 PyObject *swig_obj[1] ;
14783
14784 if (!args) SWIG_fail;
14785 swig_obj[0] = args;
14786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14787 if (!SWIG_IsOK(res1)) {
14788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14789 }
14790 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14791 {
14792 PyThreadState* __tstate = wxPyBeginAllowThreads();
14793 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14794 wxPyEndAllowThreads(__tstate);
14795 if (PyErr_Occurred()) SWIG_fail;
14796 }
14797 {
14798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14799 }
14800 return resultobj;
14801 fail:
14802 return NULL;
14803 }
14804
14805
14806 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14807 PyObject *resultobj = 0;
14808 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14809 bool result;
14810 void *argp1 = 0 ;
14811 int res1 = 0 ;
14812 PyObject *swig_obj[1] ;
14813
14814 if (!args) SWIG_fail;
14815 swig_obj[0] = args;
14816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14817 if (!SWIG_IsOK(res1)) {
14818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14819 }
14820 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14821 {
14822 PyThreadState* __tstate = wxPyBeginAllowThreads();
14823 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14824 wxPyEndAllowThreads(__tstate);
14825 if (PyErr_Occurred()) SWIG_fail;
14826 }
14827 {
14828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14829 }
14830 return resultobj;
14831 fail:
14832 return NULL;
14833 }
14834
14835
14836 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14837 PyObject *resultobj = 0;
14838 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14839 bool result;
14840 void *argp1 = 0 ;
14841 int res1 = 0 ;
14842 PyObject *swig_obj[1] ;
14843
14844 if (!args) SWIG_fail;
14845 swig_obj[0] = args;
14846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14847 if (!SWIG_IsOK(res1)) {
14848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14849 }
14850 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14851 {
14852 PyThreadState* __tstate = wxPyBeginAllowThreads();
14853 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14854 wxPyEndAllowThreads(__tstate);
14855 if (PyErr_Occurred()) SWIG_fail;
14856 }
14857 {
14858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14859 }
14860 return resultobj;
14861 fail:
14862 return NULL;
14863 }
14864
14865
14866 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14867 PyObject *obj;
14868 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14869 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14870 return SWIG_Py_Void();
14871 }
14872
14873 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14874 return SWIG_Python_InitShadowInstance(args);
14875 }
14876
14877 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14878 PyObject *resultobj = 0;
14879 int arg1 = (int) 0 ;
14880 int arg2 = (int) 0 ;
14881 int arg3 = (int) 0 ;
14882 wxProcessEvent *result = 0 ;
14883 int val1 ;
14884 int ecode1 = 0 ;
14885 int val2 ;
14886 int ecode2 = 0 ;
14887 int val3 ;
14888 int ecode3 = 0 ;
14889 PyObject * obj0 = 0 ;
14890 PyObject * obj1 = 0 ;
14891 PyObject * obj2 = 0 ;
14892 char * kwnames[] = {
14893 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14894 };
14895
14896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14897 if (obj0) {
14898 ecode1 = SWIG_AsVal_int(obj0, &val1);
14899 if (!SWIG_IsOK(ecode1)) {
14900 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14901 }
14902 arg1 = static_cast< int >(val1);
14903 }
14904 if (obj1) {
14905 ecode2 = SWIG_AsVal_int(obj1, &val2);
14906 if (!SWIG_IsOK(ecode2)) {
14907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14908 }
14909 arg2 = static_cast< int >(val2);
14910 }
14911 if (obj2) {
14912 ecode3 = SWIG_AsVal_int(obj2, &val3);
14913 if (!SWIG_IsOK(ecode3)) {
14914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14915 }
14916 arg3 = static_cast< int >(val3);
14917 }
14918 {
14919 PyThreadState* __tstate = wxPyBeginAllowThreads();
14920 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14921 wxPyEndAllowThreads(__tstate);
14922 if (PyErr_Occurred()) SWIG_fail;
14923 }
14924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14925 return resultobj;
14926 fail:
14927 return NULL;
14928 }
14929
14930
14931 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14932 PyObject *resultobj = 0;
14933 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14934 int result;
14935 void *argp1 = 0 ;
14936 int res1 = 0 ;
14937 PyObject *swig_obj[1] ;
14938
14939 if (!args) SWIG_fail;
14940 swig_obj[0] = args;
14941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14942 if (!SWIG_IsOK(res1)) {
14943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14944 }
14945 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14946 {
14947 PyThreadState* __tstate = wxPyBeginAllowThreads();
14948 result = (int)(arg1)->GetPid();
14949 wxPyEndAllowThreads(__tstate);
14950 if (PyErr_Occurred()) SWIG_fail;
14951 }
14952 resultobj = SWIG_From_int(static_cast< int >(result));
14953 return resultobj;
14954 fail:
14955 return NULL;
14956 }
14957
14958
14959 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14960 PyObject *resultobj = 0;
14961 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14962 int result;
14963 void *argp1 = 0 ;
14964 int res1 = 0 ;
14965 PyObject *swig_obj[1] ;
14966
14967 if (!args) SWIG_fail;
14968 swig_obj[0] = args;
14969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14970 if (!SWIG_IsOK(res1)) {
14971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14972 }
14973 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14974 {
14975 PyThreadState* __tstate = wxPyBeginAllowThreads();
14976 result = (int)(arg1)->GetExitCode();
14977 wxPyEndAllowThreads(__tstate);
14978 if (PyErr_Occurred()) SWIG_fail;
14979 }
14980 resultobj = SWIG_From_int(static_cast< int >(result));
14981 return resultobj;
14982 fail:
14983 return NULL;
14984 }
14985
14986
14987 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14988 PyObject *resultobj = 0;
14989 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14990 int arg2 ;
14991 void *argp1 = 0 ;
14992 int res1 = 0 ;
14993 int val2 ;
14994 int ecode2 = 0 ;
14995 PyObject *swig_obj[2] ;
14996
14997 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14999 if (!SWIG_IsOK(res1)) {
15000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15001 }
15002 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15003 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15004 if (!SWIG_IsOK(ecode2)) {
15005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
15006 }
15007 arg2 = static_cast< int >(val2);
15008 if (arg1) (arg1)->m_pid = arg2;
15009
15010 resultobj = SWIG_Py_Void();
15011 return resultobj;
15012 fail:
15013 return NULL;
15014 }
15015
15016
15017 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15018 PyObject *resultobj = 0;
15019 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15020 int result;
15021 void *argp1 = 0 ;
15022 int res1 = 0 ;
15023 PyObject *swig_obj[1] ;
15024
15025 if (!args) SWIG_fail;
15026 swig_obj[0] = args;
15027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15028 if (!SWIG_IsOK(res1)) {
15029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15030 }
15031 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15032 result = (int) ((arg1)->m_pid);
15033 resultobj = SWIG_From_int(static_cast< int >(result));
15034 return resultobj;
15035 fail:
15036 return NULL;
15037 }
15038
15039
15040 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15041 PyObject *resultobj = 0;
15042 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15043 int arg2 ;
15044 void *argp1 = 0 ;
15045 int res1 = 0 ;
15046 int val2 ;
15047 int ecode2 = 0 ;
15048 PyObject *swig_obj[2] ;
15049
15050 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
15051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15052 if (!SWIG_IsOK(res1)) {
15053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15054 }
15055 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15056 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15057 if (!SWIG_IsOK(ecode2)) {
15058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
15059 }
15060 arg2 = static_cast< int >(val2);
15061 if (arg1) (arg1)->m_exitcode = arg2;
15062
15063 resultobj = SWIG_Py_Void();
15064 return resultobj;
15065 fail:
15066 return NULL;
15067 }
15068
15069
15070 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15071 PyObject *resultobj = 0;
15072 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15073 int result;
15074 void *argp1 = 0 ;
15075 int res1 = 0 ;
15076 PyObject *swig_obj[1] ;
15077
15078 if (!args) SWIG_fail;
15079 swig_obj[0] = args;
15080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15081 if (!SWIG_IsOK(res1)) {
15082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15083 }
15084 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15085 result = (int) ((arg1)->m_exitcode);
15086 resultobj = SWIG_From_int(static_cast< int >(result));
15087 return resultobj;
15088 fail:
15089 return NULL;
15090 }
15091
15092
15093 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15094 PyObject *obj;
15095 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15096 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
15097 return SWIG_Py_Void();
15098 }
15099
15100 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15101 return SWIG_Python_InitShadowInstance(args);
15102 }
15103
15104 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15105 PyObject *resultobj = 0;
15106 wxString *arg1 = 0 ;
15107 int arg2 = (int) wxEXEC_ASYNC ;
15108 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15109 long result;
15110 bool temp1 = false ;
15111 int val2 ;
15112 int ecode2 = 0 ;
15113 void *argp3 = 0 ;
15114 int res3 = 0 ;
15115 PyObject * obj0 = 0 ;
15116 PyObject * obj1 = 0 ;
15117 PyObject * obj2 = 0 ;
15118 char * kwnames[] = {
15119 (char *) "command",(char *) "flags",(char *) "process", NULL
15120 };
15121
15122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15123 {
15124 arg1 = wxString_in_helper(obj0);
15125 if (arg1 == NULL) SWIG_fail;
15126 temp1 = true;
15127 }
15128 if (obj1) {
15129 ecode2 = SWIG_AsVal_int(obj1, &val2);
15130 if (!SWIG_IsOK(ecode2)) {
15131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15132 }
15133 arg2 = static_cast< int >(val2);
15134 }
15135 if (obj2) {
15136 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15137 if (!SWIG_IsOK(res3)) {
15138 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15139 }
15140 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15141 }
15142 {
15143 if (!wxPyCheckForApp()) SWIG_fail;
15144 PyThreadState* __tstate = wxPyBeginAllowThreads();
15145 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15146 wxPyEndAllowThreads(__tstate);
15147 if (PyErr_Occurred()) SWIG_fail;
15148 }
15149 resultobj = SWIG_From_long(static_cast< long >(result));
15150 {
15151 if (temp1)
15152 delete arg1;
15153 }
15154 return resultobj;
15155 fail:
15156 {
15157 if (temp1)
15158 delete arg1;
15159 }
15160 return NULL;
15161 }
15162
15163
15164 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15165 PyObject *resultobj = 0;
15166 long arg1 ;
15167 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15168 wxKillError *arg3 = (wxKillError *) 0 ;
15169 int arg4 = (int) wxKILL_NOCHILDREN ;
15170 int result;
15171 long val1 ;
15172 int ecode1 = 0 ;
15173 int val2 ;
15174 int ecode2 = 0 ;
15175 wxKillError temp3 ;
15176 int val4 ;
15177 int ecode4 = 0 ;
15178 PyObject * obj0 = 0 ;
15179 PyObject * obj1 = 0 ;
15180 PyObject * obj2 = 0 ;
15181 char * kwnames[] = {
15182 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15183 };
15184
15185 {
15186 arg3 = &temp3;
15187 }
15188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15189 ecode1 = SWIG_AsVal_long(obj0, &val1);
15190 if (!SWIG_IsOK(ecode1)) {
15191 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15192 }
15193 arg1 = static_cast< long >(val1);
15194 if (obj1) {
15195 ecode2 = SWIG_AsVal_int(obj1, &val2);
15196 if (!SWIG_IsOK(ecode2)) {
15197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15198 }
15199 arg2 = static_cast< wxSignal >(val2);
15200 }
15201 if (obj2) {
15202 ecode4 = SWIG_AsVal_int(obj2, &val4);
15203 if (!SWIG_IsOK(ecode4)) {
15204 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15205 }
15206 arg4 = static_cast< int >(val4);
15207 }
15208 {
15209 PyThreadState* __tstate = wxPyBeginAllowThreads();
15210 result = (int)wxKill(arg1,arg2,arg3,arg4);
15211 wxPyEndAllowThreads(__tstate);
15212 if (PyErr_Occurred()) SWIG_fail;
15213 }
15214 resultobj = SWIG_From_int(static_cast< int >(result));
15215 {
15216 PyObject* o;
15217 o = PyInt_FromLong((long) (*arg3));
15218
15219
15220
15221 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15222
15223 }
15224 return resultobj;
15225 fail:
15226 return NULL;
15227 }
15228
15229
15230 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15231 PyObject *resultobj = 0;
15232 int arg1 = (int) wxJOYSTICK1 ;
15233 wxJoystick *result = 0 ;
15234 int val1 ;
15235 int ecode1 = 0 ;
15236 PyObject * obj0 = 0 ;
15237 char * kwnames[] = {
15238 (char *) "joystick", NULL
15239 };
15240
15241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15242 if (obj0) {
15243 ecode1 = SWIG_AsVal_int(obj0, &val1);
15244 if (!SWIG_IsOK(ecode1)) {
15245 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15246 }
15247 arg1 = static_cast< int >(val1);
15248 }
15249 {
15250 if (!wxPyCheckForApp()) SWIG_fail;
15251 PyThreadState* __tstate = wxPyBeginAllowThreads();
15252 result = (wxJoystick *)new wxJoystick(arg1);
15253 wxPyEndAllowThreads(__tstate);
15254 if (PyErr_Occurred()) SWIG_fail;
15255 }
15256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15257 return resultobj;
15258 fail:
15259 return NULL;
15260 }
15261
15262
15263 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15264 PyObject *resultobj = 0;
15265 wxJoystick *arg1 = (wxJoystick *) 0 ;
15266 void *argp1 = 0 ;
15267 int res1 = 0 ;
15268 PyObject *swig_obj[1] ;
15269
15270 if (!args) SWIG_fail;
15271 swig_obj[0] = args;
15272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15273 if (!SWIG_IsOK(res1)) {
15274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15275 }
15276 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15277 {
15278 PyThreadState* __tstate = wxPyBeginAllowThreads();
15279 delete arg1;
15280
15281 wxPyEndAllowThreads(__tstate);
15282 if (PyErr_Occurred()) SWIG_fail;
15283 }
15284 resultobj = SWIG_Py_Void();
15285 return resultobj;
15286 fail:
15287 return NULL;
15288 }
15289
15290
15291 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15292 PyObject *resultobj = 0;
15293 wxJoystick *arg1 = (wxJoystick *) 0 ;
15294 wxPoint result;
15295 void *argp1 = 0 ;
15296 int res1 = 0 ;
15297 PyObject *swig_obj[1] ;
15298
15299 if (!args) SWIG_fail;
15300 swig_obj[0] = args;
15301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15302 if (!SWIG_IsOK(res1)) {
15303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15304 }
15305 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15306 {
15307 PyThreadState* __tstate = wxPyBeginAllowThreads();
15308 result = (arg1)->GetPosition();
15309 wxPyEndAllowThreads(__tstate);
15310 if (PyErr_Occurred()) SWIG_fail;
15311 }
15312 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15313 return resultobj;
15314 fail:
15315 return NULL;
15316 }
15317
15318
15319 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15320 PyObject *resultobj = 0;
15321 wxJoystick *arg1 = (wxJoystick *) 0 ;
15322 int result;
15323 void *argp1 = 0 ;
15324 int res1 = 0 ;
15325 PyObject *swig_obj[1] ;
15326
15327 if (!args) SWIG_fail;
15328 swig_obj[0] = args;
15329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15330 if (!SWIG_IsOK(res1)) {
15331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15332 }
15333 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15334 {
15335 PyThreadState* __tstate = wxPyBeginAllowThreads();
15336 result = (int)(arg1)->GetZPosition();
15337 wxPyEndAllowThreads(__tstate);
15338 if (PyErr_Occurred()) SWIG_fail;
15339 }
15340 resultobj = SWIG_From_int(static_cast< int >(result));
15341 return resultobj;
15342 fail:
15343 return NULL;
15344 }
15345
15346
15347 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15348 PyObject *resultobj = 0;
15349 wxJoystick *arg1 = (wxJoystick *) 0 ;
15350 int result;
15351 void *argp1 = 0 ;
15352 int res1 = 0 ;
15353 PyObject *swig_obj[1] ;
15354
15355 if (!args) SWIG_fail;
15356 swig_obj[0] = args;
15357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15358 if (!SWIG_IsOK(res1)) {
15359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15360 }
15361 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15362 {
15363 PyThreadState* __tstate = wxPyBeginAllowThreads();
15364 result = (int)(arg1)->GetButtonState();
15365 wxPyEndAllowThreads(__tstate);
15366 if (PyErr_Occurred()) SWIG_fail;
15367 }
15368 resultobj = SWIG_From_int(static_cast< int >(result));
15369 return resultobj;
15370 fail:
15371 return NULL;
15372 }
15373
15374
15375 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15376 PyObject *resultobj = 0;
15377 wxJoystick *arg1 = (wxJoystick *) 0 ;
15378 int result;
15379 void *argp1 = 0 ;
15380 int res1 = 0 ;
15381 PyObject *swig_obj[1] ;
15382
15383 if (!args) SWIG_fail;
15384 swig_obj[0] = args;
15385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15386 if (!SWIG_IsOK(res1)) {
15387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15388 }
15389 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15390 {
15391 PyThreadState* __tstate = wxPyBeginAllowThreads();
15392 result = (int)(arg1)->GetPOVPosition();
15393 wxPyEndAllowThreads(__tstate);
15394 if (PyErr_Occurred()) SWIG_fail;
15395 }
15396 resultobj = SWIG_From_int(static_cast< int >(result));
15397 return resultobj;
15398 fail:
15399 return NULL;
15400 }
15401
15402
15403 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15404 PyObject *resultobj = 0;
15405 wxJoystick *arg1 = (wxJoystick *) 0 ;
15406 int result;
15407 void *argp1 = 0 ;
15408 int res1 = 0 ;
15409 PyObject *swig_obj[1] ;
15410
15411 if (!args) SWIG_fail;
15412 swig_obj[0] = args;
15413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15414 if (!SWIG_IsOK(res1)) {
15415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15416 }
15417 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15418 {
15419 PyThreadState* __tstate = wxPyBeginAllowThreads();
15420 result = (int)(arg1)->GetPOVCTSPosition();
15421 wxPyEndAllowThreads(__tstate);
15422 if (PyErr_Occurred()) SWIG_fail;
15423 }
15424 resultobj = SWIG_From_int(static_cast< int >(result));
15425 return resultobj;
15426 fail:
15427 return NULL;
15428 }
15429
15430
15431 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15432 PyObject *resultobj = 0;
15433 wxJoystick *arg1 = (wxJoystick *) 0 ;
15434 int result;
15435 void *argp1 = 0 ;
15436 int res1 = 0 ;
15437 PyObject *swig_obj[1] ;
15438
15439 if (!args) SWIG_fail;
15440 swig_obj[0] = args;
15441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15442 if (!SWIG_IsOK(res1)) {
15443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15444 }
15445 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15446 {
15447 PyThreadState* __tstate = wxPyBeginAllowThreads();
15448 result = (int)(arg1)->GetRudderPosition();
15449 wxPyEndAllowThreads(__tstate);
15450 if (PyErr_Occurred()) SWIG_fail;
15451 }
15452 resultobj = SWIG_From_int(static_cast< int >(result));
15453 return resultobj;
15454 fail:
15455 return NULL;
15456 }
15457
15458
15459 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15460 PyObject *resultobj = 0;
15461 wxJoystick *arg1 = (wxJoystick *) 0 ;
15462 int result;
15463 void *argp1 = 0 ;
15464 int res1 = 0 ;
15465 PyObject *swig_obj[1] ;
15466
15467 if (!args) SWIG_fail;
15468 swig_obj[0] = args;
15469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15470 if (!SWIG_IsOK(res1)) {
15471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15472 }
15473 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15474 {
15475 PyThreadState* __tstate = wxPyBeginAllowThreads();
15476 result = (int)(arg1)->GetUPosition();
15477 wxPyEndAllowThreads(__tstate);
15478 if (PyErr_Occurred()) SWIG_fail;
15479 }
15480 resultobj = SWIG_From_int(static_cast< int >(result));
15481 return resultobj;
15482 fail:
15483 return NULL;
15484 }
15485
15486
15487 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15488 PyObject *resultobj = 0;
15489 wxJoystick *arg1 = (wxJoystick *) 0 ;
15490 int result;
15491 void *argp1 = 0 ;
15492 int res1 = 0 ;
15493 PyObject *swig_obj[1] ;
15494
15495 if (!args) SWIG_fail;
15496 swig_obj[0] = args;
15497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15498 if (!SWIG_IsOK(res1)) {
15499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15500 }
15501 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15502 {
15503 PyThreadState* __tstate = wxPyBeginAllowThreads();
15504 result = (int)(arg1)->GetVPosition();
15505 wxPyEndAllowThreads(__tstate);
15506 if (PyErr_Occurred()) SWIG_fail;
15507 }
15508 resultobj = SWIG_From_int(static_cast< int >(result));
15509 return resultobj;
15510 fail:
15511 return NULL;
15512 }
15513
15514
15515 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15516 PyObject *resultobj = 0;
15517 wxJoystick *arg1 = (wxJoystick *) 0 ;
15518 int result;
15519 void *argp1 = 0 ;
15520 int res1 = 0 ;
15521 PyObject *swig_obj[1] ;
15522
15523 if (!args) SWIG_fail;
15524 swig_obj[0] = args;
15525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15526 if (!SWIG_IsOK(res1)) {
15527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15528 }
15529 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15530 {
15531 PyThreadState* __tstate = wxPyBeginAllowThreads();
15532 result = (int)(arg1)->GetMovementThreshold();
15533 wxPyEndAllowThreads(__tstate);
15534 if (PyErr_Occurred()) SWIG_fail;
15535 }
15536 resultobj = SWIG_From_int(static_cast< int >(result));
15537 return resultobj;
15538 fail:
15539 return NULL;
15540 }
15541
15542
15543 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15544 PyObject *resultobj = 0;
15545 wxJoystick *arg1 = (wxJoystick *) 0 ;
15546 int arg2 ;
15547 void *argp1 = 0 ;
15548 int res1 = 0 ;
15549 int val2 ;
15550 int ecode2 = 0 ;
15551 PyObject * obj0 = 0 ;
15552 PyObject * obj1 = 0 ;
15553 char * kwnames[] = {
15554 (char *) "self",(char *) "threshold", NULL
15555 };
15556
15557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15559 if (!SWIG_IsOK(res1)) {
15560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15561 }
15562 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15563 ecode2 = SWIG_AsVal_int(obj1, &val2);
15564 if (!SWIG_IsOK(ecode2)) {
15565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15566 }
15567 arg2 = static_cast< int >(val2);
15568 {
15569 PyThreadState* __tstate = wxPyBeginAllowThreads();
15570 (arg1)->SetMovementThreshold(arg2);
15571 wxPyEndAllowThreads(__tstate);
15572 if (PyErr_Occurred()) SWIG_fail;
15573 }
15574 resultobj = SWIG_Py_Void();
15575 return resultobj;
15576 fail:
15577 return NULL;
15578 }
15579
15580
15581 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15582 PyObject *resultobj = 0;
15583 wxJoystick *arg1 = (wxJoystick *) 0 ;
15584 bool result;
15585 void *argp1 = 0 ;
15586 int res1 = 0 ;
15587 PyObject *swig_obj[1] ;
15588
15589 if (!args) SWIG_fail;
15590 swig_obj[0] = args;
15591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15592 if (!SWIG_IsOK(res1)) {
15593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15594 }
15595 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15596 {
15597 PyThreadState* __tstate = wxPyBeginAllowThreads();
15598 result = (bool)(arg1)->IsOk();
15599 wxPyEndAllowThreads(__tstate);
15600 if (PyErr_Occurred()) SWIG_fail;
15601 }
15602 {
15603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15604 }
15605 return resultobj;
15606 fail:
15607 return NULL;
15608 }
15609
15610
15611 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15612 PyObject *resultobj = 0;
15613 wxJoystick *arg1 = (wxJoystick *) 0 ;
15614 int result;
15615 void *argp1 = 0 ;
15616 int res1 = 0 ;
15617 PyObject *swig_obj[1] ;
15618
15619 if (!args) SWIG_fail;
15620 swig_obj[0] = args;
15621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15622 if (!SWIG_IsOK(res1)) {
15623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15624 }
15625 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15626 {
15627 PyThreadState* __tstate = wxPyBeginAllowThreads();
15628 result = (int)(arg1)->GetNumberJoysticks();
15629 wxPyEndAllowThreads(__tstate);
15630 if (PyErr_Occurred()) SWIG_fail;
15631 }
15632 resultobj = SWIG_From_int(static_cast< int >(result));
15633 return resultobj;
15634 fail:
15635 return NULL;
15636 }
15637
15638
15639 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15640 PyObject *resultobj = 0;
15641 wxJoystick *arg1 = (wxJoystick *) 0 ;
15642 int result;
15643 void *argp1 = 0 ;
15644 int res1 = 0 ;
15645 PyObject *swig_obj[1] ;
15646
15647 if (!args) SWIG_fail;
15648 swig_obj[0] = args;
15649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15650 if (!SWIG_IsOK(res1)) {
15651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15652 }
15653 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15654 {
15655 PyThreadState* __tstate = wxPyBeginAllowThreads();
15656 result = (int)(arg1)->GetManufacturerId();
15657 wxPyEndAllowThreads(__tstate);
15658 if (PyErr_Occurred()) SWIG_fail;
15659 }
15660 resultobj = SWIG_From_int(static_cast< int >(result));
15661 return resultobj;
15662 fail:
15663 return NULL;
15664 }
15665
15666
15667 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15668 PyObject *resultobj = 0;
15669 wxJoystick *arg1 = (wxJoystick *) 0 ;
15670 int result;
15671 void *argp1 = 0 ;
15672 int res1 = 0 ;
15673 PyObject *swig_obj[1] ;
15674
15675 if (!args) SWIG_fail;
15676 swig_obj[0] = args;
15677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15678 if (!SWIG_IsOK(res1)) {
15679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15680 }
15681 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15682 {
15683 PyThreadState* __tstate = wxPyBeginAllowThreads();
15684 result = (int)(arg1)->GetProductId();
15685 wxPyEndAllowThreads(__tstate);
15686 if (PyErr_Occurred()) SWIG_fail;
15687 }
15688 resultobj = SWIG_From_int(static_cast< int >(result));
15689 return resultobj;
15690 fail:
15691 return NULL;
15692 }
15693
15694
15695 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15696 PyObject *resultobj = 0;
15697 wxJoystick *arg1 = (wxJoystick *) 0 ;
15698 wxString result;
15699 void *argp1 = 0 ;
15700 int res1 = 0 ;
15701 PyObject *swig_obj[1] ;
15702
15703 if (!args) SWIG_fail;
15704 swig_obj[0] = args;
15705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15706 if (!SWIG_IsOK(res1)) {
15707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15708 }
15709 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15710 {
15711 PyThreadState* __tstate = wxPyBeginAllowThreads();
15712 result = (arg1)->GetProductName();
15713 wxPyEndAllowThreads(__tstate);
15714 if (PyErr_Occurred()) SWIG_fail;
15715 }
15716 {
15717 #if wxUSE_UNICODE
15718 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15719 #else
15720 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15721 #endif
15722 }
15723 return resultobj;
15724 fail:
15725 return NULL;
15726 }
15727
15728
15729 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15730 PyObject *resultobj = 0;
15731 wxJoystick *arg1 = (wxJoystick *) 0 ;
15732 int result;
15733 void *argp1 = 0 ;
15734 int res1 = 0 ;
15735 PyObject *swig_obj[1] ;
15736
15737 if (!args) SWIG_fail;
15738 swig_obj[0] = args;
15739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15740 if (!SWIG_IsOK(res1)) {
15741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15742 }
15743 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15744 {
15745 PyThreadState* __tstate = wxPyBeginAllowThreads();
15746 result = (int)(arg1)->GetXMin();
15747 wxPyEndAllowThreads(__tstate);
15748 if (PyErr_Occurred()) SWIG_fail;
15749 }
15750 resultobj = SWIG_From_int(static_cast< int >(result));
15751 return resultobj;
15752 fail:
15753 return NULL;
15754 }
15755
15756
15757 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15758 PyObject *resultobj = 0;
15759 wxJoystick *arg1 = (wxJoystick *) 0 ;
15760 int result;
15761 void *argp1 = 0 ;
15762 int res1 = 0 ;
15763 PyObject *swig_obj[1] ;
15764
15765 if (!args) SWIG_fail;
15766 swig_obj[0] = args;
15767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15768 if (!SWIG_IsOK(res1)) {
15769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15770 }
15771 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15772 {
15773 PyThreadState* __tstate = wxPyBeginAllowThreads();
15774 result = (int)(arg1)->GetYMin();
15775 wxPyEndAllowThreads(__tstate);
15776 if (PyErr_Occurred()) SWIG_fail;
15777 }
15778 resultobj = SWIG_From_int(static_cast< int >(result));
15779 return resultobj;
15780 fail:
15781 return NULL;
15782 }
15783
15784
15785 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15786 PyObject *resultobj = 0;
15787 wxJoystick *arg1 = (wxJoystick *) 0 ;
15788 int result;
15789 void *argp1 = 0 ;
15790 int res1 = 0 ;
15791 PyObject *swig_obj[1] ;
15792
15793 if (!args) SWIG_fail;
15794 swig_obj[0] = args;
15795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15796 if (!SWIG_IsOK(res1)) {
15797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15798 }
15799 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15800 {
15801 PyThreadState* __tstate = wxPyBeginAllowThreads();
15802 result = (int)(arg1)->GetZMin();
15803 wxPyEndAllowThreads(__tstate);
15804 if (PyErr_Occurred()) SWIG_fail;
15805 }
15806 resultobj = SWIG_From_int(static_cast< int >(result));
15807 return resultobj;
15808 fail:
15809 return NULL;
15810 }
15811
15812
15813 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15814 PyObject *resultobj = 0;
15815 wxJoystick *arg1 = (wxJoystick *) 0 ;
15816 int result;
15817 void *argp1 = 0 ;
15818 int res1 = 0 ;
15819 PyObject *swig_obj[1] ;
15820
15821 if (!args) SWIG_fail;
15822 swig_obj[0] = args;
15823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15824 if (!SWIG_IsOK(res1)) {
15825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15826 }
15827 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15828 {
15829 PyThreadState* __tstate = wxPyBeginAllowThreads();
15830 result = (int)(arg1)->GetXMax();
15831 wxPyEndAllowThreads(__tstate);
15832 if (PyErr_Occurred()) SWIG_fail;
15833 }
15834 resultobj = SWIG_From_int(static_cast< int >(result));
15835 return resultobj;
15836 fail:
15837 return NULL;
15838 }
15839
15840
15841 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15842 PyObject *resultobj = 0;
15843 wxJoystick *arg1 = (wxJoystick *) 0 ;
15844 int result;
15845 void *argp1 = 0 ;
15846 int res1 = 0 ;
15847 PyObject *swig_obj[1] ;
15848
15849 if (!args) SWIG_fail;
15850 swig_obj[0] = args;
15851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15852 if (!SWIG_IsOK(res1)) {
15853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15854 }
15855 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15856 {
15857 PyThreadState* __tstate = wxPyBeginAllowThreads();
15858 result = (int)(arg1)->GetYMax();
15859 wxPyEndAllowThreads(__tstate);
15860 if (PyErr_Occurred()) SWIG_fail;
15861 }
15862 resultobj = SWIG_From_int(static_cast< int >(result));
15863 return resultobj;
15864 fail:
15865 return NULL;
15866 }
15867
15868
15869 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15870 PyObject *resultobj = 0;
15871 wxJoystick *arg1 = (wxJoystick *) 0 ;
15872 int result;
15873 void *argp1 = 0 ;
15874 int res1 = 0 ;
15875 PyObject *swig_obj[1] ;
15876
15877 if (!args) SWIG_fail;
15878 swig_obj[0] = args;
15879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15880 if (!SWIG_IsOK(res1)) {
15881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15882 }
15883 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15884 {
15885 PyThreadState* __tstate = wxPyBeginAllowThreads();
15886 result = (int)(arg1)->GetZMax();
15887 wxPyEndAllowThreads(__tstate);
15888 if (PyErr_Occurred()) SWIG_fail;
15889 }
15890 resultobj = SWIG_From_int(static_cast< int >(result));
15891 return resultobj;
15892 fail:
15893 return NULL;
15894 }
15895
15896
15897 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15898 PyObject *resultobj = 0;
15899 wxJoystick *arg1 = (wxJoystick *) 0 ;
15900 int result;
15901 void *argp1 = 0 ;
15902 int res1 = 0 ;
15903 PyObject *swig_obj[1] ;
15904
15905 if (!args) SWIG_fail;
15906 swig_obj[0] = args;
15907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15908 if (!SWIG_IsOK(res1)) {
15909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15910 }
15911 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15912 {
15913 PyThreadState* __tstate = wxPyBeginAllowThreads();
15914 result = (int)(arg1)->GetNumberButtons();
15915 wxPyEndAllowThreads(__tstate);
15916 if (PyErr_Occurred()) SWIG_fail;
15917 }
15918 resultobj = SWIG_From_int(static_cast< int >(result));
15919 return resultobj;
15920 fail:
15921 return NULL;
15922 }
15923
15924
15925 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15926 PyObject *resultobj = 0;
15927 wxJoystick *arg1 = (wxJoystick *) 0 ;
15928 int result;
15929 void *argp1 = 0 ;
15930 int res1 = 0 ;
15931 PyObject *swig_obj[1] ;
15932
15933 if (!args) SWIG_fail;
15934 swig_obj[0] = args;
15935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15936 if (!SWIG_IsOK(res1)) {
15937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15938 }
15939 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15940 {
15941 PyThreadState* __tstate = wxPyBeginAllowThreads();
15942 result = (int)(arg1)->GetNumberAxes();
15943 wxPyEndAllowThreads(__tstate);
15944 if (PyErr_Occurred()) SWIG_fail;
15945 }
15946 resultobj = SWIG_From_int(static_cast< int >(result));
15947 return resultobj;
15948 fail:
15949 return NULL;
15950 }
15951
15952
15953 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15954 PyObject *resultobj = 0;
15955 wxJoystick *arg1 = (wxJoystick *) 0 ;
15956 int result;
15957 void *argp1 = 0 ;
15958 int res1 = 0 ;
15959 PyObject *swig_obj[1] ;
15960
15961 if (!args) SWIG_fail;
15962 swig_obj[0] = args;
15963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15964 if (!SWIG_IsOK(res1)) {
15965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15966 }
15967 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15968 {
15969 PyThreadState* __tstate = wxPyBeginAllowThreads();
15970 result = (int)(arg1)->GetMaxButtons();
15971 wxPyEndAllowThreads(__tstate);
15972 if (PyErr_Occurred()) SWIG_fail;
15973 }
15974 resultobj = SWIG_From_int(static_cast< int >(result));
15975 return resultobj;
15976 fail:
15977 return NULL;
15978 }
15979
15980
15981 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15982 PyObject *resultobj = 0;
15983 wxJoystick *arg1 = (wxJoystick *) 0 ;
15984 int result;
15985 void *argp1 = 0 ;
15986 int res1 = 0 ;
15987 PyObject *swig_obj[1] ;
15988
15989 if (!args) SWIG_fail;
15990 swig_obj[0] = args;
15991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15992 if (!SWIG_IsOK(res1)) {
15993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15994 }
15995 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15996 {
15997 PyThreadState* __tstate = wxPyBeginAllowThreads();
15998 result = (int)(arg1)->GetMaxAxes();
15999 wxPyEndAllowThreads(__tstate);
16000 if (PyErr_Occurred()) SWIG_fail;
16001 }
16002 resultobj = SWIG_From_int(static_cast< int >(result));
16003 return resultobj;
16004 fail:
16005 return NULL;
16006 }
16007
16008
16009 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16010 PyObject *resultobj = 0;
16011 wxJoystick *arg1 = (wxJoystick *) 0 ;
16012 int result;
16013 void *argp1 = 0 ;
16014 int res1 = 0 ;
16015 PyObject *swig_obj[1] ;
16016
16017 if (!args) SWIG_fail;
16018 swig_obj[0] = args;
16019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16020 if (!SWIG_IsOK(res1)) {
16021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16022 }
16023 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16024 {
16025 PyThreadState* __tstate = wxPyBeginAllowThreads();
16026 result = (int)(arg1)->GetPollingMin();
16027 wxPyEndAllowThreads(__tstate);
16028 if (PyErr_Occurred()) SWIG_fail;
16029 }
16030 resultobj = SWIG_From_int(static_cast< int >(result));
16031 return resultobj;
16032 fail:
16033 return NULL;
16034 }
16035
16036
16037 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16038 PyObject *resultobj = 0;
16039 wxJoystick *arg1 = (wxJoystick *) 0 ;
16040 int result;
16041 void *argp1 = 0 ;
16042 int res1 = 0 ;
16043 PyObject *swig_obj[1] ;
16044
16045 if (!args) SWIG_fail;
16046 swig_obj[0] = args;
16047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16048 if (!SWIG_IsOK(res1)) {
16049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16050 }
16051 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16052 {
16053 PyThreadState* __tstate = wxPyBeginAllowThreads();
16054 result = (int)(arg1)->GetPollingMax();
16055 wxPyEndAllowThreads(__tstate);
16056 if (PyErr_Occurred()) SWIG_fail;
16057 }
16058 resultobj = SWIG_From_int(static_cast< int >(result));
16059 return resultobj;
16060 fail:
16061 return NULL;
16062 }
16063
16064
16065 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16066 PyObject *resultobj = 0;
16067 wxJoystick *arg1 = (wxJoystick *) 0 ;
16068 int result;
16069 void *argp1 = 0 ;
16070 int res1 = 0 ;
16071 PyObject *swig_obj[1] ;
16072
16073 if (!args) SWIG_fail;
16074 swig_obj[0] = args;
16075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16076 if (!SWIG_IsOK(res1)) {
16077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16078 }
16079 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16080 {
16081 PyThreadState* __tstate = wxPyBeginAllowThreads();
16082 result = (int)(arg1)->GetRudderMin();
16083 wxPyEndAllowThreads(__tstate);
16084 if (PyErr_Occurred()) SWIG_fail;
16085 }
16086 resultobj = SWIG_From_int(static_cast< int >(result));
16087 return resultobj;
16088 fail:
16089 return NULL;
16090 }
16091
16092
16093 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16094 PyObject *resultobj = 0;
16095 wxJoystick *arg1 = (wxJoystick *) 0 ;
16096 int result;
16097 void *argp1 = 0 ;
16098 int res1 = 0 ;
16099 PyObject *swig_obj[1] ;
16100
16101 if (!args) SWIG_fail;
16102 swig_obj[0] = args;
16103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16104 if (!SWIG_IsOK(res1)) {
16105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16106 }
16107 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16108 {
16109 PyThreadState* __tstate = wxPyBeginAllowThreads();
16110 result = (int)(arg1)->GetRudderMax();
16111 wxPyEndAllowThreads(__tstate);
16112 if (PyErr_Occurred()) SWIG_fail;
16113 }
16114 resultobj = SWIG_From_int(static_cast< int >(result));
16115 return resultobj;
16116 fail:
16117 return NULL;
16118 }
16119
16120
16121 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16122 PyObject *resultobj = 0;
16123 wxJoystick *arg1 = (wxJoystick *) 0 ;
16124 int result;
16125 void *argp1 = 0 ;
16126 int res1 = 0 ;
16127 PyObject *swig_obj[1] ;
16128
16129 if (!args) SWIG_fail;
16130 swig_obj[0] = args;
16131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16132 if (!SWIG_IsOK(res1)) {
16133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16134 }
16135 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16136 {
16137 PyThreadState* __tstate = wxPyBeginAllowThreads();
16138 result = (int)(arg1)->GetUMin();
16139 wxPyEndAllowThreads(__tstate);
16140 if (PyErr_Occurred()) SWIG_fail;
16141 }
16142 resultobj = SWIG_From_int(static_cast< int >(result));
16143 return resultobj;
16144 fail:
16145 return NULL;
16146 }
16147
16148
16149 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16150 PyObject *resultobj = 0;
16151 wxJoystick *arg1 = (wxJoystick *) 0 ;
16152 int result;
16153 void *argp1 = 0 ;
16154 int res1 = 0 ;
16155 PyObject *swig_obj[1] ;
16156
16157 if (!args) SWIG_fail;
16158 swig_obj[0] = args;
16159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16160 if (!SWIG_IsOK(res1)) {
16161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16162 }
16163 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16164 {
16165 PyThreadState* __tstate = wxPyBeginAllowThreads();
16166 result = (int)(arg1)->GetUMax();
16167 wxPyEndAllowThreads(__tstate);
16168 if (PyErr_Occurred()) SWIG_fail;
16169 }
16170 resultobj = SWIG_From_int(static_cast< int >(result));
16171 return resultobj;
16172 fail:
16173 return NULL;
16174 }
16175
16176
16177 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16178 PyObject *resultobj = 0;
16179 wxJoystick *arg1 = (wxJoystick *) 0 ;
16180 int result;
16181 void *argp1 = 0 ;
16182 int res1 = 0 ;
16183 PyObject *swig_obj[1] ;
16184
16185 if (!args) SWIG_fail;
16186 swig_obj[0] = args;
16187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16188 if (!SWIG_IsOK(res1)) {
16189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16190 }
16191 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16192 {
16193 PyThreadState* __tstate = wxPyBeginAllowThreads();
16194 result = (int)(arg1)->GetVMin();
16195 wxPyEndAllowThreads(__tstate);
16196 if (PyErr_Occurred()) SWIG_fail;
16197 }
16198 resultobj = SWIG_From_int(static_cast< int >(result));
16199 return resultobj;
16200 fail:
16201 return NULL;
16202 }
16203
16204
16205 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16206 PyObject *resultobj = 0;
16207 wxJoystick *arg1 = (wxJoystick *) 0 ;
16208 int result;
16209 void *argp1 = 0 ;
16210 int res1 = 0 ;
16211 PyObject *swig_obj[1] ;
16212
16213 if (!args) SWIG_fail;
16214 swig_obj[0] = args;
16215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16216 if (!SWIG_IsOK(res1)) {
16217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16218 }
16219 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16220 {
16221 PyThreadState* __tstate = wxPyBeginAllowThreads();
16222 result = (int)(arg1)->GetVMax();
16223 wxPyEndAllowThreads(__tstate);
16224 if (PyErr_Occurred()) SWIG_fail;
16225 }
16226 resultobj = SWIG_From_int(static_cast< int >(result));
16227 return resultobj;
16228 fail:
16229 return NULL;
16230 }
16231
16232
16233 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16234 PyObject *resultobj = 0;
16235 wxJoystick *arg1 = (wxJoystick *) 0 ;
16236 bool result;
16237 void *argp1 = 0 ;
16238 int res1 = 0 ;
16239 PyObject *swig_obj[1] ;
16240
16241 if (!args) SWIG_fail;
16242 swig_obj[0] = args;
16243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16244 if (!SWIG_IsOK(res1)) {
16245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16246 }
16247 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16248 {
16249 PyThreadState* __tstate = wxPyBeginAllowThreads();
16250 result = (bool)(arg1)->HasRudder();
16251 wxPyEndAllowThreads(__tstate);
16252 if (PyErr_Occurred()) SWIG_fail;
16253 }
16254 {
16255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16256 }
16257 return resultobj;
16258 fail:
16259 return NULL;
16260 }
16261
16262
16263 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16264 PyObject *resultobj = 0;
16265 wxJoystick *arg1 = (wxJoystick *) 0 ;
16266 bool result;
16267 void *argp1 = 0 ;
16268 int res1 = 0 ;
16269 PyObject *swig_obj[1] ;
16270
16271 if (!args) SWIG_fail;
16272 swig_obj[0] = args;
16273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16274 if (!SWIG_IsOK(res1)) {
16275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16276 }
16277 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16278 {
16279 PyThreadState* __tstate = wxPyBeginAllowThreads();
16280 result = (bool)(arg1)->HasZ();
16281 wxPyEndAllowThreads(__tstate);
16282 if (PyErr_Occurred()) SWIG_fail;
16283 }
16284 {
16285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16286 }
16287 return resultobj;
16288 fail:
16289 return NULL;
16290 }
16291
16292
16293 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16294 PyObject *resultobj = 0;
16295 wxJoystick *arg1 = (wxJoystick *) 0 ;
16296 bool result;
16297 void *argp1 = 0 ;
16298 int res1 = 0 ;
16299 PyObject *swig_obj[1] ;
16300
16301 if (!args) SWIG_fail;
16302 swig_obj[0] = args;
16303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16304 if (!SWIG_IsOK(res1)) {
16305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16306 }
16307 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16308 {
16309 PyThreadState* __tstate = wxPyBeginAllowThreads();
16310 result = (bool)(arg1)->HasU();
16311 wxPyEndAllowThreads(__tstate);
16312 if (PyErr_Occurred()) SWIG_fail;
16313 }
16314 {
16315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16316 }
16317 return resultobj;
16318 fail:
16319 return NULL;
16320 }
16321
16322
16323 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16324 PyObject *resultobj = 0;
16325 wxJoystick *arg1 = (wxJoystick *) 0 ;
16326 bool result;
16327 void *argp1 = 0 ;
16328 int res1 = 0 ;
16329 PyObject *swig_obj[1] ;
16330
16331 if (!args) SWIG_fail;
16332 swig_obj[0] = args;
16333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16334 if (!SWIG_IsOK(res1)) {
16335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16336 }
16337 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16338 {
16339 PyThreadState* __tstate = wxPyBeginAllowThreads();
16340 result = (bool)(arg1)->HasV();
16341 wxPyEndAllowThreads(__tstate);
16342 if (PyErr_Occurred()) SWIG_fail;
16343 }
16344 {
16345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16346 }
16347 return resultobj;
16348 fail:
16349 return NULL;
16350 }
16351
16352
16353 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16354 PyObject *resultobj = 0;
16355 wxJoystick *arg1 = (wxJoystick *) 0 ;
16356 bool result;
16357 void *argp1 = 0 ;
16358 int res1 = 0 ;
16359 PyObject *swig_obj[1] ;
16360
16361 if (!args) SWIG_fail;
16362 swig_obj[0] = args;
16363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16364 if (!SWIG_IsOK(res1)) {
16365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16366 }
16367 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16368 {
16369 PyThreadState* __tstate = wxPyBeginAllowThreads();
16370 result = (bool)(arg1)->HasPOV();
16371 wxPyEndAllowThreads(__tstate);
16372 if (PyErr_Occurred()) SWIG_fail;
16373 }
16374 {
16375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16376 }
16377 return resultobj;
16378 fail:
16379 return NULL;
16380 }
16381
16382
16383 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16384 PyObject *resultobj = 0;
16385 wxJoystick *arg1 = (wxJoystick *) 0 ;
16386 bool result;
16387 void *argp1 = 0 ;
16388 int res1 = 0 ;
16389 PyObject *swig_obj[1] ;
16390
16391 if (!args) SWIG_fail;
16392 swig_obj[0] = args;
16393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16394 if (!SWIG_IsOK(res1)) {
16395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16396 }
16397 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16398 {
16399 PyThreadState* __tstate = wxPyBeginAllowThreads();
16400 result = (bool)(arg1)->HasPOV4Dir();
16401 wxPyEndAllowThreads(__tstate);
16402 if (PyErr_Occurred()) SWIG_fail;
16403 }
16404 {
16405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16406 }
16407 return resultobj;
16408 fail:
16409 return NULL;
16410 }
16411
16412
16413 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16414 PyObject *resultobj = 0;
16415 wxJoystick *arg1 = (wxJoystick *) 0 ;
16416 bool result;
16417 void *argp1 = 0 ;
16418 int res1 = 0 ;
16419 PyObject *swig_obj[1] ;
16420
16421 if (!args) SWIG_fail;
16422 swig_obj[0] = args;
16423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16424 if (!SWIG_IsOK(res1)) {
16425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16426 }
16427 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16428 {
16429 PyThreadState* __tstate = wxPyBeginAllowThreads();
16430 result = (bool)(arg1)->HasPOVCTS();
16431 wxPyEndAllowThreads(__tstate);
16432 if (PyErr_Occurred()) SWIG_fail;
16433 }
16434 {
16435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16436 }
16437 return resultobj;
16438 fail:
16439 return NULL;
16440 }
16441
16442
16443 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16444 PyObject *resultobj = 0;
16445 wxJoystick *arg1 = (wxJoystick *) 0 ;
16446 wxWindow *arg2 = (wxWindow *) 0 ;
16447 int arg3 = (int) 0 ;
16448 bool result;
16449 void *argp1 = 0 ;
16450 int res1 = 0 ;
16451 void *argp2 = 0 ;
16452 int res2 = 0 ;
16453 int val3 ;
16454 int ecode3 = 0 ;
16455 PyObject * obj0 = 0 ;
16456 PyObject * obj1 = 0 ;
16457 PyObject * obj2 = 0 ;
16458 char * kwnames[] = {
16459 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16460 };
16461
16462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16464 if (!SWIG_IsOK(res1)) {
16465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16466 }
16467 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16468 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16469 if (!SWIG_IsOK(res2)) {
16470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16471 }
16472 arg2 = reinterpret_cast< wxWindow * >(argp2);
16473 if (obj2) {
16474 ecode3 = SWIG_AsVal_int(obj2, &val3);
16475 if (!SWIG_IsOK(ecode3)) {
16476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16477 }
16478 arg3 = static_cast< int >(val3);
16479 }
16480 {
16481 PyThreadState* __tstate = wxPyBeginAllowThreads();
16482 result = (bool)(arg1)->SetCapture(arg2,arg3);
16483 wxPyEndAllowThreads(__tstate);
16484 if (PyErr_Occurred()) SWIG_fail;
16485 }
16486 {
16487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16488 }
16489 return resultobj;
16490 fail:
16491 return NULL;
16492 }
16493
16494
16495 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16496 PyObject *resultobj = 0;
16497 wxJoystick *arg1 = (wxJoystick *) 0 ;
16498 bool result;
16499 void *argp1 = 0 ;
16500 int res1 = 0 ;
16501 PyObject *swig_obj[1] ;
16502
16503 if (!args) SWIG_fail;
16504 swig_obj[0] = args;
16505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16506 if (!SWIG_IsOK(res1)) {
16507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16508 }
16509 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16510 {
16511 PyThreadState* __tstate = wxPyBeginAllowThreads();
16512 result = (bool)(arg1)->ReleaseCapture();
16513 wxPyEndAllowThreads(__tstate);
16514 if (PyErr_Occurred()) SWIG_fail;
16515 }
16516 {
16517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16518 }
16519 return resultobj;
16520 fail:
16521 return NULL;
16522 }
16523
16524
16525 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16526 PyObject *obj;
16527 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16528 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16529 return SWIG_Py_Void();
16530 }
16531
16532 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16533 return SWIG_Python_InitShadowInstance(args);
16534 }
16535
16536 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16537 PyObject *resultobj = 0;
16538 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16539 int arg2 = (int) 0 ;
16540 int arg3 = (int) wxJOYSTICK1 ;
16541 int arg4 = (int) 0 ;
16542 wxJoystickEvent *result = 0 ;
16543 int val1 ;
16544 int ecode1 = 0 ;
16545 int val2 ;
16546 int ecode2 = 0 ;
16547 int val3 ;
16548 int ecode3 = 0 ;
16549 int val4 ;
16550 int ecode4 = 0 ;
16551 PyObject * obj0 = 0 ;
16552 PyObject * obj1 = 0 ;
16553 PyObject * obj2 = 0 ;
16554 PyObject * obj3 = 0 ;
16555 char * kwnames[] = {
16556 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16557 };
16558
16559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16560 if (obj0) {
16561 ecode1 = SWIG_AsVal_int(obj0, &val1);
16562 if (!SWIG_IsOK(ecode1)) {
16563 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16564 }
16565 arg1 = static_cast< wxEventType >(val1);
16566 }
16567 if (obj1) {
16568 ecode2 = SWIG_AsVal_int(obj1, &val2);
16569 if (!SWIG_IsOK(ecode2)) {
16570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16571 }
16572 arg2 = static_cast< int >(val2);
16573 }
16574 if (obj2) {
16575 ecode3 = SWIG_AsVal_int(obj2, &val3);
16576 if (!SWIG_IsOK(ecode3)) {
16577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16578 }
16579 arg3 = static_cast< int >(val3);
16580 }
16581 if (obj3) {
16582 ecode4 = SWIG_AsVal_int(obj3, &val4);
16583 if (!SWIG_IsOK(ecode4)) {
16584 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16585 }
16586 arg4 = static_cast< int >(val4);
16587 }
16588 {
16589 PyThreadState* __tstate = wxPyBeginAllowThreads();
16590 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16591 wxPyEndAllowThreads(__tstate);
16592 if (PyErr_Occurred()) SWIG_fail;
16593 }
16594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16595 return resultobj;
16596 fail:
16597 return NULL;
16598 }
16599
16600
16601 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16602 PyObject *resultobj = 0;
16603 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16604 wxPoint result;
16605 void *argp1 = 0 ;
16606 int res1 = 0 ;
16607 PyObject *swig_obj[1] ;
16608
16609 if (!args) SWIG_fail;
16610 swig_obj[0] = args;
16611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16612 if (!SWIG_IsOK(res1)) {
16613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16614 }
16615 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16616 {
16617 PyThreadState* __tstate = wxPyBeginAllowThreads();
16618 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16619 wxPyEndAllowThreads(__tstate);
16620 if (PyErr_Occurred()) SWIG_fail;
16621 }
16622 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16623 return resultobj;
16624 fail:
16625 return NULL;
16626 }
16627
16628
16629 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16630 PyObject *resultobj = 0;
16631 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16632 int result;
16633 void *argp1 = 0 ;
16634 int res1 = 0 ;
16635 PyObject *swig_obj[1] ;
16636
16637 if (!args) SWIG_fail;
16638 swig_obj[0] = args;
16639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16640 if (!SWIG_IsOK(res1)) {
16641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16642 }
16643 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16644 {
16645 PyThreadState* __tstate = wxPyBeginAllowThreads();
16646 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16647 wxPyEndAllowThreads(__tstate);
16648 if (PyErr_Occurred()) SWIG_fail;
16649 }
16650 resultobj = SWIG_From_int(static_cast< int >(result));
16651 return resultobj;
16652 fail:
16653 return NULL;
16654 }
16655
16656
16657 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16658 PyObject *resultobj = 0;
16659 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16660 int result;
16661 void *argp1 = 0 ;
16662 int res1 = 0 ;
16663 PyObject *swig_obj[1] ;
16664
16665 if (!args) SWIG_fail;
16666 swig_obj[0] = args;
16667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16668 if (!SWIG_IsOK(res1)) {
16669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16670 }
16671 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16672 {
16673 PyThreadState* __tstate = wxPyBeginAllowThreads();
16674 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16675 wxPyEndAllowThreads(__tstate);
16676 if (PyErr_Occurred()) SWIG_fail;
16677 }
16678 resultobj = SWIG_From_int(static_cast< int >(result));
16679 return resultobj;
16680 fail:
16681 return NULL;
16682 }
16683
16684
16685 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16686 PyObject *resultobj = 0;
16687 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16688 int result;
16689 void *argp1 = 0 ;
16690 int res1 = 0 ;
16691 PyObject *swig_obj[1] ;
16692
16693 if (!args) SWIG_fail;
16694 swig_obj[0] = args;
16695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16696 if (!SWIG_IsOK(res1)) {
16697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16698 }
16699 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16700 {
16701 PyThreadState* __tstate = wxPyBeginAllowThreads();
16702 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16703 wxPyEndAllowThreads(__tstate);
16704 if (PyErr_Occurred()) SWIG_fail;
16705 }
16706 resultobj = SWIG_From_int(static_cast< int >(result));
16707 return resultobj;
16708 fail:
16709 return NULL;
16710 }
16711
16712
16713 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16714 PyObject *resultobj = 0;
16715 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16716 int result;
16717 void *argp1 = 0 ;
16718 int res1 = 0 ;
16719 PyObject *swig_obj[1] ;
16720
16721 if (!args) SWIG_fail;
16722 swig_obj[0] = args;
16723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16724 if (!SWIG_IsOK(res1)) {
16725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16726 }
16727 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16728 {
16729 PyThreadState* __tstate = wxPyBeginAllowThreads();
16730 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16731 wxPyEndAllowThreads(__tstate);
16732 if (PyErr_Occurred()) SWIG_fail;
16733 }
16734 resultobj = SWIG_From_int(static_cast< int >(result));
16735 return resultobj;
16736 fail:
16737 return NULL;
16738 }
16739
16740
16741 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16742 PyObject *resultobj = 0;
16743 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16744 int arg2 ;
16745 void *argp1 = 0 ;
16746 int res1 = 0 ;
16747 int val2 ;
16748 int ecode2 = 0 ;
16749 PyObject * obj0 = 0 ;
16750 PyObject * obj1 = 0 ;
16751 char * kwnames[] = {
16752 (char *) "self",(char *) "stick", NULL
16753 };
16754
16755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16757 if (!SWIG_IsOK(res1)) {
16758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16759 }
16760 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16761 ecode2 = SWIG_AsVal_int(obj1, &val2);
16762 if (!SWIG_IsOK(ecode2)) {
16763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16764 }
16765 arg2 = static_cast< int >(val2);
16766 {
16767 PyThreadState* __tstate = wxPyBeginAllowThreads();
16768 (arg1)->SetJoystick(arg2);
16769 wxPyEndAllowThreads(__tstate);
16770 if (PyErr_Occurred()) SWIG_fail;
16771 }
16772 resultobj = SWIG_Py_Void();
16773 return resultobj;
16774 fail:
16775 return NULL;
16776 }
16777
16778
16779 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16780 PyObject *resultobj = 0;
16781 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16782 int arg2 ;
16783 void *argp1 = 0 ;
16784 int res1 = 0 ;
16785 int val2 ;
16786 int ecode2 = 0 ;
16787 PyObject * obj0 = 0 ;
16788 PyObject * obj1 = 0 ;
16789 char * kwnames[] = {
16790 (char *) "self",(char *) "state", NULL
16791 };
16792
16793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16795 if (!SWIG_IsOK(res1)) {
16796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16797 }
16798 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16799 ecode2 = SWIG_AsVal_int(obj1, &val2);
16800 if (!SWIG_IsOK(ecode2)) {
16801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16802 }
16803 arg2 = static_cast< int >(val2);
16804 {
16805 PyThreadState* __tstate = wxPyBeginAllowThreads();
16806 (arg1)->SetButtonState(arg2);
16807 wxPyEndAllowThreads(__tstate);
16808 if (PyErr_Occurred()) SWIG_fail;
16809 }
16810 resultobj = SWIG_Py_Void();
16811 return resultobj;
16812 fail:
16813 return NULL;
16814 }
16815
16816
16817 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16818 PyObject *resultobj = 0;
16819 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16820 int arg2 ;
16821 void *argp1 = 0 ;
16822 int res1 = 0 ;
16823 int val2 ;
16824 int ecode2 = 0 ;
16825 PyObject * obj0 = 0 ;
16826 PyObject * obj1 = 0 ;
16827 char * kwnames[] = {
16828 (char *) "self",(char *) "change", NULL
16829 };
16830
16831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16833 if (!SWIG_IsOK(res1)) {
16834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16835 }
16836 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16837 ecode2 = SWIG_AsVal_int(obj1, &val2);
16838 if (!SWIG_IsOK(ecode2)) {
16839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16840 }
16841 arg2 = static_cast< int >(val2);
16842 {
16843 PyThreadState* __tstate = wxPyBeginAllowThreads();
16844 (arg1)->SetButtonChange(arg2);
16845 wxPyEndAllowThreads(__tstate);
16846 if (PyErr_Occurred()) SWIG_fail;
16847 }
16848 resultobj = SWIG_Py_Void();
16849 return resultobj;
16850 fail:
16851 return NULL;
16852 }
16853
16854
16855 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16856 PyObject *resultobj = 0;
16857 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16858 wxPoint *arg2 = 0 ;
16859 void *argp1 = 0 ;
16860 int res1 = 0 ;
16861 wxPoint temp2 ;
16862 PyObject * obj0 = 0 ;
16863 PyObject * obj1 = 0 ;
16864 char * kwnames[] = {
16865 (char *) "self",(char *) "pos", NULL
16866 };
16867
16868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16870 if (!SWIG_IsOK(res1)) {
16871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16872 }
16873 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16874 {
16875 arg2 = &temp2;
16876 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16877 }
16878 {
16879 PyThreadState* __tstate = wxPyBeginAllowThreads();
16880 (arg1)->SetPosition((wxPoint const &)*arg2);
16881 wxPyEndAllowThreads(__tstate);
16882 if (PyErr_Occurred()) SWIG_fail;
16883 }
16884 resultobj = SWIG_Py_Void();
16885 return resultobj;
16886 fail:
16887 return NULL;
16888 }
16889
16890
16891 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16892 PyObject *resultobj = 0;
16893 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16894 int arg2 ;
16895 void *argp1 = 0 ;
16896 int res1 = 0 ;
16897 int val2 ;
16898 int ecode2 = 0 ;
16899 PyObject * obj0 = 0 ;
16900 PyObject * obj1 = 0 ;
16901 char * kwnames[] = {
16902 (char *) "self",(char *) "zPos", NULL
16903 };
16904
16905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16907 if (!SWIG_IsOK(res1)) {
16908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16909 }
16910 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16911 ecode2 = SWIG_AsVal_int(obj1, &val2);
16912 if (!SWIG_IsOK(ecode2)) {
16913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16914 }
16915 arg2 = static_cast< int >(val2);
16916 {
16917 PyThreadState* __tstate = wxPyBeginAllowThreads();
16918 (arg1)->SetZPosition(arg2);
16919 wxPyEndAllowThreads(__tstate);
16920 if (PyErr_Occurred()) SWIG_fail;
16921 }
16922 resultobj = SWIG_Py_Void();
16923 return resultobj;
16924 fail:
16925 return NULL;
16926 }
16927
16928
16929 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16930 PyObject *resultobj = 0;
16931 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16932 bool result;
16933 void *argp1 = 0 ;
16934 int res1 = 0 ;
16935 PyObject *swig_obj[1] ;
16936
16937 if (!args) SWIG_fail;
16938 swig_obj[0] = args;
16939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16940 if (!SWIG_IsOK(res1)) {
16941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16942 }
16943 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16944 {
16945 PyThreadState* __tstate = wxPyBeginAllowThreads();
16946 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16947 wxPyEndAllowThreads(__tstate);
16948 if (PyErr_Occurred()) SWIG_fail;
16949 }
16950 {
16951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16952 }
16953 return resultobj;
16954 fail:
16955 return NULL;
16956 }
16957
16958
16959 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16960 PyObject *resultobj = 0;
16961 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16962 bool result;
16963 void *argp1 = 0 ;
16964 int res1 = 0 ;
16965 PyObject *swig_obj[1] ;
16966
16967 if (!args) SWIG_fail;
16968 swig_obj[0] = args;
16969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16970 if (!SWIG_IsOK(res1)) {
16971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16972 }
16973 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16974 {
16975 PyThreadState* __tstate = wxPyBeginAllowThreads();
16976 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16977 wxPyEndAllowThreads(__tstate);
16978 if (PyErr_Occurred()) SWIG_fail;
16979 }
16980 {
16981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16982 }
16983 return resultobj;
16984 fail:
16985 return NULL;
16986 }
16987
16988
16989 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16990 PyObject *resultobj = 0;
16991 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16992 bool result;
16993 void *argp1 = 0 ;
16994 int res1 = 0 ;
16995 PyObject *swig_obj[1] ;
16996
16997 if (!args) SWIG_fail;
16998 swig_obj[0] = args;
16999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17000 if (!SWIG_IsOK(res1)) {
17001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17002 }
17003 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17004 {
17005 PyThreadState* __tstate = wxPyBeginAllowThreads();
17006 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
17007 wxPyEndAllowThreads(__tstate);
17008 if (PyErr_Occurred()) SWIG_fail;
17009 }
17010 {
17011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17012 }
17013 return resultobj;
17014 fail:
17015 return NULL;
17016 }
17017
17018
17019 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17020 PyObject *resultobj = 0;
17021 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17022 int arg2 = (int) wxJOY_BUTTON_ANY ;
17023 bool result;
17024 void *argp1 = 0 ;
17025 int res1 = 0 ;
17026 int val2 ;
17027 int ecode2 = 0 ;
17028 PyObject * obj0 = 0 ;
17029 PyObject * obj1 = 0 ;
17030 char * kwnames[] = {
17031 (char *) "self",(char *) "but", NULL
17032 };
17033
17034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
17035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17036 if (!SWIG_IsOK(res1)) {
17037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17038 }
17039 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17040 if (obj1) {
17041 ecode2 = SWIG_AsVal_int(obj1, &val2);
17042 if (!SWIG_IsOK(ecode2)) {
17043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
17044 }
17045 arg2 = static_cast< int >(val2);
17046 }
17047 {
17048 PyThreadState* __tstate = wxPyBeginAllowThreads();
17049 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
17050 wxPyEndAllowThreads(__tstate);
17051 if (PyErr_Occurred()) SWIG_fail;
17052 }
17053 {
17054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17055 }
17056 return resultobj;
17057 fail:
17058 return NULL;
17059 }
17060
17061
17062 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17063 PyObject *resultobj = 0;
17064 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17065 int arg2 = (int) wxJOY_BUTTON_ANY ;
17066 bool result;
17067 void *argp1 = 0 ;
17068 int res1 = 0 ;
17069 int val2 ;
17070 int ecode2 = 0 ;
17071 PyObject * obj0 = 0 ;
17072 PyObject * obj1 = 0 ;
17073 char * kwnames[] = {
17074 (char *) "self",(char *) "but", NULL
17075 };
17076
17077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
17078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17079 if (!SWIG_IsOK(res1)) {
17080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17081 }
17082 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17083 if (obj1) {
17084 ecode2 = SWIG_AsVal_int(obj1, &val2);
17085 if (!SWIG_IsOK(ecode2)) {
17086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
17087 }
17088 arg2 = static_cast< int >(val2);
17089 }
17090 {
17091 PyThreadState* __tstate = wxPyBeginAllowThreads();
17092 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
17093 wxPyEndAllowThreads(__tstate);
17094 if (PyErr_Occurred()) SWIG_fail;
17095 }
17096 {
17097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17098 }
17099 return resultobj;
17100 fail:
17101 return NULL;
17102 }
17103
17104
17105 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17106 PyObject *resultobj = 0;
17107 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17108 int arg2 = (int) wxJOY_BUTTON_ANY ;
17109 bool result;
17110 void *argp1 = 0 ;
17111 int res1 = 0 ;
17112 int val2 ;
17113 int ecode2 = 0 ;
17114 PyObject * obj0 = 0 ;
17115 PyObject * obj1 = 0 ;
17116 char * kwnames[] = {
17117 (char *) "self",(char *) "but", NULL
17118 };
17119
17120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17122 if (!SWIG_IsOK(res1)) {
17123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17124 }
17125 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17126 if (obj1) {
17127 ecode2 = SWIG_AsVal_int(obj1, &val2);
17128 if (!SWIG_IsOK(ecode2)) {
17129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17130 }
17131 arg2 = static_cast< int >(val2);
17132 }
17133 {
17134 PyThreadState* __tstate = wxPyBeginAllowThreads();
17135 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17136 wxPyEndAllowThreads(__tstate);
17137 if (PyErr_Occurred()) SWIG_fail;
17138 }
17139 {
17140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17141 }
17142 return resultobj;
17143 fail:
17144 return NULL;
17145 }
17146
17147
17148 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17149 PyObject *obj;
17150 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17151 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17152 return SWIG_Py_Void();
17153 }
17154
17155 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17156 return SWIG_Python_InitShadowInstance(args);
17157 }
17158
17159 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17160 PyObject *resultobj = 0;
17161 wxString const &arg1_defvalue = wxPyEmptyString ;
17162 wxString *arg1 = (wxString *) &arg1_defvalue ;
17163 wxSound *result = 0 ;
17164 bool temp1 = false ;
17165 PyObject * obj0 = 0 ;
17166 char * kwnames[] = {
17167 (char *) "fileName", NULL
17168 };
17169
17170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17171 if (obj0) {
17172 {
17173 arg1 = wxString_in_helper(obj0);
17174 if (arg1 == NULL) SWIG_fail;
17175 temp1 = true;
17176 }
17177 }
17178 {
17179 if (!wxPyCheckForApp()) SWIG_fail;
17180 PyThreadState* __tstate = wxPyBeginAllowThreads();
17181 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17182 wxPyEndAllowThreads(__tstate);
17183 if (PyErr_Occurred()) SWIG_fail;
17184 }
17185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17186 {
17187 if (temp1)
17188 delete arg1;
17189 }
17190 return resultobj;
17191 fail:
17192 {
17193 if (temp1)
17194 delete arg1;
17195 }
17196 return NULL;
17197 }
17198
17199
17200 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17201 PyObject *resultobj = 0;
17202 PyObject *arg1 = (PyObject *) 0 ;
17203 wxSound *result = 0 ;
17204 PyObject * obj0 = 0 ;
17205 char * kwnames[] = {
17206 (char *) "data", NULL
17207 };
17208
17209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17210 arg1 = obj0;
17211 {
17212 if (!wxPyCheckForApp()) SWIG_fail;
17213 PyThreadState* __tstate = wxPyBeginAllowThreads();
17214 result = (wxSound *)new_wxSound(arg1);
17215 wxPyEndAllowThreads(__tstate);
17216 if (PyErr_Occurred()) SWIG_fail;
17217 }
17218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17219 return resultobj;
17220 fail:
17221 return NULL;
17222 }
17223
17224
17225 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17226 PyObject *resultobj = 0;
17227 wxSound *arg1 = (wxSound *) 0 ;
17228 void *argp1 = 0 ;
17229 int res1 = 0 ;
17230 PyObject *swig_obj[1] ;
17231
17232 if (!args) SWIG_fail;
17233 swig_obj[0] = args;
17234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17235 if (!SWIG_IsOK(res1)) {
17236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17237 }
17238 arg1 = reinterpret_cast< wxSound * >(argp1);
17239 {
17240 PyThreadState* __tstate = wxPyBeginAllowThreads();
17241 delete arg1;
17242
17243 wxPyEndAllowThreads(__tstate);
17244 if (PyErr_Occurred()) SWIG_fail;
17245 }
17246 resultobj = SWIG_Py_Void();
17247 return resultobj;
17248 fail:
17249 return NULL;
17250 }
17251
17252
17253 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17254 PyObject *resultobj = 0;
17255 wxSound *arg1 = (wxSound *) 0 ;
17256 wxString *arg2 = 0 ;
17257 bool result;
17258 void *argp1 = 0 ;
17259 int res1 = 0 ;
17260 bool temp2 = false ;
17261 PyObject * obj0 = 0 ;
17262 PyObject * obj1 = 0 ;
17263 char * kwnames[] = {
17264 (char *) "self",(char *) "fileName", NULL
17265 };
17266
17267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17269 if (!SWIG_IsOK(res1)) {
17270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17271 }
17272 arg1 = reinterpret_cast< wxSound * >(argp1);
17273 {
17274 arg2 = wxString_in_helper(obj1);
17275 if (arg2 == NULL) SWIG_fail;
17276 temp2 = true;
17277 }
17278 {
17279 PyThreadState* __tstate = wxPyBeginAllowThreads();
17280 result = (bool)(arg1)->Create((wxString const &)*arg2);
17281 wxPyEndAllowThreads(__tstate);
17282 if (PyErr_Occurred()) SWIG_fail;
17283 }
17284 {
17285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17286 }
17287 {
17288 if (temp2)
17289 delete arg2;
17290 }
17291 return resultobj;
17292 fail:
17293 {
17294 if (temp2)
17295 delete arg2;
17296 }
17297 return NULL;
17298 }
17299
17300
17301 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17302 PyObject *resultobj = 0;
17303 wxSound *arg1 = (wxSound *) 0 ;
17304 PyObject *arg2 = (PyObject *) 0 ;
17305 bool result;
17306 void *argp1 = 0 ;
17307 int res1 = 0 ;
17308 PyObject * obj0 = 0 ;
17309 PyObject * obj1 = 0 ;
17310 char * kwnames[] = {
17311 (char *) "self",(char *) "data", NULL
17312 };
17313
17314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17316 if (!SWIG_IsOK(res1)) {
17317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17318 }
17319 arg1 = reinterpret_cast< wxSound * >(argp1);
17320 arg2 = obj1;
17321 {
17322 PyThreadState* __tstate = wxPyBeginAllowThreads();
17323 result = (bool)wxSound_CreateFromData(arg1,arg2);
17324 wxPyEndAllowThreads(__tstate);
17325 if (PyErr_Occurred()) SWIG_fail;
17326 }
17327 {
17328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17329 }
17330 return resultobj;
17331 fail:
17332 return NULL;
17333 }
17334
17335
17336 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17337 PyObject *resultobj = 0;
17338 wxSound *arg1 = (wxSound *) 0 ;
17339 bool result;
17340 void *argp1 = 0 ;
17341 int res1 = 0 ;
17342 PyObject *swig_obj[1] ;
17343
17344 if (!args) SWIG_fail;
17345 swig_obj[0] = args;
17346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17347 if (!SWIG_IsOK(res1)) {
17348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17349 }
17350 arg1 = reinterpret_cast< wxSound * >(argp1);
17351 {
17352 PyThreadState* __tstate = wxPyBeginAllowThreads();
17353 result = (bool)(arg1)->IsOk();
17354 wxPyEndAllowThreads(__tstate);
17355 if (PyErr_Occurred()) SWIG_fail;
17356 }
17357 {
17358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17359 }
17360 return resultobj;
17361 fail:
17362 return NULL;
17363 }
17364
17365
17366 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17367 PyObject *resultobj = 0;
17368 wxSound *arg1 = (wxSound *) 0 ;
17369 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17370 bool result;
17371 void *argp1 = 0 ;
17372 int res1 = 0 ;
17373 unsigned int val2 ;
17374 int ecode2 = 0 ;
17375 PyObject * obj0 = 0 ;
17376 PyObject * obj1 = 0 ;
17377 char * kwnames[] = {
17378 (char *) "self",(char *) "flags", NULL
17379 };
17380
17381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17383 if (!SWIG_IsOK(res1)) {
17384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17385 }
17386 arg1 = reinterpret_cast< wxSound * >(argp1);
17387 if (obj1) {
17388 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17389 if (!SWIG_IsOK(ecode2)) {
17390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17391 }
17392 arg2 = static_cast< unsigned int >(val2);
17393 }
17394 {
17395 if (!wxPyCheckForApp()) SWIG_fail;
17396 PyThreadState* __tstate = wxPyBeginAllowThreads();
17397 result = (bool)((wxSound const *)arg1)->Play(arg2);
17398 wxPyEndAllowThreads(__tstate);
17399 if (PyErr_Occurred()) SWIG_fail;
17400 }
17401 {
17402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17403 }
17404 return resultobj;
17405 fail:
17406 return NULL;
17407 }
17408
17409
17410 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17411 PyObject *resultobj = 0;
17412 wxString *arg1 = 0 ;
17413 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17414 bool result;
17415 bool temp1 = false ;
17416 unsigned int val2 ;
17417 int ecode2 = 0 ;
17418 PyObject * obj0 = 0 ;
17419 PyObject * obj1 = 0 ;
17420 char * kwnames[] = {
17421 (char *) "filename",(char *) "flags", NULL
17422 };
17423
17424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17425 {
17426 arg1 = wxString_in_helper(obj0);
17427 if (arg1 == NULL) SWIG_fail;
17428 temp1 = true;
17429 }
17430 if (obj1) {
17431 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17432 if (!SWIG_IsOK(ecode2)) {
17433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17434 }
17435 arg2 = static_cast< unsigned int >(val2);
17436 }
17437 {
17438 if (!wxPyCheckForApp()) SWIG_fail;
17439 PyThreadState* __tstate = wxPyBeginAllowThreads();
17440 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17441 wxPyEndAllowThreads(__tstate);
17442 if (PyErr_Occurred()) SWIG_fail;
17443 }
17444 {
17445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17446 }
17447 {
17448 if (temp1)
17449 delete arg1;
17450 }
17451 return resultobj;
17452 fail:
17453 {
17454 if (temp1)
17455 delete arg1;
17456 }
17457 return NULL;
17458 }
17459
17460
17461 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17462 PyObject *resultobj = 0;
17463
17464 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17465 {
17466 if (!wxPyCheckForApp()) SWIG_fail;
17467 PyThreadState* __tstate = wxPyBeginAllowThreads();
17468 wxSound::Stop();
17469 wxPyEndAllowThreads(__tstate);
17470 if (PyErr_Occurred()) SWIG_fail;
17471 }
17472 resultobj = SWIG_Py_Void();
17473 return resultobj;
17474 fail:
17475 return NULL;
17476 }
17477
17478
17479 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17480 PyObject *obj;
17481 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17482 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17483 return SWIG_Py_Void();
17484 }
17485
17486 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17487 return SWIG_Python_InitShadowInstance(args);
17488 }
17489
17490 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17491 PyObject *resultobj = 0;
17492 wxString *arg1 = 0 ;
17493 wxString *arg2 = 0 ;
17494 wxString *arg3 = 0 ;
17495 wxString *arg4 = 0 ;
17496 wxFileTypeInfo *result = 0 ;
17497 bool temp1 = false ;
17498 bool temp2 = false ;
17499 bool temp3 = false ;
17500 bool temp4 = false ;
17501 PyObject * obj0 = 0 ;
17502 PyObject * obj1 = 0 ;
17503 PyObject * obj2 = 0 ;
17504 PyObject * obj3 = 0 ;
17505 char * kwnames[] = {
17506 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17507 };
17508
17509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17510 {
17511 arg1 = wxString_in_helper(obj0);
17512 if (arg1 == NULL) SWIG_fail;
17513 temp1 = true;
17514 }
17515 {
17516 arg2 = wxString_in_helper(obj1);
17517 if (arg2 == NULL) SWIG_fail;
17518 temp2 = true;
17519 }
17520 {
17521 arg3 = wxString_in_helper(obj2);
17522 if (arg3 == NULL) SWIG_fail;
17523 temp3 = true;
17524 }
17525 {
17526 arg4 = wxString_in_helper(obj3);
17527 if (arg4 == NULL) SWIG_fail;
17528 temp4 = true;
17529 }
17530 {
17531 PyThreadState* __tstate = wxPyBeginAllowThreads();
17532 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17533 wxPyEndAllowThreads(__tstate);
17534 if (PyErr_Occurred()) SWIG_fail;
17535 }
17536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17537 {
17538 if (temp1)
17539 delete arg1;
17540 }
17541 {
17542 if (temp2)
17543 delete arg2;
17544 }
17545 {
17546 if (temp3)
17547 delete arg3;
17548 }
17549 {
17550 if (temp4)
17551 delete arg4;
17552 }
17553 return resultobj;
17554 fail:
17555 {
17556 if (temp1)
17557 delete arg1;
17558 }
17559 {
17560 if (temp2)
17561 delete arg2;
17562 }
17563 {
17564 if (temp3)
17565 delete arg3;
17566 }
17567 {
17568 if (temp4)
17569 delete arg4;
17570 }
17571 return NULL;
17572 }
17573
17574
17575 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17576 PyObject *resultobj = 0;
17577 wxArrayString *arg1 = 0 ;
17578 wxFileTypeInfo *result = 0 ;
17579 bool temp1 = false ;
17580 PyObject * obj0 = 0 ;
17581 char * kwnames[] = {
17582 (char *) "sArray", NULL
17583 };
17584
17585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17586 {
17587 if (! PySequence_Check(obj0)) {
17588 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17589 SWIG_fail;
17590 }
17591 arg1 = new wxArrayString;
17592 temp1 = true;
17593 int i, len=PySequence_Length(obj0);
17594 for (i=0; i<len; i++) {
17595 PyObject* item = PySequence_GetItem(obj0, i);
17596 wxString* s = wxString_in_helper(item);
17597 if (PyErr_Occurred()) SWIG_fail;
17598 arg1->Add(*s);
17599 delete s;
17600 Py_DECREF(item);
17601 }
17602 }
17603 {
17604 PyThreadState* __tstate = wxPyBeginAllowThreads();
17605 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17606 wxPyEndAllowThreads(__tstate);
17607 if (PyErr_Occurred()) SWIG_fail;
17608 }
17609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17610 {
17611 if (temp1) delete arg1;
17612 }
17613 return resultobj;
17614 fail:
17615 {
17616 if (temp1) delete arg1;
17617 }
17618 return NULL;
17619 }
17620
17621
17622 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17623 PyObject *resultobj = 0;
17624 wxFileTypeInfo *result = 0 ;
17625
17626 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17627 {
17628 PyThreadState* __tstate = wxPyBeginAllowThreads();
17629 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17630 wxPyEndAllowThreads(__tstate);
17631 if (PyErr_Occurred()) SWIG_fail;
17632 }
17633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17634 return resultobj;
17635 fail:
17636 return NULL;
17637 }
17638
17639
17640 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17641 PyObject *resultobj = 0;
17642 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17643 bool result;
17644 void *argp1 = 0 ;
17645 int res1 = 0 ;
17646 PyObject *swig_obj[1] ;
17647
17648 if (!args) SWIG_fail;
17649 swig_obj[0] = args;
17650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17651 if (!SWIG_IsOK(res1)) {
17652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17653 }
17654 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17655 {
17656 PyThreadState* __tstate = wxPyBeginAllowThreads();
17657 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17658 wxPyEndAllowThreads(__tstate);
17659 if (PyErr_Occurred()) SWIG_fail;
17660 }
17661 {
17662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17663 }
17664 return resultobj;
17665 fail:
17666 return NULL;
17667 }
17668
17669
17670 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17671 PyObject *resultobj = 0;
17672 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17673 wxString *arg2 = 0 ;
17674 int arg3 = (int) 0 ;
17675 void *argp1 = 0 ;
17676 int res1 = 0 ;
17677 bool temp2 = false ;
17678 int val3 ;
17679 int ecode3 = 0 ;
17680 PyObject * obj0 = 0 ;
17681 PyObject * obj1 = 0 ;
17682 PyObject * obj2 = 0 ;
17683 char * kwnames[] = {
17684 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17685 };
17686
17687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17689 if (!SWIG_IsOK(res1)) {
17690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17691 }
17692 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17693 {
17694 arg2 = wxString_in_helper(obj1);
17695 if (arg2 == NULL) SWIG_fail;
17696 temp2 = true;
17697 }
17698 if (obj2) {
17699 ecode3 = SWIG_AsVal_int(obj2, &val3);
17700 if (!SWIG_IsOK(ecode3)) {
17701 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17702 }
17703 arg3 = static_cast< int >(val3);
17704 }
17705 {
17706 PyThreadState* __tstate = wxPyBeginAllowThreads();
17707 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17708 wxPyEndAllowThreads(__tstate);
17709 if (PyErr_Occurred()) SWIG_fail;
17710 }
17711 resultobj = SWIG_Py_Void();
17712 {
17713 if (temp2)
17714 delete arg2;
17715 }
17716 return resultobj;
17717 fail:
17718 {
17719 if (temp2)
17720 delete arg2;
17721 }
17722 return NULL;
17723 }
17724
17725
17726 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17727 PyObject *resultobj = 0;
17728 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17729 wxString *arg2 = 0 ;
17730 void *argp1 = 0 ;
17731 int res1 = 0 ;
17732 bool temp2 = false ;
17733 PyObject * obj0 = 0 ;
17734 PyObject * obj1 = 0 ;
17735 char * kwnames[] = {
17736 (char *) "self",(char *) "shortDesc", NULL
17737 };
17738
17739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17741 if (!SWIG_IsOK(res1)) {
17742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17743 }
17744 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17745 {
17746 arg2 = wxString_in_helper(obj1);
17747 if (arg2 == NULL) SWIG_fail;
17748 temp2 = true;
17749 }
17750 {
17751 PyThreadState* __tstate = wxPyBeginAllowThreads();
17752 (arg1)->SetShortDesc((wxString const &)*arg2);
17753 wxPyEndAllowThreads(__tstate);
17754 if (PyErr_Occurred()) SWIG_fail;
17755 }
17756 resultobj = SWIG_Py_Void();
17757 {
17758 if (temp2)
17759 delete arg2;
17760 }
17761 return resultobj;
17762 fail:
17763 {
17764 if (temp2)
17765 delete arg2;
17766 }
17767 return NULL;
17768 }
17769
17770
17771 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17772 PyObject *resultobj = 0;
17773 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17774 wxString *result = 0 ;
17775 void *argp1 = 0 ;
17776 int res1 = 0 ;
17777 PyObject *swig_obj[1] ;
17778
17779 if (!args) SWIG_fail;
17780 swig_obj[0] = args;
17781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17782 if (!SWIG_IsOK(res1)) {
17783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17784 }
17785 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17786 {
17787 PyThreadState* __tstate = wxPyBeginAllowThreads();
17788 {
17789 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17790 result = (wxString *) &_result_ref;
17791 }
17792 wxPyEndAllowThreads(__tstate);
17793 if (PyErr_Occurred()) SWIG_fail;
17794 }
17795 {
17796 #if wxUSE_UNICODE
17797 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17798 #else
17799 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17800 #endif
17801 }
17802 return resultobj;
17803 fail:
17804 return NULL;
17805 }
17806
17807
17808 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17809 PyObject *resultobj = 0;
17810 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17811 wxString *result = 0 ;
17812 void *argp1 = 0 ;
17813 int res1 = 0 ;
17814 PyObject *swig_obj[1] ;
17815
17816 if (!args) SWIG_fail;
17817 swig_obj[0] = args;
17818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17819 if (!SWIG_IsOK(res1)) {
17820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17821 }
17822 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17823 {
17824 PyThreadState* __tstate = wxPyBeginAllowThreads();
17825 {
17826 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17827 result = (wxString *) &_result_ref;
17828 }
17829 wxPyEndAllowThreads(__tstate);
17830 if (PyErr_Occurred()) SWIG_fail;
17831 }
17832 {
17833 #if wxUSE_UNICODE
17834 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17835 #else
17836 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17837 #endif
17838 }
17839 return resultobj;
17840 fail:
17841 return NULL;
17842 }
17843
17844
17845 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17846 PyObject *resultobj = 0;
17847 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17848 wxString *result = 0 ;
17849 void *argp1 = 0 ;
17850 int res1 = 0 ;
17851 PyObject *swig_obj[1] ;
17852
17853 if (!args) SWIG_fail;
17854 swig_obj[0] = args;
17855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17856 if (!SWIG_IsOK(res1)) {
17857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17858 }
17859 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17860 {
17861 PyThreadState* __tstate = wxPyBeginAllowThreads();
17862 {
17863 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17864 result = (wxString *) &_result_ref;
17865 }
17866 wxPyEndAllowThreads(__tstate);
17867 if (PyErr_Occurred()) SWIG_fail;
17868 }
17869 {
17870 #if wxUSE_UNICODE
17871 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17872 #else
17873 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17874 #endif
17875 }
17876 return resultobj;
17877 fail:
17878 return NULL;
17879 }
17880
17881
17882 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17883 PyObject *resultobj = 0;
17884 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17885 wxString *result = 0 ;
17886 void *argp1 = 0 ;
17887 int res1 = 0 ;
17888 PyObject *swig_obj[1] ;
17889
17890 if (!args) SWIG_fail;
17891 swig_obj[0] = args;
17892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17893 if (!SWIG_IsOK(res1)) {
17894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17895 }
17896 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17897 {
17898 PyThreadState* __tstate = wxPyBeginAllowThreads();
17899 {
17900 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17901 result = (wxString *) &_result_ref;
17902 }
17903 wxPyEndAllowThreads(__tstate);
17904 if (PyErr_Occurred()) SWIG_fail;
17905 }
17906 {
17907 #if wxUSE_UNICODE
17908 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17909 #else
17910 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17911 #endif
17912 }
17913 return resultobj;
17914 fail:
17915 return NULL;
17916 }
17917
17918
17919 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17920 PyObject *resultobj = 0;
17921 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17922 wxString *result = 0 ;
17923 void *argp1 = 0 ;
17924 int res1 = 0 ;
17925 PyObject *swig_obj[1] ;
17926
17927 if (!args) SWIG_fail;
17928 swig_obj[0] = args;
17929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17930 if (!SWIG_IsOK(res1)) {
17931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17932 }
17933 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17934 {
17935 PyThreadState* __tstate = wxPyBeginAllowThreads();
17936 {
17937 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17938 result = (wxString *) &_result_ref;
17939 }
17940 wxPyEndAllowThreads(__tstate);
17941 if (PyErr_Occurred()) SWIG_fail;
17942 }
17943 {
17944 #if wxUSE_UNICODE
17945 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17946 #else
17947 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17948 #endif
17949 }
17950 return resultobj;
17951 fail:
17952 return NULL;
17953 }
17954
17955
17956 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17957 PyObject *resultobj = 0;
17958 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17959 wxArrayString *result = 0 ;
17960 void *argp1 = 0 ;
17961 int res1 = 0 ;
17962 PyObject *swig_obj[1] ;
17963
17964 if (!args) SWIG_fail;
17965 swig_obj[0] = args;
17966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17967 if (!SWIG_IsOK(res1)) {
17968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17969 }
17970 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17971 {
17972 PyThreadState* __tstate = wxPyBeginAllowThreads();
17973 {
17974 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17975 result = (wxArrayString *) &_result_ref;
17976 }
17977 wxPyEndAllowThreads(__tstate);
17978 if (PyErr_Occurred()) SWIG_fail;
17979 }
17980 {
17981 resultobj = wxArrayString2PyList_helper(*result);
17982 }
17983 return resultobj;
17984 fail:
17985 return NULL;
17986 }
17987
17988
17989 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17990 PyObject *resultobj = 0;
17991 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17992 size_t result;
17993 void *argp1 = 0 ;
17994 int res1 = 0 ;
17995 PyObject *swig_obj[1] ;
17996
17997 if (!args) SWIG_fail;
17998 swig_obj[0] = args;
17999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18000 if (!SWIG_IsOK(res1)) {
18001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18002 }
18003 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18004 {
18005 PyThreadState* __tstate = wxPyBeginAllowThreads();
18006 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
18007 wxPyEndAllowThreads(__tstate);
18008 if (PyErr_Occurred()) SWIG_fail;
18009 }
18010 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
18011 return resultobj;
18012 fail:
18013 return NULL;
18014 }
18015
18016
18017 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18018 PyObject *resultobj = 0;
18019 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18020 wxString *result = 0 ;
18021 void *argp1 = 0 ;
18022 int res1 = 0 ;
18023 PyObject *swig_obj[1] ;
18024
18025 if (!args) SWIG_fail;
18026 swig_obj[0] = args;
18027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18028 if (!SWIG_IsOK(res1)) {
18029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18030 }
18031 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18032 {
18033 PyThreadState* __tstate = wxPyBeginAllowThreads();
18034 {
18035 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
18036 result = (wxString *) &_result_ref;
18037 }
18038 wxPyEndAllowThreads(__tstate);
18039 if (PyErr_Occurred()) SWIG_fail;
18040 }
18041 {
18042 #if wxUSE_UNICODE
18043 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18044 #else
18045 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18046 #endif
18047 }
18048 return resultobj;
18049 fail:
18050 return NULL;
18051 }
18052
18053
18054 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18055 PyObject *resultobj = 0;
18056 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18057 int result;
18058 void *argp1 = 0 ;
18059 int res1 = 0 ;
18060 PyObject *swig_obj[1] ;
18061
18062 if (!args) SWIG_fail;
18063 swig_obj[0] = args;
18064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18065 if (!SWIG_IsOK(res1)) {
18066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18067 }
18068 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18069 {
18070 PyThreadState* __tstate = wxPyBeginAllowThreads();
18071 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
18072 wxPyEndAllowThreads(__tstate);
18073 if (PyErr_Occurred()) SWIG_fail;
18074 }
18075 resultobj = SWIG_From_int(static_cast< int >(result));
18076 return resultobj;
18077 fail:
18078 return NULL;
18079 }
18080
18081
18082 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18083 PyObject *obj;
18084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18085 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
18086 return SWIG_Py_Void();
18087 }
18088
18089 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18090 return SWIG_Python_InitShadowInstance(args);
18091 }
18092
18093 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18094 PyObject *resultobj = 0;
18095 wxFileTypeInfo *arg1 = 0 ;
18096 wxFileType *result = 0 ;
18097 void *argp1 = 0 ;
18098 int res1 = 0 ;
18099 PyObject * obj0 = 0 ;
18100 char * kwnames[] = {
18101 (char *) "ftInfo", NULL
18102 };
18103
18104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18105 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18106 if (!SWIG_IsOK(res1)) {
18107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18108 }
18109 if (!argp1) {
18110 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18111 }
18112 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18113 {
18114 PyThreadState* __tstate = wxPyBeginAllowThreads();
18115 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18116 wxPyEndAllowThreads(__tstate);
18117 if (PyErr_Occurred()) SWIG_fail;
18118 }
18119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18120 return resultobj;
18121 fail:
18122 return NULL;
18123 }
18124
18125
18126 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18127 PyObject *resultobj = 0;
18128 wxFileType *arg1 = (wxFileType *) 0 ;
18129 void *argp1 = 0 ;
18130 int res1 = 0 ;
18131 PyObject *swig_obj[1] ;
18132
18133 if (!args) SWIG_fail;
18134 swig_obj[0] = args;
18135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18136 if (!SWIG_IsOK(res1)) {
18137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18138 }
18139 arg1 = reinterpret_cast< wxFileType * >(argp1);
18140 {
18141 PyThreadState* __tstate = wxPyBeginAllowThreads();
18142 delete arg1;
18143
18144 wxPyEndAllowThreads(__tstate);
18145 if (PyErr_Occurred()) SWIG_fail;
18146 }
18147 resultobj = SWIG_Py_Void();
18148 return resultobj;
18149 fail:
18150 return NULL;
18151 }
18152
18153
18154 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18155 PyObject *resultobj = 0;
18156 wxFileType *arg1 = (wxFileType *) 0 ;
18157 PyObject *result = 0 ;
18158 void *argp1 = 0 ;
18159 int res1 = 0 ;
18160 PyObject *swig_obj[1] ;
18161
18162 if (!args) SWIG_fail;
18163 swig_obj[0] = args;
18164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18165 if (!SWIG_IsOK(res1)) {
18166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18167 }
18168 arg1 = reinterpret_cast< wxFileType * >(argp1);
18169 {
18170 PyThreadState* __tstate = wxPyBeginAllowThreads();
18171 result = (PyObject *)wxFileType_GetMimeType(arg1);
18172 wxPyEndAllowThreads(__tstate);
18173 if (PyErr_Occurred()) SWIG_fail;
18174 }
18175 resultobj = result;
18176 return resultobj;
18177 fail:
18178 return NULL;
18179 }
18180
18181
18182 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18183 PyObject *resultobj = 0;
18184 wxFileType *arg1 = (wxFileType *) 0 ;
18185 PyObject *result = 0 ;
18186 void *argp1 = 0 ;
18187 int res1 = 0 ;
18188 PyObject *swig_obj[1] ;
18189
18190 if (!args) SWIG_fail;
18191 swig_obj[0] = args;
18192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18193 if (!SWIG_IsOK(res1)) {
18194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18195 }
18196 arg1 = reinterpret_cast< wxFileType * >(argp1);
18197 {
18198 PyThreadState* __tstate = wxPyBeginAllowThreads();
18199 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18200 wxPyEndAllowThreads(__tstate);
18201 if (PyErr_Occurred()) SWIG_fail;
18202 }
18203 resultobj = result;
18204 return resultobj;
18205 fail:
18206 return NULL;
18207 }
18208
18209
18210 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18211 PyObject *resultobj = 0;
18212 wxFileType *arg1 = (wxFileType *) 0 ;
18213 PyObject *result = 0 ;
18214 void *argp1 = 0 ;
18215 int res1 = 0 ;
18216 PyObject *swig_obj[1] ;
18217
18218 if (!args) SWIG_fail;
18219 swig_obj[0] = args;
18220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18221 if (!SWIG_IsOK(res1)) {
18222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18223 }
18224 arg1 = reinterpret_cast< wxFileType * >(argp1);
18225 {
18226 PyThreadState* __tstate = wxPyBeginAllowThreads();
18227 result = (PyObject *)wxFileType_GetExtensions(arg1);
18228 wxPyEndAllowThreads(__tstate);
18229 if (PyErr_Occurred()) SWIG_fail;
18230 }
18231 resultobj = result;
18232 return resultobj;
18233 fail:
18234 return NULL;
18235 }
18236
18237
18238 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18239 PyObject *resultobj = 0;
18240 wxFileType *arg1 = (wxFileType *) 0 ;
18241 wxIcon *result = 0 ;
18242 void *argp1 = 0 ;
18243 int res1 = 0 ;
18244 PyObject *swig_obj[1] ;
18245
18246 if (!args) SWIG_fail;
18247 swig_obj[0] = args;
18248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18249 if (!SWIG_IsOK(res1)) {
18250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18251 }
18252 arg1 = reinterpret_cast< wxFileType * >(argp1);
18253 {
18254 PyThreadState* __tstate = wxPyBeginAllowThreads();
18255 result = (wxIcon *)wxFileType_GetIcon(arg1);
18256 wxPyEndAllowThreads(__tstate);
18257 if (PyErr_Occurred()) SWIG_fail;
18258 }
18259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18260 return resultobj;
18261 fail:
18262 return NULL;
18263 }
18264
18265
18266 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18267 PyObject *resultobj = 0;
18268 wxFileType *arg1 = (wxFileType *) 0 ;
18269 PyObject *result = 0 ;
18270 void *argp1 = 0 ;
18271 int res1 = 0 ;
18272 PyObject *swig_obj[1] ;
18273
18274 if (!args) SWIG_fail;
18275 swig_obj[0] = args;
18276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18277 if (!SWIG_IsOK(res1)) {
18278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18279 }
18280 arg1 = reinterpret_cast< wxFileType * >(argp1);
18281 {
18282 PyThreadState* __tstate = wxPyBeginAllowThreads();
18283 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18284 wxPyEndAllowThreads(__tstate);
18285 if (PyErr_Occurred()) SWIG_fail;
18286 }
18287 resultobj = result;
18288 return resultobj;
18289 fail:
18290 return NULL;
18291 }
18292
18293
18294 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18295 PyObject *resultobj = 0;
18296 wxFileType *arg1 = (wxFileType *) 0 ;
18297 PyObject *result = 0 ;
18298 void *argp1 = 0 ;
18299 int res1 = 0 ;
18300 PyObject *swig_obj[1] ;
18301
18302 if (!args) SWIG_fail;
18303 swig_obj[0] = args;
18304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18305 if (!SWIG_IsOK(res1)) {
18306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18307 }
18308 arg1 = reinterpret_cast< wxFileType * >(argp1);
18309 {
18310 PyThreadState* __tstate = wxPyBeginAllowThreads();
18311 result = (PyObject *)wxFileType_GetDescription(arg1);
18312 wxPyEndAllowThreads(__tstate);
18313 if (PyErr_Occurred()) SWIG_fail;
18314 }
18315 resultobj = result;
18316 return resultobj;
18317 fail:
18318 return NULL;
18319 }
18320
18321
18322 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18323 PyObject *resultobj = 0;
18324 wxFileType *arg1 = (wxFileType *) 0 ;
18325 wxString *arg2 = 0 ;
18326 wxString const &arg3_defvalue = wxPyEmptyString ;
18327 wxString *arg3 = (wxString *) &arg3_defvalue ;
18328 PyObject *result = 0 ;
18329 void *argp1 = 0 ;
18330 int res1 = 0 ;
18331 bool temp2 = false ;
18332 bool temp3 = false ;
18333 PyObject * obj0 = 0 ;
18334 PyObject * obj1 = 0 ;
18335 PyObject * obj2 = 0 ;
18336 char * kwnames[] = {
18337 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18338 };
18339
18340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18342 if (!SWIG_IsOK(res1)) {
18343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18344 }
18345 arg1 = reinterpret_cast< wxFileType * >(argp1);
18346 {
18347 arg2 = wxString_in_helper(obj1);
18348 if (arg2 == NULL) SWIG_fail;
18349 temp2 = true;
18350 }
18351 if (obj2) {
18352 {
18353 arg3 = wxString_in_helper(obj2);
18354 if (arg3 == NULL) SWIG_fail;
18355 temp3 = true;
18356 }
18357 }
18358 {
18359 PyThreadState* __tstate = wxPyBeginAllowThreads();
18360 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18361 wxPyEndAllowThreads(__tstate);
18362 if (PyErr_Occurred()) SWIG_fail;
18363 }
18364 resultobj = result;
18365 {
18366 if (temp2)
18367 delete arg2;
18368 }
18369 {
18370 if (temp3)
18371 delete arg3;
18372 }
18373 return resultobj;
18374 fail:
18375 {
18376 if (temp2)
18377 delete arg2;
18378 }
18379 {
18380 if (temp3)
18381 delete arg3;
18382 }
18383 return NULL;
18384 }
18385
18386
18387 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18388 PyObject *resultobj = 0;
18389 wxFileType *arg1 = (wxFileType *) 0 ;
18390 wxString *arg2 = 0 ;
18391 wxString const &arg3_defvalue = wxPyEmptyString ;
18392 wxString *arg3 = (wxString *) &arg3_defvalue ;
18393 PyObject *result = 0 ;
18394 void *argp1 = 0 ;
18395 int res1 = 0 ;
18396 bool temp2 = false ;
18397 bool temp3 = false ;
18398 PyObject * obj0 = 0 ;
18399 PyObject * obj1 = 0 ;
18400 PyObject * obj2 = 0 ;
18401 char * kwnames[] = {
18402 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18403 };
18404
18405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18407 if (!SWIG_IsOK(res1)) {
18408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18409 }
18410 arg1 = reinterpret_cast< wxFileType * >(argp1);
18411 {
18412 arg2 = wxString_in_helper(obj1);
18413 if (arg2 == NULL) SWIG_fail;
18414 temp2 = true;
18415 }
18416 if (obj2) {
18417 {
18418 arg3 = wxString_in_helper(obj2);
18419 if (arg3 == NULL) SWIG_fail;
18420 temp3 = true;
18421 }
18422 }
18423 {
18424 PyThreadState* __tstate = wxPyBeginAllowThreads();
18425 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18426 wxPyEndAllowThreads(__tstate);
18427 if (PyErr_Occurred()) SWIG_fail;
18428 }
18429 resultobj = result;
18430 {
18431 if (temp2)
18432 delete arg2;
18433 }
18434 {
18435 if (temp3)
18436 delete arg3;
18437 }
18438 return resultobj;
18439 fail:
18440 {
18441 if (temp2)
18442 delete arg2;
18443 }
18444 {
18445 if (temp3)
18446 delete arg3;
18447 }
18448 return NULL;
18449 }
18450
18451
18452 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18453 PyObject *resultobj = 0;
18454 wxFileType *arg1 = (wxFileType *) 0 ;
18455 wxString *arg2 = 0 ;
18456 wxString const &arg3_defvalue = wxPyEmptyString ;
18457 wxString *arg3 = (wxString *) &arg3_defvalue ;
18458 PyObject *result = 0 ;
18459 void *argp1 = 0 ;
18460 int res1 = 0 ;
18461 bool temp2 = false ;
18462 bool temp3 = false ;
18463 PyObject * obj0 = 0 ;
18464 PyObject * obj1 = 0 ;
18465 PyObject * obj2 = 0 ;
18466 char * kwnames[] = {
18467 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18468 };
18469
18470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18472 if (!SWIG_IsOK(res1)) {
18473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18474 }
18475 arg1 = reinterpret_cast< wxFileType * >(argp1);
18476 {
18477 arg2 = wxString_in_helper(obj1);
18478 if (arg2 == NULL) SWIG_fail;
18479 temp2 = true;
18480 }
18481 if (obj2) {
18482 {
18483 arg3 = wxString_in_helper(obj2);
18484 if (arg3 == NULL) SWIG_fail;
18485 temp3 = true;
18486 }
18487 }
18488 {
18489 PyThreadState* __tstate = wxPyBeginAllowThreads();
18490 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18491 wxPyEndAllowThreads(__tstate);
18492 if (PyErr_Occurred()) SWIG_fail;
18493 }
18494 resultobj = result;
18495 {
18496 if (temp2)
18497 delete arg2;
18498 }
18499 {
18500 if (temp3)
18501 delete arg3;
18502 }
18503 return resultobj;
18504 fail:
18505 {
18506 if (temp2)
18507 delete arg2;
18508 }
18509 {
18510 if (temp3)
18511 delete arg3;
18512 }
18513 return NULL;
18514 }
18515
18516
18517 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18518 PyObject *resultobj = 0;
18519 wxFileType *arg1 = (wxFileType *) 0 ;
18520 wxString *arg2 = 0 ;
18521 wxString *arg3 = 0 ;
18522 bool arg4 = (bool) true ;
18523 bool result;
18524 void *argp1 = 0 ;
18525 int res1 = 0 ;
18526 bool temp2 = false ;
18527 bool temp3 = false ;
18528 bool val4 ;
18529 int ecode4 = 0 ;
18530 PyObject * obj0 = 0 ;
18531 PyObject * obj1 = 0 ;
18532 PyObject * obj2 = 0 ;
18533 PyObject * obj3 = 0 ;
18534 char * kwnames[] = {
18535 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18536 };
18537
18538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18540 if (!SWIG_IsOK(res1)) {
18541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18542 }
18543 arg1 = reinterpret_cast< wxFileType * >(argp1);
18544 {
18545 arg2 = wxString_in_helper(obj1);
18546 if (arg2 == NULL) SWIG_fail;
18547 temp2 = true;
18548 }
18549 {
18550 arg3 = wxString_in_helper(obj2);
18551 if (arg3 == NULL) SWIG_fail;
18552 temp3 = true;
18553 }
18554 if (obj3) {
18555 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18556 if (!SWIG_IsOK(ecode4)) {
18557 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18558 }
18559 arg4 = static_cast< bool >(val4);
18560 }
18561 {
18562 PyThreadState* __tstate = wxPyBeginAllowThreads();
18563 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18564 wxPyEndAllowThreads(__tstate);
18565 if (PyErr_Occurred()) SWIG_fail;
18566 }
18567 {
18568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18569 }
18570 {
18571 if (temp2)
18572 delete arg2;
18573 }
18574 {
18575 if (temp3)
18576 delete arg3;
18577 }
18578 return resultobj;
18579 fail:
18580 {
18581 if (temp2)
18582 delete arg2;
18583 }
18584 {
18585 if (temp3)
18586 delete arg3;
18587 }
18588 return NULL;
18589 }
18590
18591
18592 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18593 PyObject *resultobj = 0;
18594 wxFileType *arg1 = (wxFileType *) 0 ;
18595 wxString const &arg2_defvalue = wxPyEmptyString ;
18596 wxString *arg2 = (wxString *) &arg2_defvalue ;
18597 int arg3 = (int) 0 ;
18598 bool result;
18599 void *argp1 = 0 ;
18600 int res1 = 0 ;
18601 bool temp2 = false ;
18602 int val3 ;
18603 int ecode3 = 0 ;
18604 PyObject * obj0 = 0 ;
18605 PyObject * obj1 = 0 ;
18606 PyObject * obj2 = 0 ;
18607 char * kwnames[] = {
18608 (char *) "self",(char *) "cmd",(char *) "index", NULL
18609 };
18610
18611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18613 if (!SWIG_IsOK(res1)) {
18614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18615 }
18616 arg1 = reinterpret_cast< wxFileType * >(argp1);
18617 if (obj1) {
18618 {
18619 arg2 = wxString_in_helper(obj1);
18620 if (arg2 == NULL) SWIG_fail;
18621 temp2 = true;
18622 }
18623 }
18624 if (obj2) {
18625 ecode3 = SWIG_AsVal_int(obj2, &val3);
18626 if (!SWIG_IsOK(ecode3)) {
18627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18628 }
18629 arg3 = static_cast< int >(val3);
18630 }
18631 {
18632 PyThreadState* __tstate = wxPyBeginAllowThreads();
18633 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18634 wxPyEndAllowThreads(__tstate);
18635 if (PyErr_Occurred()) SWIG_fail;
18636 }
18637 {
18638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18639 }
18640 {
18641 if (temp2)
18642 delete arg2;
18643 }
18644 return resultobj;
18645 fail:
18646 {
18647 if (temp2)
18648 delete arg2;
18649 }
18650 return NULL;
18651 }
18652
18653
18654 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18655 PyObject *resultobj = 0;
18656 wxFileType *arg1 = (wxFileType *) 0 ;
18657 bool result;
18658 void *argp1 = 0 ;
18659 int res1 = 0 ;
18660 PyObject *swig_obj[1] ;
18661
18662 if (!args) SWIG_fail;
18663 swig_obj[0] = args;
18664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18665 if (!SWIG_IsOK(res1)) {
18666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18667 }
18668 arg1 = reinterpret_cast< wxFileType * >(argp1);
18669 {
18670 PyThreadState* __tstate = wxPyBeginAllowThreads();
18671 result = (bool)(arg1)->Unassociate();
18672 wxPyEndAllowThreads(__tstate);
18673 if (PyErr_Occurred()) SWIG_fail;
18674 }
18675 {
18676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18677 }
18678 return resultobj;
18679 fail:
18680 return NULL;
18681 }
18682
18683
18684 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18685 PyObject *resultobj = 0;
18686 wxString *arg1 = 0 ;
18687 wxString *arg2 = 0 ;
18688 wxString const &arg3_defvalue = wxPyEmptyString ;
18689 wxString *arg3 = (wxString *) &arg3_defvalue ;
18690 wxString result;
18691 bool temp1 = false ;
18692 bool temp2 = false ;
18693 bool temp3 = false ;
18694 PyObject * obj0 = 0 ;
18695 PyObject * obj1 = 0 ;
18696 PyObject * obj2 = 0 ;
18697 char * kwnames[] = {
18698 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18699 };
18700
18701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18702 {
18703 arg1 = wxString_in_helper(obj0);
18704 if (arg1 == NULL) SWIG_fail;
18705 temp1 = true;
18706 }
18707 {
18708 arg2 = wxString_in_helper(obj1);
18709 if (arg2 == NULL) SWIG_fail;
18710 temp2 = true;
18711 }
18712 if (obj2) {
18713 {
18714 arg3 = wxString_in_helper(obj2);
18715 if (arg3 == NULL) SWIG_fail;
18716 temp3 = true;
18717 }
18718 }
18719 {
18720 PyThreadState* __tstate = wxPyBeginAllowThreads();
18721 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18722 wxPyEndAllowThreads(__tstate);
18723 if (PyErr_Occurred()) SWIG_fail;
18724 }
18725 {
18726 #if wxUSE_UNICODE
18727 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18728 #else
18729 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18730 #endif
18731 }
18732 {
18733 if (temp1)
18734 delete arg1;
18735 }
18736 {
18737 if (temp2)
18738 delete arg2;
18739 }
18740 {
18741 if (temp3)
18742 delete arg3;
18743 }
18744 return resultobj;
18745 fail:
18746 {
18747 if (temp1)
18748 delete arg1;
18749 }
18750 {
18751 if (temp2)
18752 delete arg2;
18753 }
18754 {
18755 if (temp3)
18756 delete arg3;
18757 }
18758 return NULL;
18759 }
18760
18761
18762 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18763 PyObject *obj;
18764 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18765 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18766 return SWIG_Py_Void();
18767 }
18768
18769 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18770 return SWIG_Python_InitShadowInstance(args);
18771 }
18772
18773 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18774 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18775 return 1;
18776 }
18777
18778
18779 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18780 PyObject *pyobj = 0;
18781
18782 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18783 return pyobj;
18784 }
18785
18786
18787 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18788 PyObject *resultobj = 0;
18789 wxString *arg1 = 0 ;
18790 wxString *arg2 = 0 ;
18791 bool result;
18792 bool temp1 = false ;
18793 bool temp2 = false ;
18794 PyObject * obj0 = 0 ;
18795 PyObject * obj1 = 0 ;
18796 char * kwnames[] = {
18797 (char *) "mimeType",(char *) "wildcard", NULL
18798 };
18799
18800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18801 {
18802 arg1 = wxString_in_helper(obj0);
18803 if (arg1 == NULL) SWIG_fail;
18804 temp1 = true;
18805 }
18806 {
18807 arg2 = wxString_in_helper(obj1);
18808 if (arg2 == NULL) SWIG_fail;
18809 temp2 = true;
18810 }
18811 {
18812 PyThreadState* __tstate = wxPyBeginAllowThreads();
18813 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18814 wxPyEndAllowThreads(__tstate);
18815 if (PyErr_Occurred()) SWIG_fail;
18816 }
18817 {
18818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18819 }
18820 {
18821 if (temp1)
18822 delete arg1;
18823 }
18824 {
18825 if (temp2)
18826 delete arg2;
18827 }
18828 return resultobj;
18829 fail:
18830 {
18831 if (temp1)
18832 delete arg1;
18833 }
18834 {
18835 if (temp2)
18836 delete arg2;
18837 }
18838 return NULL;
18839 }
18840
18841
18842 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18843 PyObject *resultobj = 0;
18844 wxMimeTypesManager *result = 0 ;
18845
18846 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18847 {
18848 PyThreadState* __tstate = wxPyBeginAllowThreads();
18849 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18850 wxPyEndAllowThreads(__tstate);
18851 if (PyErr_Occurred()) SWIG_fail;
18852 }
18853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18854 return resultobj;
18855 fail:
18856 return NULL;
18857 }
18858
18859
18860 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18861 PyObject *resultobj = 0;
18862 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18863 int arg2 = (int) wxMAILCAP_ALL ;
18864 wxString const &arg3_defvalue = wxPyEmptyString ;
18865 wxString *arg3 = (wxString *) &arg3_defvalue ;
18866 void *argp1 = 0 ;
18867 int res1 = 0 ;
18868 int val2 ;
18869 int ecode2 = 0 ;
18870 bool temp3 = false ;
18871 PyObject * obj0 = 0 ;
18872 PyObject * obj1 = 0 ;
18873 PyObject * obj2 = 0 ;
18874 char * kwnames[] = {
18875 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18876 };
18877
18878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18880 if (!SWIG_IsOK(res1)) {
18881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18882 }
18883 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18884 if (obj1) {
18885 ecode2 = SWIG_AsVal_int(obj1, &val2);
18886 if (!SWIG_IsOK(ecode2)) {
18887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18888 }
18889 arg2 = static_cast< int >(val2);
18890 }
18891 if (obj2) {
18892 {
18893 arg3 = wxString_in_helper(obj2);
18894 if (arg3 == NULL) SWIG_fail;
18895 temp3 = true;
18896 }
18897 }
18898 {
18899 PyThreadState* __tstate = wxPyBeginAllowThreads();
18900 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18901 wxPyEndAllowThreads(__tstate);
18902 if (PyErr_Occurred()) SWIG_fail;
18903 }
18904 resultobj = SWIG_Py_Void();
18905 {
18906 if (temp3)
18907 delete arg3;
18908 }
18909 return resultobj;
18910 fail:
18911 {
18912 if (temp3)
18913 delete arg3;
18914 }
18915 return NULL;
18916 }
18917
18918
18919 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18920 PyObject *resultobj = 0;
18921 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18922 void *argp1 = 0 ;
18923 int res1 = 0 ;
18924 PyObject *swig_obj[1] ;
18925
18926 if (!args) SWIG_fail;
18927 swig_obj[0] = args;
18928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18929 if (!SWIG_IsOK(res1)) {
18930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18931 }
18932 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18933 {
18934 PyThreadState* __tstate = wxPyBeginAllowThreads();
18935 (arg1)->ClearData();
18936 wxPyEndAllowThreads(__tstate);
18937 if (PyErr_Occurred()) SWIG_fail;
18938 }
18939 resultobj = SWIG_Py_Void();
18940 return resultobj;
18941 fail:
18942 return NULL;
18943 }
18944
18945
18946 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18947 PyObject *resultobj = 0;
18948 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18949 wxString *arg2 = 0 ;
18950 wxFileType *result = 0 ;
18951 void *argp1 = 0 ;
18952 int res1 = 0 ;
18953 bool temp2 = false ;
18954 PyObject * obj0 = 0 ;
18955 PyObject * obj1 = 0 ;
18956 char * kwnames[] = {
18957 (char *) "self",(char *) "ext", NULL
18958 };
18959
18960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18962 if (!SWIG_IsOK(res1)) {
18963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18964 }
18965 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18966 {
18967 arg2 = wxString_in_helper(obj1);
18968 if (arg2 == NULL) SWIG_fail;
18969 temp2 = true;
18970 }
18971 {
18972 PyThreadState* __tstate = wxPyBeginAllowThreads();
18973 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18974 wxPyEndAllowThreads(__tstate);
18975 if (PyErr_Occurred()) SWIG_fail;
18976 }
18977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18978 {
18979 if (temp2)
18980 delete arg2;
18981 }
18982 return resultobj;
18983 fail:
18984 {
18985 if (temp2)
18986 delete arg2;
18987 }
18988 return NULL;
18989 }
18990
18991
18992 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18993 PyObject *resultobj = 0;
18994 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18995 wxString *arg2 = 0 ;
18996 wxFileType *result = 0 ;
18997 void *argp1 = 0 ;
18998 int res1 = 0 ;
18999 bool temp2 = false ;
19000 PyObject * obj0 = 0 ;
19001 PyObject * obj1 = 0 ;
19002 char * kwnames[] = {
19003 (char *) "self",(char *) "mimeType", NULL
19004 };
19005
19006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
19007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19008 if (!SWIG_IsOK(res1)) {
19009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19010 }
19011 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19012 {
19013 arg2 = wxString_in_helper(obj1);
19014 if (arg2 == NULL) SWIG_fail;
19015 temp2 = true;
19016 }
19017 {
19018 PyThreadState* __tstate = wxPyBeginAllowThreads();
19019 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
19020 wxPyEndAllowThreads(__tstate);
19021 if (PyErr_Occurred()) SWIG_fail;
19022 }
19023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19024 {
19025 if (temp2)
19026 delete arg2;
19027 }
19028 return resultobj;
19029 fail:
19030 {
19031 if (temp2)
19032 delete arg2;
19033 }
19034 return NULL;
19035 }
19036
19037
19038 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19039 PyObject *resultobj = 0;
19040 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19041 wxString *arg2 = 0 ;
19042 bool arg3 = (bool) false ;
19043 bool result;
19044 void *argp1 = 0 ;
19045 int res1 = 0 ;
19046 bool temp2 = false ;
19047 bool val3 ;
19048 int ecode3 = 0 ;
19049 PyObject * obj0 = 0 ;
19050 PyObject * obj1 = 0 ;
19051 PyObject * obj2 = 0 ;
19052 char * kwnames[] = {
19053 (char *) "self",(char *) "filename",(char *) "fallback", NULL
19054 };
19055
19056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19058 if (!SWIG_IsOK(res1)) {
19059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19060 }
19061 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19062 {
19063 arg2 = wxString_in_helper(obj1);
19064 if (arg2 == NULL) SWIG_fail;
19065 temp2 = true;
19066 }
19067 if (obj2) {
19068 ecode3 = SWIG_AsVal_bool(obj2, &val3);
19069 if (!SWIG_IsOK(ecode3)) {
19070 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
19071 }
19072 arg3 = static_cast< bool >(val3);
19073 }
19074 {
19075 PyThreadState* __tstate = wxPyBeginAllowThreads();
19076 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
19077 wxPyEndAllowThreads(__tstate);
19078 if (PyErr_Occurred()) SWIG_fail;
19079 }
19080 {
19081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19082 }
19083 {
19084 if (temp2)
19085 delete arg2;
19086 }
19087 return resultobj;
19088 fail:
19089 {
19090 if (temp2)
19091 delete arg2;
19092 }
19093 return NULL;
19094 }
19095
19096
19097 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19098 PyObject *resultobj = 0;
19099 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19100 wxString *arg2 = 0 ;
19101 bool result;
19102 void *argp1 = 0 ;
19103 int res1 = 0 ;
19104 bool temp2 = false ;
19105 PyObject * obj0 = 0 ;
19106 PyObject * obj1 = 0 ;
19107 char * kwnames[] = {
19108 (char *) "self",(char *) "filename", NULL
19109 };
19110
19111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19113 if (!SWIG_IsOK(res1)) {
19114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19115 }
19116 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19117 {
19118 arg2 = wxString_in_helper(obj1);
19119 if (arg2 == NULL) SWIG_fail;
19120 temp2 = true;
19121 }
19122 {
19123 PyThreadState* __tstate = wxPyBeginAllowThreads();
19124 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19125 wxPyEndAllowThreads(__tstate);
19126 if (PyErr_Occurred()) SWIG_fail;
19127 }
19128 {
19129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19130 }
19131 {
19132 if (temp2)
19133 delete arg2;
19134 }
19135 return resultobj;
19136 fail:
19137 {
19138 if (temp2)
19139 delete arg2;
19140 }
19141 return NULL;
19142 }
19143
19144
19145 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19146 PyObject *resultobj = 0;
19147 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19148 PyObject *result = 0 ;
19149 void *argp1 = 0 ;
19150 int res1 = 0 ;
19151 PyObject *swig_obj[1] ;
19152
19153 if (!args) SWIG_fail;
19154 swig_obj[0] = args;
19155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19156 if (!SWIG_IsOK(res1)) {
19157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19158 }
19159 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19160 {
19161 PyThreadState* __tstate = wxPyBeginAllowThreads();
19162 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19163 wxPyEndAllowThreads(__tstate);
19164 if (PyErr_Occurred()) SWIG_fail;
19165 }
19166 resultobj = result;
19167 return resultobj;
19168 fail:
19169 return NULL;
19170 }
19171
19172
19173 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19174 PyObject *resultobj = 0;
19175 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19176 wxFileTypeInfo *arg2 = 0 ;
19177 void *argp1 = 0 ;
19178 int res1 = 0 ;
19179 void *argp2 = 0 ;
19180 int res2 = 0 ;
19181 PyObject * obj0 = 0 ;
19182 PyObject * obj1 = 0 ;
19183 char * kwnames[] = {
19184 (char *) "self",(char *) "ft", NULL
19185 };
19186
19187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19189 if (!SWIG_IsOK(res1)) {
19190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19191 }
19192 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19193 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19194 if (!SWIG_IsOK(res2)) {
19195 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19196 }
19197 if (!argp2) {
19198 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19199 }
19200 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19201 {
19202 PyThreadState* __tstate = wxPyBeginAllowThreads();
19203 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19204 wxPyEndAllowThreads(__tstate);
19205 if (PyErr_Occurred()) SWIG_fail;
19206 }
19207 resultobj = SWIG_Py_Void();
19208 return resultobj;
19209 fail:
19210 return NULL;
19211 }
19212
19213
19214 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19215 PyObject *resultobj = 0;
19216 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19217 wxFileTypeInfo *arg2 = 0 ;
19218 wxFileType *result = 0 ;
19219 void *argp1 = 0 ;
19220 int res1 = 0 ;
19221 void *argp2 = 0 ;
19222 int res2 = 0 ;
19223 PyObject * obj0 = 0 ;
19224 PyObject * obj1 = 0 ;
19225 char * kwnames[] = {
19226 (char *) "self",(char *) "ftInfo", NULL
19227 };
19228
19229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19231 if (!SWIG_IsOK(res1)) {
19232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19233 }
19234 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19235 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19236 if (!SWIG_IsOK(res2)) {
19237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19238 }
19239 if (!argp2) {
19240 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19241 }
19242 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19243 {
19244 PyThreadState* __tstate = wxPyBeginAllowThreads();
19245 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19246 wxPyEndAllowThreads(__tstate);
19247 if (PyErr_Occurred()) SWIG_fail;
19248 }
19249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19250 return resultobj;
19251 fail:
19252 return NULL;
19253 }
19254
19255
19256 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19257 PyObject *resultobj = 0;
19258 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19259 wxFileType *arg2 = (wxFileType *) 0 ;
19260 bool result;
19261 void *argp1 = 0 ;
19262 int res1 = 0 ;
19263 void *argp2 = 0 ;
19264 int res2 = 0 ;
19265 PyObject * obj0 = 0 ;
19266 PyObject * obj1 = 0 ;
19267 char * kwnames[] = {
19268 (char *) "self",(char *) "ft", NULL
19269 };
19270
19271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19273 if (!SWIG_IsOK(res1)) {
19274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19275 }
19276 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19277 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19278 if (!SWIG_IsOK(res2)) {
19279 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19280 }
19281 arg2 = reinterpret_cast< wxFileType * >(argp2);
19282 {
19283 PyThreadState* __tstate = wxPyBeginAllowThreads();
19284 result = (bool)(arg1)->Unassociate(arg2);
19285 wxPyEndAllowThreads(__tstate);
19286 if (PyErr_Occurred()) SWIG_fail;
19287 }
19288 {
19289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19290 }
19291 return resultobj;
19292 fail:
19293 return NULL;
19294 }
19295
19296
19297 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19298 PyObject *resultobj = 0;
19299 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19300 void *argp1 = 0 ;
19301 int res1 = 0 ;
19302 PyObject *swig_obj[1] ;
19303
19304 if (!args) SWIG_fail;
19305 swig_obj[0] = args;
19306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19307 if (!SWIG_IsOK(res1)) {
19308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19309 }
19310 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19311 {
19312 PyThreadState* __tstate = wxPyBeginAllowThreads();
19313 delete arg1;
19314
19315 wxPyEndAllowThreads(__tstate);
19316 if (PyErr_Occurred()) SWIG_fail;
19317 }
19318 resultobj = SWIG_Py_Void();
19319 return resultobj;
19320 fail:
19321 return NULL;
19322 }
19323
19324
19325 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19326 PyObject *obj;
19327 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19328 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19329 return SWIG_Py_Void();
19330 }
19331
19332 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19333 return SWIG_Python_InitShadowInstance(args);
19334 }
19335
19336 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19337 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19338 return 1;
19339 }
19340
19341
19342 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19343 PyObject *pyobj = 0;
19344
19345 {
19346 #if wxUSE_UNICODE
19347 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19348 #else
19349 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19350 #endif
19351 }
19352 return pyobj;
19353 }
19354
19355
19356 SWIGINTERN int ART_MENU_set(PyObject *) {
19357 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19358 return 1;
19359 }
19360
19361
19362 SWIGINTERN PyObject *ART_MENU_get(void) {
19363 PyObject *pyobj = 0;
19364
19365 {
19366 #if wxUSE_UNICODE
19367 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19368 #else
19369 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19370 #endif
19371 }
19372 return pyobj;
19373 }
19374
19375
19376 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19377 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19378 return 1;
19379 }
19380
19381
19382 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19383 PyObject *pyobj = 0;
19384
19385 {
19386 #if wxUSE_UNICODE
19387 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19388 #else
19389 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19390 #endif
19391 }
19392 return pyobj;
19393 }
19394
19395
19396 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19397 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19398 return 1;
19399 }
19400
19401
19402 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19403 PyObject *pyobj = 0;
19404
19405 {
19406 #if wxUSE_UNICODE
19407 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19408 #else
19409 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19410 #endif
19411 }
19412 return pyobj;
19413 }
19414
19415
19416 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19417 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19418 return 1;
19419 }
19420
19421
19422 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19423 PyObject *pyobj = 0;
19424
19425 {
19426 #if wxUSE_UNICODE
19427 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19428 #else
19429 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19430 #endif
19431 }
19432 return pyobj;
19433 }
19434
19435
19436 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19437 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19438 return 1;
19439 }
19440
19441
19442 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19443 PyObject *pyobj = 0;
19444
19445 {
19446 #if wxUSE_UNICODE
19447 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19448 #else
19449 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19450 #endif
19451 }
19452 return pyobj;
19453 }
19454
19455
19456 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19457 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19458 return 1;
19459 }
19460
19461
19462 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19463 PyObject *pyobj = 0;
19464
19465 {
19466 #if wxUSE_UNICODE
19467 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19468 #else
19469 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19470 #endif
19471 }
19472 return pyobj;
19473 }
19474
19475
19476 SWIGINTERN int ART_OTHER_set(PyObject *) {
19477 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19478 return 1;
19479 }
19480
19481
19482 SWIGINTERN PyObject *ART_OTHER_get(void) {
19483 PyObject *pyobj = 0;
19484
19485 {
19486 #if wxUSE_UNICODE
19487 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19488 #else
19489 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19490 #endif
19491 }
19492 return pyobj;
19493 }
19494
19495
19496 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19497 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19498 return 1;
19499 }
19500
19501
19502 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19503 PyObject *pyobj = 0;
19504
19505 {
19506 #if wxUSE_UNICODE
19507 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19508 #else
19509 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19510 #endif
19511 }
19512 return pyobj;
19513 }
19514
19515
19516 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19517 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19518 return 1;
19519 }
19520
19521
19522 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19523 PyObject *pyobj = 0;
19524
19525 {
19526 #if wxUSE_UNICODE
19527 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19528 #else
19529 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19530 #endif
19531 }
19532 return pyobj;
19533 }
19534
19535
19536 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19537 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19538 return 1;
19539 }
19540
19541
19542 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19543 PyObject *pyobj = 0;
19544
19545 {
19546 #if wxUSE_UNICODE
19547 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19548 #else
19549 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19550 #endif
19551 }
19552 return pyobj;
19553 }
19554
19555
19556 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19557 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19558 return 1;
19559 }
19560
19561
19562 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19563 PyObject *pyobj = 0;
19564
19565 {
19566 #if wxUSE_UNICODE
19567 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19568 #else
19569 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19570 #endif
19571 }
19572 return pyobj;
19573 }
19574
19575
19576 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19577 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19578 return 1;
19579 }
19580
19581
19582 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19583 PyObject *pyobj = 0;
19584
19585 {
19586 #if wxUSE_UNICODE
19587 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19588 #else
19589 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19590 #endif
19591 }
19592 return pyobj;
19593 }
19594
19595
19596 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19597 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19598 return 1;
19599 }
19600
19601
19602 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19603 PyObject *pyobj = 0;
19604
19605 {
19606 #if wxUSE_UNICODE
19607 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19608 #else
19609 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19610 #endif
19611 }
19612 return pyobj;
19613 }
19614
19615
19616 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19617 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19618 return 1;
19619 }
19620
19621
19622 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19623 PyObject *pyobj = 0;
19624
19625 {
19626 #if wxUSE_UNICODE
19627 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19628 #else
19629 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19630 #endif
19631 }
19632 return pyobj;
19633 }
19634
19635
19636 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19637 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19638 return 1;
19639 }
19640
19641
19642 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19643 PyObject *pyobj = 0;
19644
19645 {
19646 #if wxUSE_UNICODE
19647 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19648 #else
19649 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19650 #endif
19651 }
19652 return pyobj;
19653 }
19654
19655
19656 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19657 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19658 return 1;
19659 }
19660
19661
19662 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19663 PyObject *pyobj = 0;
19664
19665 {
19666 #if wxUSE_UNICODE
19667 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19668 #else
19669 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19670 #endif
19671 }
19672 return pyobj;
19673 }
19674
19675
19676 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19677 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19678 return 1;
19679 }
19680
19681
19682 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19683 PyObject *pyobj = 0;
19684
19685 {
19686 #if wxUSE_UNICODE
19687 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19688 #else
19689 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19690 #endif
19691 }
19692 return pyobj;
19693 }
19694
19695
19696 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19697 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19698 return 1;
19699 }
19700
19701
19702 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19703 PyObject *pyobj = 0;
19704
19705 {
19706 #if wxUSE_UNICODE
19707 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19708 #else
19709 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19710 #endif
19711 }
19712 return pyobj;
19713 }
19714
19715
19716 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19717 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19718 return 1;
19719 }
19720
19721
19722 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19723 PyObject *pyobj = 0;
19724
19725 {
19726 #if wxUSE_UNICODE
19727 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19728 #else
19729 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19730 #endif
19731 }
19732 return pyobj;
19733 }
19734
19735
19736 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19737 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19738 return 1;
19739 }
19740
19741
19742 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19743 PyObject *pyobj = 0;
19744
19745 {
19746 #if wxUSE_UNICODE
19747 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19748 #else
19749 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19750 #endif
19751 }
19752 return pyobj;
19753 }
19754
19755
19756 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19757 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19758 return 1;
19759 }
19760
19761
19762 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19763 PyObject *pyobj = 0;
19764
19765 {
19766 #if wxUSE_UNICODE
19767 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19768 #else
19769 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19770 #endif
19771 }
19772 return pyobj;
19773 }
19774
19775
19776 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19777 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19778 return 1;
19779 }
19780
19781
19782 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19783 PyObject *pyobj = 0;
19784
19785 {
19786 #if wxUSE_UNICODE
19787 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19788 #else
19789 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19790 #endif
19791 }
19792 return pyobj;
19793 }
19794
19795
19796 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19797 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19798 return 1;
19799 }
19800
19801
19802 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19803 PyObject *pyobj = 0;
19804
19805 {
19806 #if wxUSE_UNICODE
19807 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19808 #else
19809 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19810 #endif
19811 }
19812 return pyobj;
19813 }
19814
19815
19816 SWIGINTERN int ART_PRINT_set(PyObject *) {
19817 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19818 return 1;
19819 }
19820
19821
19822 SWIGINTERN PyObject *ART_PRINT_get(void) {
19823 PyObject *pyobj = 0;
19824
19825 {
19826 #if wxUSE_UNICODE
19827 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19828 #else
19829 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19830 #endif
19831 }
19832 return pyobj;
19833 }
19834
19835
19836 SWIGINTERN int ART_HELP_set(PyObject *) {
19837 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19838 return 1;
19839 }
19840
19841
19842 SWIGINTERN PyObject *ART_HELP_get(void) {
19843 PyObject *pyobj = 0;
19844
19845 {
19846 #if wxUSE_UNICODE
19847 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19848 #else
19849 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19850 #endif
19851 }
19852 return pyobj;
19853 }
19854
19855
19856 SWIGINTERN int ART_TIP_set(PyObject *) {
19857 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19858 return 1;
19859 }
19860
19861
19862 SWIGINTERN PyObject *ART_TIP_get(void) {
19863 PyObject *pyobj = 0;
19864
19865 {
19866 #if wxUSE_UNICODE
19867 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19868 #else
19869 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19870 #endif
19871 }
19872 return pyobj;
19873 }
19874
19875
19876 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19877 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19878 return 1;
19879 }
19880
19881
19882 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19883 PyObject *pyobj = 0;
19884
19885 {
19886 #if wxUSE_UNICODE
19887 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19888 #else
19889 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19890 #endif
19891 }
19892 return pyobj;
19893 }
19894
19895
19896 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19897 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19898 return 1;
19899 }
19900
19901
19902 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19903 PyObject *pyobj = 0;
19904
19905 {
19906 #if wxUSE_UNICODE
19907 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19908 #else
19909 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19910 #endif
19911 }
19912 return pyobj;
19913 }
19914
19915
19916 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19917 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19918 return 1;
19919 }
19920
19921
19922 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19923 PyObject *pyobj = 0;
19924
19925 {
19926 #if wxUSE_UNICODE
19927 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19928 #else
19929 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19930 #endif
19931 }
19932 return pyobj;
19933 }
19934
19935
19936 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19937 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19938 return 1;
19939 }
19940
19941
19942 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19943 PyObject *pyobj = 0;
19944
19945 {
19946 #if wxUSE_UNICODE
19947 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19948 #else
19949 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19950 #endif
19951 }
19952 return pyobj;
19953 }
19954
19955
19956 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19957 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19958 return 1;
19959 }
19960
19961
19962 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19963 PyObject *pyobj = 0;
19964
19965 {
19966 #if wxUSE_UNICODE
19967 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19968 #else
19969 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19970 #endif
19971 }
19972 return pyobj;
19973 }
19974
19975
19976 SWIGINTERN int ART_CDROM_set(PyObject *) {
19977 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19978 return 1;
19979 }
19980
19981
19982 SWIGINTERN PyObject *ART_CDROM_get(void) {
19983 PyObject *pyobj = 0;
19984
19985 {
19986 #if wxUSE_UNICODE
19987 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19988 #else
19989 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19990 #endif
19991 }
19992 return pyobj;
19993 }
19994
19995
19996 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19997 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19998 return 1;
19999 }
20000
20001
20002 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
20003 PyObject *pyobj = 0;
20004
20005 {
20006 #if wxUSE_UNICODE
20007 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
20008 #else
20009 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
20010 #endif
20011 }
20012 return pyobj;
20013 }
20014
20015
20016 SWIGINTERN int ART_FOLDER_set(PyObject *) {
20017 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
20018 return 1;
20019 }
20020
20021
20022 SWIGINTERN PyObject *ART_FOLDER_get(void) {
20023 PyObject *pyobj = 0;
20024
20025 {
20026 #if wxUSE_UNICODE
20027 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20028 #else
20029 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20030 #endif
20031 }
20032 return pyobj;
20033 }
20034
20035
20036 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
20037 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
20038 return 1;
20039 }
20040
20041
20042 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
20043 PyObject *pyobj = 0;
20044
20045 {
20046 #if wxUSE_UNICODE
20047 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20048 #else
20049 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20050 #endif
20051 }
20052 return pyobj;
20053 }
20054
20055
20056 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
20057 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
20058 return 1;
20059 }
20060
20061
20062 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
20063 PyObject *pyobj = 0;
20064
20065 {
20066 #if wxUSE_UNICODE
20067 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20068 #else
20069 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20070 #endif
20071 }
20072 return pyobj;
20073 }
20074
20075
20076 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
20077 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
20078 return 1;
20079 }
20080
20081
20082 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
20083 PyObject *pyobj = 0;
20084
20085 {
20086 #if wxUSE_UNICODE
20087 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20088 #else
20089 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20090 #endif
20091 }
20092 return pyobj;
20093 }
20094
20095
20096 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
20097 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
20098 return 1;
20099 }
20100
20101
20102 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20103 PyObject *pyobj = 0;
20104
20105 {
20106 #if wxUSE_UNICODE
20107 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20108 #else
20109 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20110 #endif
20111 }
20112 return pyobj;
20113 }
20114
20115
20116 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20117 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20118 return 1;
20119 }
20120
20121
20122 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20123 PyObject *pyobj = 0;
20124
20125 {
20126 #if wxUSE_UNICODE
20127 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20128 #else
20129 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20130 #endif
20131 }
20132 return pyobj;
20133 }
20134
20135
20136 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20137 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20138 return 1;
20139 }
20140
20141
20142 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20143 PyObject *pyobj = 0;
20144
20145 {
20146 #if wxUSE_UNICODE
20147 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20148 #else
20149 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20150 #endif
20151 }
20152 return pyobj;
20153 }
20154
20155
20156 SWIGINTERN int ART_ERROR_set(PyObject *) {
20157 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20158 return 1;
20159 }
20160
20161
20162 SWIGINTERN PyObject *ART_ERROR_get(void) {
20163 PyObject *pyobj = 0;
20164
20165 {
20166 #if wxUSE_UNICODE
20167 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20168 #else
20169 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20170 #endif
20171 }
20172 return pyobj;
20173 }
20174
20175
20176 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20177 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20178 return 1;
20179 }
20180
20181
20182 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20183 PyObject *pyobj = 0;
20184
20185 {
20186 #if wxUSE_UNICODE
20187 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20188 #else
20189 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20190 #endif
20191 }
20192 return pyobj;
20193 }
20194
20195
20196 SWIGINTERN int ART_WARNING_set(PyObject *) {
20197 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20198 return 1;
20199 }
20200
20201
20202 SWIGINTERN PyObject *ART_WARNING_get(void) {
20203 PyObject *pyobj = 0;
20204
20205 {
20206 #if wxUSE_UNICODE
20207 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20208 #else
20209 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20210 #endif
20211 }
20212 return pyobj;
20213 }
20214
20215
20216 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20217 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20218 return 1;
20219 }
20220
20221
20222 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20223 PyObject *pyobj = 0;
20224
20225 {
20226 #if wxUSE_UNICODE
20227 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20228 #else
20229 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20230 #endif
20231 }
20232 return pyobj;
20233 }
20234
20235
20236 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20237 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20238 return 1;
20239 }
20240
20241
20242 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20243 PyObject *pyobj = 0;
20244
20245 {
20246 #if wxUSE_UNICODE
20247 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20248 #else
20249 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20250 #endif
20251 }
20252 return pyobj;
20253 }
20254
20255
20256 SWIGINTERN int ART_COPY_set(PyObject *) {
20257 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20258 return 1;
20259 }
20260
20261
20262 SWIGINTERN PyObject *ART_COPY_get(void) {
20263 PyObject *pyobj = 0;
20264
20265 {
20266 #if wxUSE_UNICODE
20267 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20268 #else
20269 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20270 #endif
20271 }
20272 return pyobj;
20273 }
20274
20275
20276 SWIGINTERN int ART_CUT_set(PyObject *) {
20277 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20278 return 1;
20279 }
20280
20281
20282 SWIGINTERN PyObject *ART_CUT_get(void) {
20283 PyObject *pyobj = 0;
20284
20285 {
20286 #if wxUSE_UNICODE
20287 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20288 #else
20289 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20290 #endif
20291 }
20292 return pyobj;
20293 }
20294
20295
20296 SWIGINTERN int ART_PASTE_set(PyObject *) {
20297 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20298 return 1;
20299 }
20300
20301
20302 SWIGINTERN PyObject *ART_PASTE_get(void) {
20303 PyObject *pyobj = 0;
20304
20305 {
20306 #if wxUSE_UNICODE
20307 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20308 #else
20309 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20310 #endif
20311 }
20312 return pyobj;
20313 }
20314
20315
20316 SWIGINTERN int ART_DELETE_set(PyObject *) {
20317 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20318 return 1;
20319 }
20320
20321
20322 SWIGINTERN PyObject *ART_DELETE_get(void) {
20323 PyObject *pyobj = 0;
20324
20325 {
20326 #if wxUSE_UNICODE
20327 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20328 #else
20329 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20330 #endif
20331 }
20332 return pyobj;
20333 }
20334
20335
20336 SWIGINTERN int ART_NEW_set(PyObject *) {
20337 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20338 return 1;
20339 }
20340
20341
20342 SWIGINTERN PyObject *ART_NEW_get(void) {
20343 PyObject *pyobj = 0;
20344
20345 {
20346 #if wxUSE_UNICODE
20347 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20348 #else
20349 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20350 #endif
20351 }
20352 return pyobj;
20353 }
20354
20355
20356 SWIGINTERN int ART_UNDO_set(PyObject *) {
20357 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20358 return 1;
20359 }
20360
20361
20362 SWIGINTERN PyObject *ART_UNDO_get(void) {
20363 PyObject *pyobj = 0;
20364
20365 {
20366 #if wxUSE_UNICODE
20367 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20368 #else
20369 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20370 #endif
20371 }
20372 return pyobj;
20373 }
20374
20375
20376 SWIGINTERN int ART_REDO_set(PyObject *) {
20377 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20378 return 1;
20379 }
20380
20381
20382 SWIGINTERN PyObject *ART_REDO_get(void) {
20383 PyObject *pyobj = 0;
20384
20385 {
20386 #if wxUSE_UNICODE
20387 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20388 #else
20389 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20390 #endif
20391 }
20392 return pyobj;
20393 }
20394
20395
20396 SWIGINTERN int ART_QUIT_set(PyObject *) {
20397 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20398 return 1;
20399 }
20400
20401
20402 SWIGINTERN PyObject *ART_QUIT_get(void) {
20403 PyObject *pyobj = 0;
20404
20405 {
20406 #if wxUSE_UNICODE
20407 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20408 #else
20409 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20410 #endif
20411 }
20412 return pyobj;
20413 }
20414
20415
20416 SWIGINTERN int ART_FIND_set(PyObject *) {
20417 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20418 return 1;
20419 }
20420
20421
20422 SWIGINTERN PyObject *ART_FIND_get(void) {
20423 PyObject *pyobj = 0;
20424
20425 {
20426 #if wxUSE_UNICODE
20427 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20428 #else
20429 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20430 #endif
20431 }
20432 return pyobj;
20433 }
20434
20435
20436 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20437 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20438 return 1;
20439 }
20440
20441
20442 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20443 PyObject *pyobj = 0;
20444
20445 {
20446 #if wxUSE_UNICODE
20447 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20448 #else
20449 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20450 #endif
20451 }
20452 return pyobj;
20453 }
20454
20455
20456 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20457 PyObject *resultobj = 0;
20458 wxPyArtProvider *result = 0 ;
20459
20460 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20461 {
20462 if (!wxPyCheckForApp()) SWIG_fail;
20463 PyThreadState* __tstate = wxPyBeginAllowThreads();
20464 result = (wxPyArtProvider *)new wxPyArtProvider();
20465 wxPyEndAllowThreads(__tstate);
20466 if (PyErr_Occurred()) SWIG_fail;
20467 }
20468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20469 return resultobj;
20470 fail:
20471 return NULL;
20472 }
20473
20474
20475 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20476 PyObject *resultobj = 0;
20477 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20478 void *argp1 = 0 ;
20479 int res1 = 0 ;
20480 PyObject *swig_obj[1] ;
20481
20482 if (!args) SWIG_fail;
20483 swig_obj[0] = args;
20484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20485 if (!SWIG_IsOK(res1)) {
20486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20487 }
20488 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20489 {
20490 PyThreadState* __tstate = wxPyBeginAllowThreads();
20491 delete arg1;
20492
20493 wxPyEndAllowThreads(__tstate);
20494 if (PyErr_Occurred()) SWIG_fail;
20495 }
20496 resultobj = SWIG_Py_Void();
20497 return resultobj;
20498 fail:
20499 return NULL;
20500 }
20501
20502
20503 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20504 PyObject *resultobj = 0;
20505 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20506 PyObject *arg2 = (PyObject *) 0 ;
20507 PyObject *arg3 = (PyObject *) 0 ;
20508 void *argp1 = 0 ;
20509 int res1 = 0 ;
20510 PyObject * obj0 = 0 ;
20511 PyObject * obj1 = 0 ;
20512 PyObject * obj2 = 0 ;
20513 char * kwnames[] = {
20514 (char *) "self",(char *) "self",(char *) "_class", NULL
20515 };
20516
20517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20519 if (!SWIG_IsOK(res1)) {
20520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20521 }
20522 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20523 arg2 = obj1;
20524 arg3 = obj2;
20525 {
20526 PyThreadState* __tstate = wxPyBeginAllowThreads();
20527 (arg1)->_setCallbackInfo(arg2,arg3);
20528 wxPyEndAllowThreads(__tstate);
20529 if (PyErr_Occurred()) SWIG_fail;
20530 }
20531 resultobj = SWIG_Py_Void();
20532 return resultobj;
20533 fail:
20534 return NULL;
20535 }
20536
20537
20538 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20539 PyObject *resultobj = 0;
20540 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20541 int res1 = 0 ;
20542 PyObject * obj0 = 0 ;
20543 char * kwnames[] = {
20544 (char *) "provider", NULL
20545 };
20546
20547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20548 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20549 if (!SWIG_IsOK(res1)) {
20550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20551 }
20552 {
20553 PyThreadState* __tstate = wxPyBeginAllowThreads();
20554 wxPyArtProvider::Push(arg1);
20555 wxPyEndAllowThreads(__tstate);
20556 if (PyErr_Occurred()) SWIG_fail;
20557 }
20558 resultobj = SWIG_Py_Void();
20559 return resultobj;
20560 fail:
20561 return NULL;
20562 }
20563
20564
20565 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20566 PyObject *resultobj = 0;
20567 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20568 int res1 = 0 ;
20569 PyObject * obj0 = 0 ;
20570 char * kwnames[] = {
20571 (char *) "provider", NULL
20572 };
20573
20574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20575 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20576 if (!SWIG_IsOK(res1)) {
20577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20578 }
20579 {
20580 PyThreadState* __tstate = wxPyBeginAllowThreads();
20581 wxPyArtProvider::Insert(arg1);
20582 wxPyEndAllowThreads(__tstate);
20583 if (PyErr_Occurred()) SWIG_fail;
20584 }
20585 resultobj = SWIG_Py_Void();
20586 return resultobj;
20587 fail:
20588 return NULL;
20589 }
20590
20591
20592 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20593 PyObject *resultobj = 0;
20594 bool result;
20595
20596 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20597 {
20598 PyThreadState* __tstate = wxPyBeginAllowThreads();
20599 result = (bool)wxPyArtProvider::Pop();
20600 wxPyEndAllowThreads(__tstate);
20601 if (PyErr_Occurred()) SWIG_fail;
20602 }
20603 {
20604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20605 }
20606 return resultobj;
20607 fail:
20608 return NULL;
20609 }
20610
20611
20612 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20613 PyObject *resultobj = 0;
20614 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20615 bool result;
20616 void *argp1 = 0 ;
20617 int res1 = 0 ;
20618 PyObject * obj0 = 0 ;
20619 char * kwnames[] = {
20620 (char *) "provider", NULL
20621 };
20622
20623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20625 if (!SWIG_IsOK(res1)) {
20626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20627 }
20628 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20629 {
20630 PyThreadState* __tstate = wxPyBeginAllowThreads();
20631 result = (bool)wxPyArtProvider::Delete(arg1);
20632 wxPyEndAllowThreads(__tstate);
20633 if (PyErr_Occurred()) SWIG_fail;
20634 }
20635 {
20636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20637 }
20638 return resultobj;
20639 fail:
20640 return NULL;
20641 }
20642
20643
20644 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20645 PyObject *resultobj = 0;
20646 wxString *arg1 = 0 ;
20647 wxString const &arg2_defvalue = wxPyART_OTHER ;
20648 wxString *arg2 = (wxString *) &arg2_defvalue ;
20649 wxSize const &arg3_defvalue = wxDefaultSize ;
20650 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20651 wxBitmap result;
20652 bool temp1 = false ;
20653 bool temp2 = false ;
20654 wxSize temp3 ;
20655 PyObject * obj0 = 0 ;
20656 PyObject * obj1 = 0 ;
20657 PyObject * obj2 = 0 ;
20658 char * kwnames[] = {
20659 (char *) "id",(char *) "client",(char *) "size", NULL
20660 };
20661
20662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20663 {
20664 arg1 = wxString_in_helper(obj0);
20665 if (arg1 == NULL) SWIG_fail;
20666 temp1 = true;
20667 }
20668 if (obj1) {
20669 {
20670 arg2 = wxString_in_helper(obj1);
20671 if (arg2 == NULL) SWIG_fail;
20672 temp2 = true;
20673 }
20674 }
20675 if (obj2) {
20676 {
20677 arg3 = &temp3;
20678 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20679 }
20680 }
20681 {
20682 if (!wxPyCheckForApp()) SWIG_fail;
20683 PyThreadState* __tstate = wxPyBeginAllowThreads();
20684 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20685 wxPyEndAllowThreads(__tstate);
20686 if (PyErr_Occurred()) SWIG_fail;
20687 }
20688 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20689 {
20690 if (temp1)
20691 delete arg1;
20692 }
20693 {
20694 if (temp2)
20695 delete arg2;
20696 }
20697 return resultobj;
20698 fail:
20699 {
20700 if (temp1)
20701 delete arg1;
20702 }
20703 {
20704 if (temp2)
20705 delete arg2;
20706 }
20707 return NULL;
20708 }
20709
20710
20711 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20712 PyObject *resultobj = 0;
20713 wxString *arg1 = 0 ;
20714 wxString const &arg2_defvalue = wxPyART_OTHER ;
20715 wxString *arg2 = (wxString *) &arg2_defvalue ;
20716 wxSize const &arg3_defvalue = wxDefaultSize ;
20717 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20718 wxIcon result;
20719 bool temp1 = false ;
20720 bool temp2 = false ;
20721 wxSize temp3 ;
20722 PyObject * obj0 = 0 ;
20723 PyObject * obj1 = 0 ;
20724 PyObject * obj2 = 0 ;
20725 char * kwnames[] = {
20726 (char *) "id",(char *) "client",(char *) "size", NULL
20727 };
20728
20729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20730 {
20731 arg1 = wxString_in_helper(obj0);
20732 if (arg1 == NULL) SWIG_fail;
20733 temp1 = true;
20734 }
20735 if (obj1) {
20736 {
20737 arg2 = wxString_in_helper(obj1);
20738 if (arg2 == NULL) SWIG_fail;
20739 temp2 = true;
20740 }
20741 }
20742 if (obj2) {
20743 {
20744 arg3 = &temp3;
20745 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20746 }
20747 }
20748 {
20749 if (!wxPyCheckForApp()) SWIG_fail;
20750 PyThreadState* __tstate = wxPyBeginAllowThreads();
20751 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20752 wxPyEndAllowThreads(__tstate);
20753 if (PyErr_Occurred()) SWIG_fail;
20754 }
20755 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20756 {
20757 if (temp1)
20758 delete arg1;
20759 }
20760 {
20761 if (temp2)
20762 delete arg2;
20763 }
20764 return resultobj;
20765 fail:
20766 {
20767 if (temp1)
20768 delete arg1;
20769 }
20770 {
20771 if (temp2)
20772 delete arg2;
20773 }
20774 return NULL;
20775 }
20776
20777
20778 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20779 PyObject *resultobj = 0;
20780 wxString *arg1 = 0 ;
20781 bool arg2 = (bool) false ;
20782 wxSize result;
20783 bool temp1 = false ;
20784 bool val2 ;
20785 int ecode2 = 0 ;
20786 PyObject * obj0 = 0 ;
20787 PyObject * obj1 = 0 ;
20788 char * kwnames[] = {
20789 (char *) "client",(char *) "platform_dependent", NULL
20790 };
20791
20792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20793 {
20794 arg1 = wxString_in_helper(obj0);
20795 if (arg1 == NULL) SWIG_fail;
20796 temp1 = true;
20797 }
20798 if (obj1) {
20799 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20800 if (!SWIG_IsOK(ecode2)) {
20801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20802 }
20803 arg2 = static_cast< bool >(val2);
20804 }
20805 {
20806 PyThreadState* __tstate = wxPyBeginAllowThreads();
20807 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20808 wxPyEndAllowThreads(__tstate);
20809 if (PyErr_Occurred()) SWIG_fail;
20810 }
20811 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20812 {
20813 if (temp1)
20814 delete arg1;
20815 }
20816 return resultobj;
20817 fail:
20818 {
20819 if (temp1)
20820 delete arg1;
20821 }
20822 return NULL;
20823 }
20824
20825
20826 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20827 PyObject *resultobj = 0;
20828 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20829 void *argp1 = 0 ;
20830 int res1 = 0 ;
20831 PyObject *swig_obj[1] ;
20832
20833 if (!args) SWIG_fail;
20834 swig_obj[0] = args;
20835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20836 if (!SWIG_IsOK(res1)) {
20837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20838 }
20839 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20840 {
20841 PyThreadState* __tstate = wxPyBeginAllowThreads();
20842 wxPyArtProvider_Destroy(arg1);
20843 wxPyEndAllowThreads(__tstate);
20844 if (PyErr_Occurred()) SWIG_fail;
20845 }
20846 resultobj = SWIG_Py_Void();
20847 return resultobj;
20848 fail:
20849 return NULL;
20850 }
20851
20852
20853 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20854 PyObject *obj;
20855 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20856 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20857 return SWIG_Py_Void();
20858 }
20859
20860 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20861 return SWIG_Python_InitShadowInstance(args);
20862 }
20863
20864 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20865 PyObject *resultobj = 0;
20866 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20867 void *argp1 = 0 ;
20868 int res1 = 0 ;
20869 PyObject *swig_obj[1] ;
20870
20871 if (!args) SWIG_fail;
20872 swig_obj[0] = args;
20873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20874 if (!SWIG_IsOK(res1)) {
20875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20876 }
20877 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20878 {
20879 PyThreadState* __tstate = wxPyBeginAllowThreads();
20880 delete arg1;
20881
20882 wxPyEndAllowThreads(__tstate);
20883 if (PyErr_Occurred()) SWIG_fail;
20884 }
20885 resultobj = SWIG_Py_Void();
20886 return resultobj;
20887 fail:
20888 return NULL;
20889 }
20890
20891
20892 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20893 PyObject *resultobj = 0;
20894 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20895 wxConfigBase *result = 0 ;
20896 int res1 = 0 ;
20897 PyObject * obj0 = 0 ;
20898 char * kwnames[] = {
20899 (char *) "config", NULL
20900 };
20901
20902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20903 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20904 if (!SWIG_IsOK(res1)) {
20905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20906 }
20907 {
20908 PyThreadState* __tstate = wxPyBeginAllowThreads();
20909 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20910 wxPyEndAllowThreads(__tstate);
20911 if (PyErr_Occurred()) SWIG_fail;
20912 }
20913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20914 return resultobj;
20915 fail:
20916 return NULL;
20917 }
20918
20919
20920 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20921 PyObject *resultobj = 0;
20922 bool arg1 = (bool) true ;
20923 wxConfigBase *result = 0 ;
20924 bool val1 ;
20925 int ecode1 = 0 ;
20926 PyObject * obj0 = 0 ;
20927 char * kwnames[] = {
20928 (char *) "createOnDemand", NULL
20929 };
20930
20931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20932 if (obj0) {
20933 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20934 if (!SWIG_IsOK(ecode1)) {
20935 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20936 }
20937 arg1 = static_cast< bool >(val1);
20938 }
20939 {
20940 PyThreadState* __tstate = wxPyBeginAllowThreads();
20941 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20942 wxPyEndAllowThreads(__tstate);
20943 if (PyErr_Occurred()) SWIG_fail;
20944 }
20945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20946 return resultobj;
20947 fail:
20948 return NULL;
20949 }
20950
20951
20952 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20953 PyObject *resultobj = 0;
20954 wxConfigBase *result = 0 ;
20955
20956 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20957 {
20958 PyThreadState* __tstate = wxPyBeginAllowThreads();
20959 result = (wxConfigBase *)wxConfigBase::Create();
20960 wxPyEndAllowThreads(__tstate);
20961 if (PyErr_Occurred()) SWIG_fail;
20962 }
20963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20964 return resultobj;
20965 fail:
20966 return NULL;
20967 }
20968
20969
20970 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20971 PyObject *resultobj = 0;
20972
20973 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20974 {
20975 PyThreadState* __tstate = wxPyBeginAllowThreads();
20976 wxConfigBase::DontCreateOnDemand();
20977 wxPyEndAllowThreads(__tstate);
20978 if (PyErr_Occurred()) SWIG_fail;
20979 }
20980 resultobj = SWIG_Py_Void();
20981 return resultobj;
20982 fail:
20983 return NULL;
20984 }
20985
20986
20987 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20988 PyObject *resultobj = 0;
20989 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20990 wxString *arg2 = 0 ;
20991 void *argp1 = 0 ;
20992 int res1 = 0 ;
20993 bool temp2 = false ;
20994 PyObject * obj0 = 0 ;
20995 PyObject * obj1 = 0 ;
20996 char * kwnames[] = {
20997 (char *) "self",(char *) "path", NULL
20998 };
20999
21000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
21001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21002 if (!SWIG_IsOK(res1)) {
21003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21004 }
21005 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21006 {
21007 arg2 = wxString_in_helper(obj1);
21008 if (arg2 == NULL) SWIG_fail;
21009 temp2 = true;
21010 }
21011 {
21012 PyThreadState* __tstate = wxPyBeginAllowThreads();
21013 (arg1)->SetPath((wxString const &)*arg2);
21014 wxPyEndAllowThreads(__tstate);
21015 if (PyErr_Occurred()) SWIG_fail;
21016 }
21017 resultobj = SWIG_Py_Void();
21018 {
21019 if (temp2)
21020 delete arg2;
21021 }
21022 return resultobj;
21023 fail:
21024 {
21025 if (temp2)
21026 delete arg2;
21027 }
21028 return NULL;
21029 }
21030
21031
21032 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21033 PyObject *resultobj = 0;
21034 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21035 wxString *result = 0 ;
21036 void *argp1 = 0 ;
21037 int res1 = 0 ;
21038 PyObject *swig_obj[1] ;
21039
21040 if (!args) SWIG_fail;
21041 swig_obj[0] = args;
21042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21043 if (!SWIG_IsOK(res1)) {
21044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21045 }
21046 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21047 {
21048 PyThreadState* __tstate = wxPyBeginAllowThreads();
21049 {
21050 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
21051 result = (wxString *) &_result_ref;
21052 }
21053 wxPyEndAllowThreads(__tstate);
21054 if (PyErr_Occurred()) SWIG_fail;
21055 }
21056 {
21057 #if wxUSE_UNICODE
21058 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21059 #else
21060 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21061 #endif
21062 }
21063 return resultobj;
21064 fail:
21065 return NULL;
21066 }
21067
21068
21069 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21070 PyObject *resultobj = 0;
21071 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21072 PyObject *result = 0 ;
21073 void *argp1 = 0 ;
21074 int res1 = 0 ;
21075 PyObject *swig_obj[1] ;
21076
21077 if (!args) SWIG_fail;
21078 swig_obj[0] = args;
21079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21080 if (!SWIG_IsOK(res1)) {
21081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21082 }
21083 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21084 {
21085 PyThreadState* __tstate = wxPyBeginAllowThreads();
21086 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
21087 wxPyEndAllowThreads(__tstate);
21088 if (PyErr_Occurred()) SWIG_fail;
21089 }
21090 resultobj = result;
21091 return resultobj;
21092 fail:
21093 return NULL;
21094 }
21095
21096
21097 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21098 PyObject *resultobj = 0;
21099 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21100 long arg2 ;
21101 PyObject *result = 0 ;
21102 void *argp1 = 0 ;
21103 int res1 = 0 ;
21104 long val2 ;
21105 int ecode2 = 0 ;
21106 PyObject * obj0 = 0 ;
21107 PyObject * obj1 = 0 ;
21108 char * kwnames[] = {
21109 (char *) "self",(char *) "index", NULL
21110 };
21111
21112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21114 if (!SWIG_IsOK(res1)) {
21115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21116 }
21117 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21118 ecode2 = SWIG_AsVal_long(obj1, &val2);
21119 if (!SWIG_IsOK(ecode2)) {
21120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21121 }
21122 arg2 = static_cast< long >(val2);
21123 {
21124 PyThreadState* __tstate = wxPyBeginAllowThreads();
21125 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21126 wxPyEndAllowThreads(__tstate);
21127 if (PyErr_Occurred()) SWIG_fail;
21128 }
21129 resultobj = result;
21130 return resultobj;
21131 fail:
21132 return NULL;
21133 }
21134
21135
21136 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21137 PyObject *resultobj = 0;
21138 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21139 PyObject *result = 0 ;
21140 void *argp1 = 0 ;
21141 int res1 = 0 ;
21142 PyObject *swig_obj[1] ;
21143
21144 if (!args) SWIG_fail;
21145 swig_obj[0] = args;
21146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21147 if (!SWIG_IsOK(res1)) {
21148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21149 }
21150 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21151 {
21152 PyThreadState* __tstate = wxPyBeginAllowThreads();
21153 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21154 wxPyEndAllowThreads(__tstate);
21155 if (PyErr_Occurred()) SWIG_fail;
21156 }
21157 resultobj = result;
21158 return resultobj;
21159 fail:
21160 return NULL;
21161 }
21162
21163
21164 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21165 PyObject *resultobj = 0;
21166 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21167 long arg2 ;
21168 PyObject *result = 0 ;
21169 void *argp1 = 0 ;
21170 int res1 = 0 ;
21171 long val2 ;
21172 int ecode2 = 0 ;
21173 PyObject * obj0 = 0 ;
21174 PyObject * obj1 = 0 ;
21175 char * kwnames[] = {
21176 (char *) "self",(char *) "index", NULL
21177 };
21178
21179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21181 if (!SWIG_IsOK(res1)) {
21182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21183 }
21184 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21185 ecode2 = SWIG_AsVal_long(obj1, &val2);
21186 if (!SWIG_IsOK(ecode2)) {
21187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21188 }
21189 arg2 = static_cast< long >(val2);
21190 {
21191 PyThreadState* __tstate = wxPyBeginAllowThreads();
21192 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21193 wxPyEndAllowThreads(__tstate);
21194 if (PyErr_Occurred()) SWIG_fail;
21195 }
21196 resultobj = result;
21197 return resultobj;
21198 fail:
21199 return NULL;
21200 }
21201
21202
21203 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21204 PyObject *resultobj = 0;
21205 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21206 bool arg2 = (bool) false ;
21207 size_t result;
21208 void *argp1 = 0 ;
21209 int res1 = 0 ;
21210 bool val2 ;
21211 int ecode2 = 0 ;
21212 PyObject * obj0 = 0 ;
21213 PyObject * obj1 = 0 ;
21214 char * kwnames[] = {
21215 (char *) "self",(char *) "recursive", NULL
21216 };
21217
21218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21220 if (!SWIG_IsOK(res1)) {
21221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21222 }
21223 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21224 if (obj1) {
21225 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21226 if (!SWIG_IsOK(ecode2)) {
21227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21228 }
21229 arg2 = static_cast< bool >(val2);
21230 }
21231 {
21232 PyThreadState* __tstate = wxPyBeginAllowThreads();
21233 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21234 wxPyEndAllowThreads(__tstate);
21235 if (PyErr_Occurred()) SWIG_fail;
21236 }
21237 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21238 return resultobj;
21239 fail:
21240 return NULL;
21241 }
21242
21243
21244 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21245 PyObject *resultobj = 0;
21246 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21247 bool arg2 = (bool) false ;
21248 size_t result;
21249 void *argp1 = 0 ;
21250 int res1 = 0 ;
21251 bool val2 ;
21252 int ecode2 = 0 ;
21253 PyObject * obj0 = 0 ;
21254 PyObject * obj1 = 0 ;
21255 char * kwnames[] = {
21256 (char *) "self",(char *) "recursive", NULL
21257 };
21258
21259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21261 if (!SWIG_IsOK(res1)) {
21262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21263 }
21264 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21265 if (obj1) {
21266 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21267 if (!SWIG_IsOK(ecode2)) {
21268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21269 }
21270 arg2 = static_cast< bool >(val2);
21271 }
21272 {
21273 PyThreadState* __tstate = wxPyBeginAllowThreads();
21274 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21275 wxPyEndAllowThreads(__tstate);
21276 if (PyErr_Occurred()) SWIG_fail;
21277 }
21278 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21279 return resultobj;
21280 fail:
21281 return NULL;
21282 }
21283
21284
21285 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21286 PyObject *resultobj = 0;
21287 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21288 wxString *arg2 = 0 ;
21289 bool result;
21290 void *argp1 = 0 ;
21291 int res1 = 0 ;
21292 bool temp2 = false ;
21293 PyObject * obj0 = 0 ;
21294 PyObject * obj1 = 0 ;
21295 char * kwnames[] = {
21296 (char *) "self",(char *) "name", NULL
21297 };
21298
21299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21301 if (!SWIG_IsOK(res1)) {
21302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21303 }
21304 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21305 {
21306 arg2 = wxString_in_helper(obj1);
21307 if (arg2 == NULL) SWIG_fail;
21308 temp2 = true;
21309 }
21310 {
21311 PyThreadState* __tstate = wxPyBeginAllowThreads();
21312 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21313 wxPyEndAllowThreads(__tstate);
21314 if (PyErr_Occurred()) SWIG_fail;
21315 }
21316 {
21317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21318 }
21319 {
21320 if (temp2)
21321 delete arg2;
21322 }
21323 return resultobj;
21324 fail:
21325 {
21326 if (temp2)
21327 delete arg2;
21328 }
21329 return NULL;
21330 }
21331
21332
21333 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21334 PyObject *resultobj = 0;
21335 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21336 wxString *arg2 = 0 ;
21337 bool result;
21338 void *argp1 = 0 ;
21339 int res1 = 0 ;
21340 bool temp2 = false ;
21341 PyObject * obj0 = 0 ;
21342 PyObject * obj1 = 0 ;
21343 char * kwnames[] = {
21344 (char *) "self",(char *) "name", NULL
21345 };
21346
21347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21349 if (!SWIG_IsOK(res1)) {
21350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21351 }
21352 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21353 {
21354 arg2 = wxString_in_helper(obj1);
21355 if (arg2 == NULL) SWIG_fail;
21356 temp2 = true;
21357 }
21358 {
21359 PyThreadState* __tstate = wxPyBeginAllowThreads();
21360 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21361 wxPyEndAllowThreads(__tstate);
21362 if (PyErr_Occurred()) SWIG_fail;
21363 }
21364 {
21365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21366 }
21367 {
21368 if (temp2)
21369 delete arg2;
21370 }
21371 return resultobj;
21372 fail:
21373 {
21374 if (temp2)
21375 delete arg2;
21376 }
21377 return NULL;
21378 }
21379
21380
21381 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21382 PyObject *resultobj = 0;
21383 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21384 wxString *arg2 = 0 ;
21385 bool result;
21386 void *argp1 = 0 ;
21387 int res1 = 0 ;
21388 bool temp2 = false ;
21389 PyObject * obj0 = 0 ;
21390 PyObject * obj1 = 0 ;
21391 char * kwnames[] = {
21392 (char *) "self",(char *) "name", NULL
21393 };
21394
21395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21397 if (!SWIG_IsOK(res1)) {
21398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21399 }
21400 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21401 {
21402 arg2 = wxString_in_helper(obj1);
21403 if (arg2 == NULL) SWIG_fail;
21404 temp2 = true;
21405 }
21406 {
21407 PyThreadState* __tstate = wxPyBeginAllowThreads();
21408 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21409 wxPyEndAllowThreads(__tstate);
21410 if (PyErr_Occurred()) SWIG_fail;
21411 }
21412 {
21413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21414 }
21415 {
21416 if (temp2)
21417 delete arg2;
21418 }
21419 return resultobj;
21420 fail:
21421 {
21422 if (temp2)
21423 delete arg2;
21424 }
21425 return NULL;
21426 }
21427
21428
21429 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21430 PyObject *resultobj = 0;
21431 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21432 wxString *arg2 = 0 ;
21433 wxConfigBase::EntryType result;
21434 void *argp1 = 0 ;
21435 int res1 = 0 ;
21436 bool temp2 = false ;
21437 PyObject * obj0 = 0 ;
21438 PyObject * obj1 = 0 ;
21439 char * kwnames[] = {
21440 (char *) "self",(char *) "name", NULL
21441 };
21442
21443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21445 if (!SWIG_IsOK(res1)) {
21446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21447 }
21448 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21449 {
21450 arg2 = wxString_in_helper(obj1);
21451 if (arg2 == NULL) SWIG_fail;
21452 temp2 = true;
21453 }
21454 {
21455 PyThreadState* __tstate = wxPyBeginAllowThreads();
21456 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21457 wxPyEndAllowThreads(__tstate);
21458 if (PyErr_Occurred()) SWIG_fail;
21459 }
21460 resultobj = SWIG_From_int(static_cast< int >(result));
21461 {
21462 if (temp2)
21463 delete arg2;
21464 }
21465 return resultobj;
21466 fail:
21467 {
21468 if (temp2)
21469 delete arg2;
21470 }
21471 return NULL;
21472 }
21473
21474
21475 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21476 PyObject *resultobj = 0;
21477 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21478 wxString *arg2 = 0 ;
21479 wxString const &arg3_defvalue = wxPyEmptyString ;
21480 wxString *arg3 = (wxString *) &arg3_defvalue ;
21481 wxString result;
21482 void *argp1 = 0 ;
21483 int res1 = 0 ;
21484 bool temp2 = false ;
21485 bool temp3 = false ;
21486 PyObject * obj0 = 0 ;
21487 PyObject * obj1 = 0 ;
21488 PyObject * obj2 = 0 ;
21489 char * kwnames[] = {
21490 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21491 };
21492
21493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21495 if (!SWIG_IsOK(res1)) {
21496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21497 }
21498 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21499 {
21500 arg2 = wxString_in_helper(obj1);
21501 if (arg2 == NULL) SWIG_fail;
21502 temp2 = true;
21503 }
21504 if (obj2) {
21505 {
21506 arg3 = wxString_in_helper(obj2);
21507 if (arg3 == NULL) SWIG_fail;
21508 temp3 = true;
21509 }
21510 }
21511 {
21512 PyThreadState* __tstate = wxPyBeginAllowThreads();
21513 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21514 wxPyEndAllowThreads(__tstate);
21515 if (PyErr_Occurred()) SWIG_fail;
21516 }
21517 {
21518 #if wxUSE_UNICODE
21519 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21520 #else
21521 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21522 #endif
21523 }
21524 {
21525 if (temp2)
21526 delete arg2;
21527 }
21528 {
21529 if (temp3)
21530 delete arg3;
21531 }
21532 return resultobj;
21533 fail:
21534 {
21535 if (temp2)
21536 delete arg2;
21537 }
21538 {
21539 if (temp3)
21540 delete arg3;
21541 }
21542 return NULL;
21543 }
21544
21545
21546 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21547 PyObject *resultobj = 0;
21548 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21549 wxString *arg2 = 0 ;
21550 long arg3 = (long) 0 ;
21551 long result;
21552 void *argp1 = 0 ;
21553 int res1 = 0 ;
21554 bool temp2 = false ;
21555 long val3 ;
21556 int ecode3 = 0 ;
21557 PyObject * obj0 = 0 ;
21558 PyObject * obj1 = 0 ;
21559 PyObject * obj2 = 0 ;
21560 char * kwnames[] = {
21561 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21562 };
21563
21564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21566 if (!SWIG_IsOK(res1)) {
21567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21568 }
21569 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21570 {
21571 arg2 = wxString_in_helper(obj1);
21572 if (arg2 == NULL) SWIG_fail;
21573 temp2 = true;
21574 }
21575 if (obj2) {
21576 ecode3 = SWIG_AsVal_long(obj2, &val3);
21577 if (!SWIG_IsOK(ecode3)) {
21578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21579 }
21580 arg3 = static_cast< long >(val3);
21581 }
21582 {
21583 PyThreadState* __tstate = wxPyBeginAllowThreads();
21584 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21585 wxPyEndAllowThreads(__tstate);
21586 if (PyErr_Occurred()) SWIG_fail;
21587 }
21588 resultobj = SWIG_From_long(static_cast< long >(result));
21589 {
21590 if (temp2)
21591 delete arg2;
21592 }
21593 return resultobj;
21594 fail:
21595 {
21596 if (temp2)
21597 delete arg2;
21598 }
21599 return NULL;
21600 }
21601
21602
21603 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21604 PyObject *resultobj = 0;
21605 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21606 wxString *arg2 = 0 ;
21607 double arg3 = (double) 0.0 ;
21608 double result;
21609 void *argp1 = 0 ;
21610 int res1 = 0 ;
21611 bool temp2 = false ;
21612 double val3 ;
21613 int ecode3 = 0 ;
21614 PyObject * obj0 = 0 ;
21615 PyObject * obj1 = 0 ;
21616 PyObject * obj2 = 0 ;
21617 char * kwnames[] = {
21618 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21619 };
21620
21621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21623 if (!SWIG_IsOK(res1)) {
21624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21625 }
21626 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21627 {
21628 arg2 = wxString_in_helper(obj1);
21629 if (arg2 == NULL) SWIG_fail;
21630 temp2 = true;
21631 }
21632 if (obj2) {
21633 ecode3 = SWIG_AsVal_double(obj2, &val3);
21634 if (!SWIG_IsOK(ecode3)) {
21635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21636 }
21637 arg3 = static_cast< double >(val3);
21638 }
21639 {
21640 PyThreadState* __tstate = wxPyBeginAllowThreads();
21641 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21642 wxPyEndAllowThreads(__tstate);
21643 if (PyErr_Occurred()) SWIG_fail;
21644 }
21645 resultobj = SWIG_From_double(static_cast< double >(result));
21646 {
21647 if (temp2)
21648 delete arg2;
21649 }
21650 return resultobj;
21651 fail:
21652 {
21653 if (temp2)
21654 delete arg2;
21655 }
21656 return NULL;
21657 }
21658
21659
21660 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21661 PyObject *resultobj = 0;
21662 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21663 wxString *arg2 = 0 ;
21664 bool arg3 = (bool) false ;
21665 bool result;
21666 void *argp1 = 0 ;
21667 int res1 = 0 ;
21668 bool temp2 = false ;
21669 bool val3 ;
21670 int ecode3 = 0 ;
21671 PyObject * obj0 = 0 ;
21672 PyObject * obj1 = 0 ;
21673 PyObject * obj2 = 0 ;
21674 char * kwnames[] = {
21675 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21676 };
21677
21678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21680 if (!SWIG_IsOK(res1)) {
21681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21682 }
21683 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21684 {
21685 arg2 = wxString_in_helper(obj1);
21686 if (arg2 == NULL) SWIG_fail;
21687 temp2 = true;
21688 }
21689 if (obj2) {
21690 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21691 if (!SWIG_IsOK(ecode3)) {
21692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21693 }
21694 arg3 = static_cast< bool >(val3);
21695 }
21696 {
21697 PyThreadState* __tstate = wxPyBeginAllowThreads();
21698 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21699 wxPyEndAllowThreads(__tstate);
21700 if (PyErr_Occurred()) SWIG_fail;
21701 }
21702 {
21703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21704 }
21705 {
21706 if (temp2)
21707 delete arg2;
21708 }
21709 return resultobj;
21710 fail:
21711 {
21712 if (temp2)
21713 delete arg2;
21714 }
21715 return NULL;
21716 }
21717
21718
21719 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21720 PyObject *resultobj = 0;
21721 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21722 wxString *arg2 = 0 ;
21723 wxString *arg3 = 0 ;
21724 bool result;
21725 void *argp1 = 0 ;
21726 int res1 = 0 ;
21727 bool temp2 = false ;
21728 bool temp3 = false ;
21729 PyObject * obj0 = 0 ;
21730 PyObject * obj1 = 0 ;
21731 PyObject * obj2 = 0 ;
21732 char * kwnames[] = {
21733 (char *) "self",(char *) "key",(char *) "value", NULL
21734 };
21735
21736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21738 if (!SWIG_IsOK(res1)) {
21739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21740 }
21741 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21742 {
21743 arg2 = wxString_in_helper(obj1);
21744 if (arg2 == NULL) SWIG_fail;
21745 temp2 = true;
21746 }
21747 {
21748 arg3 = wxString_in_helper(obj2);
21749 if (arg3 == NULL) SWIG_fail;
21750 temp3 = true;
21751 }
21752 {
21753 PyThreadState* __tstate = wxPyBeginAllowThreads();
21754 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21755 wxPyEndAllowThreads(__tstate);
21756 if (PyErr_Occurred()) SWIG_fail;
21757 }
21758 {
21759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21760 }
21761 {
21762 if (temp2)
21763 delete arg2;
21764 }
21765 {
21766 if (temp3)
21767 delete arg3;
21768 }
21769 return resultobj;
21770 fail:
21771 {
21772 if (temp2)
21773 delete arg2;
21774 }
21775 {
21776 if (temp3)
21777 delete arg3;
21778 }
21779 return NULL;
21780 }
21781
21782
21783 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21784 PyObject *resultobj = 0;
21785 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21786 wxString *arg2 = 0 ;
21787 long arg3 ;
21788 bool result;
21789 void *argp1 = 0 ;
21790 int res1 = 0 ;
21791 bool temp2 = false ;
21792 long val3 ;
21793 int ecode3 = 0 ;
21794 PyObject * obj0 = 0 ;
21795 PyObject * obj1 = 0 ;
21796 PyObject * obj2 = 0 ;
21797 char * kwnames[] = {
21798 (char *) "self",(char *) "key",(char *) "value", NULL
21799 };
21800
21801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21803 if (!SWIG_IsOK(res1)) {
21804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21805 }
21806 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21807 {
21808 arg2 = wxString_in_helper(obj1);
21809 if (arg2 == NULL) SWIG_fail;
21810 temp2 = true;
21811 }
21812 ecode3 = SWIG_AsVal_long(obj2, &val3);
21813 if (!SWIG_IsOK(ecode3)) {
21814 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21815 }
21816 arg3 = static_cast< long >(val3);
21817 {
21818 PyThreadState* __tstate = wxPyBeginAllowThreads();
21819 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21820 wxPyEndAllowThreads(__tstate);
21821 if (PyErr_Occurred()) SWIG_fail;
21822 }
21823 {
21824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21825 }
21826 {
21827 if (temp2)
21828 delete arg2;
21829 }
21830 return resultobj;
21831 fail:
21832 {
21833 if (temp2)
21834 delete arg2;
21835 }
21836 return NULL;
21837 }
21838
21839
21840 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21841 PyObject *resultobj = 0;
21842 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21843 wxString *arg2 = 0 ;
21844 double arg3 ;
21845 bool result;
21846 void *argp1 = 0 ;
21847 int res1 = 0 ;
21848 bool temp2 = false ;
21849 double val3 ;
21850 int ecode3 = 0 ;
21851 PyObject * obj0 = 0 ;
21852 PyObject * obj1 = 0 ;
21853 PyObject * obj2 = 0 ;
21854 char * kwnames[] = {
21855 (char *) "self",(char *) "key",(char *) "value", NULL
21856 };
21857
21858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21860 if (!SWIG_IsOK(res1)) {
21861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21862 }
21863 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21864 {
21865 arg2 = wxString_in_helper(obj1);
21866 if (arg2 == NULL) SWIG_fail;
21867 temp2 = true;
21868 }
21869 ecode3 = SWIG_AsVal_double(obj2, &val3);
21870 if (!SWIG_IsOK(ecode3)) {
21871 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21872 }
21873 arg3 = static_cast< double >(val3);
21874 {
21875 PyThreadState* __tstate = wxPyBeginAllowThreads();
21876 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21877 wxPyEndAllowThreads(__tstate);
21878 if (PyErr_Occurred()) SWIG_fail;
21879 }
21880 {
21881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21882 }
21883 {
21884 if (temp2)
21885 delete arg2;
21886 }
21887 return resultobj;
21888 fail:
21889 {
21890 if (temp2)
21891 delete arg2;
21892 }
21893 return NULL;
21894 }
21895
21896
21897 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21898 PyObject *resultobj = 0;
21899 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21900 wxString *arg2 = 0 ;
21901 bool arg3 ;
21902 bool result;
21903 void *argp1 = 0 ;
21904 int res1 = 0 ;
21905 bool temp2 = false ;
21906 bool val3 ;
21907 int ecode3 = 0 ;
21908 PyObject * obj0 = 0 ;
21909 PyObject * obj1 = 0 ;
21910 PyObject * obj2 = 0 ;
21911 char * kwnames[] = {
21912 (char *) "self",(char *) "key",(char *) "value", NULL
21913 };
21914
21915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21917 if (!SWIG_IsOK(res1)) {
21918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21919 }
21920 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21921 {
21922 arg2 = wxString_in_helper(obj1);
21923 if (arg2 == NULL) SWIG_fail;
21924 temp2 = true;
21925 }
21926 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21927 if (!SWIG_IsOK(ecode3)) {
21928 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21929 }
21930 arg3 = static_cast< bool >(val3);
21931 {
21932 PyThreadState* __tstate = wxPyBeginAllowThreads();
21933 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21934 wxPyEndAllowThreads(__tstate);
21935 if (PyErr_Occurred()) SWIG_fail;
21936 }
21937 {
21938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21939 }
21940 {
21941 if (temp2)
21942 delete arg2;
21943 }
21944 return resultobj;
21945 fail:
21946 {
21947 if (temp2)
21948 delete arg2;
21949 }
21950 return NULL;
21951 }
21952
21953
21954 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21955 PyObject *resultobj = 0;
21956 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21957 bool arg2 = (bool) false ;
21958 bool result;
21959 void *argp1 = 0 ;
21960 int res1 = 0 ;
21961 bool val2 ;
21962 int ecode2 = 0 ;
21963 PyObject * obj0 = 0 ;
21964 PyObject * obj1 = 0 ;
21965 char * kwnames[] = {
21966 (char *) "self",(char *) "currentOnly", NULL
21967 };
21968
21969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21971 if (!SWIG_IsOK(res1)) {
21972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21973 }
21974 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21975 if (obj1) {
21976 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21977 if (!SWIG_IsOK(ecode2)) {
21978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21979 }
21980 arg2 = static_cast< bool >(val2);
21981 }
21982 {
21983 PyThreadState* __tstate = wxPyBeginAllowThreads();
21984 result = (bool)(arg1)->Flush(arg2);
21985 wxPyEndAllowThreads(__tstate);
21986 if (PyErr_Occurred()) SWIG_fail;
21987 }
21988 {
21989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21990 }
21991 return resultobj;
21992 fail:
21993 return NULL;
21994 }
21995
21996
21997 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21998 PyObject *resultobj = 0;
21999 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22000 wxString *arg2 = 0 ;
22001 wxString *arg3 = 0 ;
22002 bool result;
22003 void *argp1 = 0 ;
22004 int res1 = 0 ;
22005 bool temp2 = false ;
22006 bool temp3 = false ;
22007 PyObject * obj0 = 0 ;
22008 PyObject * obj1 = 0 ;
22009 PyObject * obj2 = 0 ;
22010 char * kwnames[] = {
22011 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22012 };
22013
22014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22016 if (!SWIG_IsOK(res1)) {
22017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22018 }
22019 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22020 {
22021 arg2 = wxString_in_helper(obj1);
22022 if (arg2 == NULL) SWIG_fail;
22023 temp2 = true;
22024 }
22025 {
22026 arg3 = wxString_in_helper(obj2);
22027 if (arg3 == NULL) SWIG_fail;
22028 temp3 = true;
22029 }
22030 {
22031 PyThreadState* __tstate = wxPyBeginAllowThreads();
22032 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
22033 wxPyEndAllowThreads(__tstate);
22034 if (PyErr_Occurred()) SWIG_fail;
22035 }
22036 {
22037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22038 }
22039 {
22040 if (temp2)
22041 delete arg2;
22042 }
22043 {
22044 if (temp3)
22045 delete arg3;
22046 }
22047 return resultobj;
22048 fail:
22049 {
22050 if (temp2)
22051 delete arg2;
22052 }
22053 {
22054 if (temp3)
22055 delete arg3;
22056 }
22057 return NULL;
22058 }
22059
22060
22061 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22062 PyObject *resultobj = 0;
22063 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22064 wxString *arg2 = 0 ;
22065 wxString *arg3 = 0 ;
22066 bool result;
22067 void *argp1 = 0 ;
22068 int res1 = 0 ;
22069 bool temp2 = false ;
22070 bool temp3 = false ;
22071 PyObject * obj0 = 0 ;
22072 PyObject * obj1 = 0 ;
22073 PyObject * obj2 = 0 ;
22074 char * kwnames[] = {
22075 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22076 };
22077
22078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22080 if (!SWIG_IsOK(res1)) {
22081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22082 }
22083 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22084 {
22085 arg2 = wxString_in_helper(obj1);
22086 if (arg2 == NULL) SWIG_fail;
22087 temp2 = true;
22088 }
22089 {
22090 arg3 = wxString_in_helper(obj2);
22091 if (arg3 == NULL) SWIG_fail;
22092 temp3 = true;
22093 }
22094 {
22095 PyThreadState* __tstate = wxPyBeginAllowThreads();
22096 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
22097 wxPyEndAllowThreads(__tstate);
22098 if (PyErr_Occurred()) SWIG_fail;
22099 }
22100 {
22101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22102 }
22103 {
22104 if (temp2)
22105 delete arg2;
22106 }
22107 {
22108 if (temp3)
22109 delete arg3;
22110 }
22111 return resultobj;
22112 fail:
22113 {
22114 if (temp2)
22115 delete arg2;
22116 }
22117 {
22118 if (temp3)
22119 delete arg3;
22120 }
22121 return NULL;
22122 }
22123
22124
22125 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22126 PyObject *resultobj = 0;
22127 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22128 wxString *arg2 = 0 ;
22129 bool arg3 = (bool) true ;
22130 bool result;
22131 void *argp1 = 0 ;
22132 int res1 = 0 ;
22133 bool temp2 = false ;
22134 bool val3 ;
22135 int ecode3 = 0 ;
22136 PyObject * obj0 = 0 ;
22137 PyObject * obj1 = 0 ;
22138 PyObject * obj2 = 0 ;
22139 char * kwnames[] = {
22140 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22141 };
22142
22143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22145 if (!SWIG_IsOK(res1)) {
22146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22147 }
22148 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22149 {
22150 arg2 = wxString_in_helper(obj1);
22151 if (arg2 == NULL) SWIG_fail;
22152 temp2 = true;
22153 }
22154 if (obj2) {
22155 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22156 if (!SWIG_IsOK(ecode3)) {
22157 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22158 }
22159 arg3 = static_cast< bool >(val3);
22160 }
22161 {
22162 PyThreadState* __tstate = wxPyBeginAllowThreads();
22163 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22164 wxPyEndAllowThreads(__tstate);
22165 if (PyErr_Occurred()) SWIG_fail;
22166 }
22167 {
22168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22169 }
22170 {
22171 if (temp2)
22172 delete arg2;
22173 }
22174 return resultobj;
22175 fail:
22176 {
22177 if (temp2)
22178 delete arg2;
22179 }
22180 return NULL;
22181 }
22182
22183
22184 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22185 PyObject *resultobj = 0;
22186 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22187 wxString *arg2 = 0 ;
22188 bool result;
22189 void *argp1 = 0 ;
22190 int res1 = 0 ;
22191 bool temp2 = false ;
22192 PyObject * obj0 = 0 ;
22193 PyObject * obj1 = 0 ;
22194 char * kwnames[] = {
22195 (char *) "self",(char *) "key", NULL
22196 };
22197
22198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22200 if (!SWIG_IsOK(res1)) {
22201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22202 }
22203 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22204 {
22205 arg2 = wxString_in_helper(obj1);
22206 if (arg2 == NULL) SWIG_fail;
22207 temp2 = true;
22208 }
22209 {
22210 PyThreadState* __tstate = wxPyBeginAllowThreads();
22211 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22212 wxPyEndAllowThreads(__tstate);
22213 if (PyErr_Occurred()) SWIG_fail;
22214 }
22215 {
22216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22217 }
22218 {
22219 if (temp2)
22220 delete arg2;
22221 }
22222 return resultobj;
22223 fail:
22224 {
22225 if (temp2)
22226 delete arg2;
22227 }
22228 return NULL;
22229 }
22230
22231
22232 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22233 PyObject *resultobj = 0;
22234 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22235 bool result;
22236 void *argp1 = 0 ;
22237 int res1 = 0 ;
22238 PyObject *swig_obj[1] ;
22239
22240 if (!args) SWIG_fail;
22241 swig_obj[0] = args;
22242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22243 if (!SWIG_IsOK(res1)) {
22244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22245 }
22246 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22247 {
22248 PyThreadState* __tstate = wxPyBeginAllowThreads();
22249 result = (bool)(arg1)->DeleteAll();
22250 wxPyEndAllowThreads(__tstate);
22251 if (PyErr_Occurred()) SWIG_fail;
22252 }
22253 {
22254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22255 }
22256 return resultobj;
22257 fail:
22258 return NULL;
22259 }
22260
22261
22262 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22263 PyObject *resultobj = 0;
22264 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22265 bool arg2 = (bool) true ;
22266 void *argp1 = 0 ;
22267 int res1 = 0 ;
22268 bool val2 ;
22269 int ecode2 = 0 ;
22270 PyObject * obj0 = 0 ;
22271 PyObject * obj1 = 0 ;
22272 char * kwnames[] = {
22273 (char *) "self",(char *) "doIt", NULL
22274 };
22275
22276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22278 if (!SWIG_IsOK(res1)) {
22279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22280 }
22281 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22282 if (obj1) {
22283 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22284 if (!SWIG_IsOK(ecode2)) {
22285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22286 }
22287 arg2 = static_cast< bool >(val2);
22288 }
22289 {
22290 PyThreadState* __tstate = wxPyBeginAllowThreads();
22291 (arg1)->SetExpandEnvVars(arg2);
22292 wxPyEndAllowThreads(__tstate);
22293 if (PyErr_Occurred()) SWIG_fail;
22294 }
22295 resultobj = SWIG_Py_Void();
22296 return resultobj;
22297 fail:
22298 return NULL;
22299 }
22300
22301
22302 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22303 PyObject *resultobj = 0;
22304 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22305 bool result;
22306 void *argp1 = 0 ;
22307 int res1 = 0 ;
22308 PyObject *swig_obj[1] ;
22309
22310 if (!args) SWIG_fail;
22311 swig_obj[0] = args;
22312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22313 if (!SWIG_IsOK(res1)) {
22314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22315 }
22316 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22317 {
22318 PyThreadState* __tstate = wxPyBeginAllowThreads();
22319 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22320 wxPyEndAllowThreads(__tstate);
22321 if (PyErr_Occurred()) SWIG_fail;
22322 }
22323 {
22324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22325 }
22326 return resultobj;
22327 fail:
22328 return NULL;
22329 }
22330
22331
22332 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22333 PyObject *resultobj = 0;
22334 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22335 bool arg2 = (bool) true ;
22336 void *argp1 = 0 ;
22337 int res1 = 0 ;
22338 bool val2 ;
22339 int ecode2 = 0 ;
22340 PyObject * obj0 = 0 ;
22341 PyObject * obj1 = 0 ;
22342 char * kwnames[] = {
22343 (char *) "self",(char *) "doIt", NULL
22344 };
22345
22346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22348 if (!SWIG_IsOK(res1)) {
22349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22350 }
22351 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22352 if (obj1) {
22353 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22354 if (!SWIG_IsOK(ecode2)) {
22355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22356 }
22357 arg2 = static_cast< bool >(val2);
22358 }
22359 {
22360 PyThreadState* __tstate = wxPyBeginAllowThreads();
22361 (arg1)->SetRecordDefaults(arg2);
22362 wxPyEndAllowThreads(__tstate);
22363 if (PyErr_Occurred()) SWIG_fail;
22364 }
22365 resultobj = SWIG_Py_Void();
22366 return resultobj;
22367 fail:
22368 return NULL;
22369 }
22370
22371
22372 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22373 PyObject *resultobj = 0;
22374 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22375 bool result;
22376 void *argp1 = 0 ;
22377 int res1 = 0 ;
22378 PyObject *swig_obj[1] ;
22379
22380 if (!args) SWIG_fail;
22381 swig_obj[0] = args;
22382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22383 if (!SWIG_IsOK(res1)) {
22384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22385 }
22386 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22387 {
22388 PyThreadState* __tstate = wxPyBeginAllowThreads();
22389 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22390 wxPyEndAllowThreads(__tstate);
22391 if (PyErr_Occurred()) SWIG_fail;
22392 }
22393 {
22394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22395 }
22396 return resultobj;
22397 fail:
22398 return NULL;
22399 }
22400
22401
22402 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22403 PyObject *resultobj = 0;
22404 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22405 wxString *arg2 = 0 ;
22406 wxString result;
22407 void *argp1 = 0 ;
22408 int res1 = 0 ;
22409 bool temp2 = false ;
22410 PyObject * obj0 = 0 ;
22411 PyObject * obj1 = 0 ;
22412 char * kwnames[] = {
22413 (char *) "self",(char *) "str", NULL
22414 };
22415
22416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22418 if (!SWIG_IsOK(res1)) {
22419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22420 }
22421 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22422 {
22423 arg2 = wxString_in_helper(obj1);
22424 if (arg2 == NULL) SWIG_fail;
22425 temp2 = true;
22426 }
22427 {
22428 PyThreadState* __tstate = wxPyBeginAllowThreads();
22429 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22430 wxPyEndAllowThreads(__tstate);
22431 if (PyErr_Occurred()) SWIG_fail;
22432 }
22433 {
22434 #if wxUSE_UNICODE
22435 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22436 #else
22437 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22438 #endif
22439 }
22440 {
22441 if (temp2)
22442 delete arg2;
22443 }
22444 return resultobj;
22445 fail:
22446 {
22447 if (temp2)
22448 delete arg2;
22449 }
22450 return NULL;
22451 }
22452
22453
22454 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22455 PyObject *resultobj = 0;
22456 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22457 wxString result;
22458 void *argp1 = 0 ;
22459 int res1 = 0 ;
22460 PyObject *swig_obj[1] ;
22461
22462 if (!args) SWIG_fail;
22463 swig_obj[0] = args;
22464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22465 if (!SWIG_IsOK(res1)) {
22466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22467 }
22468 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22469 {
22470 PyThreadState* __tstate = wxPyBeginAllowThreads();
22471 result = ((wxConfigBase const *)arg1)->GetAppName();
22472 wxPyEndAllowThreads(__tstate);
22473 if (PyErr_Occurred()) SWIG_fail;
22474 }
22475 {
22476 #if wxUSE_UNICODE
22477 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22478 #else
22479 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22480 #endif
22481 }
22482 return resultobj;
22483 fail:
22484 return NULL;
22485 }
22486
22487
22488 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22489 PyObject *resultobj = 0;
22490 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22491 wxString result;
22492 void *argp1 = 0 ;
22493 int res1 = 0 ;
22494 PyObject *swig_obj[1] ;
22495
22496 if (!args) SWIG_fail;
22497 swig_obj[0] = args;
22498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22499 if (!SWIG_IsOK(res1)) {
22500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22501 }
22502 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22503 {
22504 PyThreadState* __tstate = wxPyBeginAllowThreads();
22505 result = ((wxConfigBase const *)arg1)->GetVendorName();
22506 wxPyEndAllowThreads(__tstate);
22507 if (PyErr_Occurred()) SWIG_fail;
22508 }
22509 {
22510 #if wxUSE_UNICODE
22511 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22512 #else
22513 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22514 #endif
22515 }
22516 return resultobj;
22517 fail:
22518 return NULL;
22519 }
22520
22521
22522 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22523 PyObject *resultobj = 0;
22524 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22525 wxString *arg2 = 0 ;
22526 void *argp1 = 0 ;
22527 int res1 = 0 ;
22528 bool temp2 = false ;
22529 PyObject * obj0 = 0 ;
22530 PyObject * obj1 = 0 ;
22531 char * kwnames[] = {
22532 (char *) "self",(char *) "appName", NULL
22533 };
22534
22535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22537 if (!SWIG_IsOK(res1)) {
22538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22539 }
22540 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22541 {
22542 arg2 = wxString_in_helper(obj1);
22543 if (arg2 == NULL) SWIG_fail;
22544 temp2 = true;
22545 }
22546 {
22547 PyThreadState* __tstate = wxPyBeginAllowThreads();
22548 (arg1)->SetAppName((wxString const &)*arg2);
22549 wxPyEndAllowThreads(__tstate);
22550 if (PyErr_Occurred()) SWIG_fail;
22551 }
22552 resultobj = SWIG_Py_Void();
22553 {
22554 if (temp2)
22555 delete arg2;
22556 }
22557 return resultobj;
22558 fail:
22559 {
22560 if (temp2)
22561 delete arg2;
22562 }
22563 return NULL;
22564 }
22565
22566
22567 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22568 PyObject *resultobj = 0;
22569 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22570 wxString *arg2 = 0 ;
22571 void *argp1 = 0 ;
22572 int res1 = 0 ;
22573 bool temp2 = false ;
22574 PyObject * obj0 = 0 ;
22575 PyObject * obj1 = 0 ;
22576 char * kwnames[] = {
22577 (char *) "self",(char *) "vendorName", NULL
22578 };
22579
22580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22582 if (!SWIG_IsOK(res1)) {
22583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22584 }
22585 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22586 {
22587 arg2 = wxString_in_helper(obj1);
22588 if (arg2 == NULL) SWIG_fail;
22589 temp2 = true;
22590 }
22591 {
22592 PyThreadState* __tstate = wxPyBeginAllowThreads();
22593 (arg1)->SetVendorName((wxString const &)*arg2);
22594 wxPyEndAllowThreads(__tstate);
22595 if (PyErr_Occurred()) SWIG_fail;
22596 }
22597 resultobj = SWIG_Py_Void();
22598 {
22599 if (temp2)
22600 delete arg2;
22601 }
22602 return resultobj;
22603 fail:
22604 {
22605 if (temp2)
22606 delete arg2;
22607 }
22608 return NULL;
22609 }
22610
22611
22612 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22613 PyObject *resultobj = 0;
22614 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22615 long arg2 ;
22616 void *argp1 = 0 ;
22617 int res1 = 0 ;
22618 long val2 ;
22619 int ecode2 = 0 ;
22620 PyObject * obj0 = 0 ;
22621 PyObject * obj1 = 0 ;
22622 char * kwnames[] = {
22623 (char *) "self",(char *) "style", NULL
22624 };
22625
22626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22628 if (!SWIG_IsOK(res1)) {
22629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22630 }
22631 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22632 ecode2 = SWIG_AsVal_long(obj1, &val2);
22633 if (!SWIG_IsOK(ecode2)) {
22634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22635 }
22636 arg2 = static_cast< long >(val2);
22637 {
22638 PyThreadState* __tstate = wxPyBeginAllowThreads();
22639 (arg1)->SetStyle(arg2);
22640 wxPyEndAllowThreads(__tstate);
22641 if (PyErr_Occurred()) SWIG_fail;
22642 }
22643 resultobj = SWIG_Py_Void();
22644 return resultobj;
22645 fail:
22646 return NULL;
22647 }
22648
22649
22650 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22651 PyObject *resultobj = 0;
22652 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22653 long result;
22654 void *argp1 = 0 ;
22655 int res1 = 0 ;
22656 PyObject *swig_obj[1] ;
22657
22658 if (!args) SWIG_fail;
22659 swig_obj[0] = args;
22660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22661 if (!SWIG_IsOK(res1)) {
22662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22663 }
22664 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22665 {
22666 PyThreadState* __tstate = wxPyBeginAllowThreads();
22667 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22668 wxPyEndAllowThreads(__tstate);
22669 if (PyErr_Occurred()) SWIG_fail;
22670 }
22671 resultobj = SWIG_From_long(static_cast< long >(result));
22672 return resultobj;
22673 fail:
22674 return NULL;
22675 }
22676
22677
22678 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22679 PyObject *obj;
22680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22681 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22682 return SWIG_Py_Void();
22683 }
22684
22685 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22686 PyObject *resultobj = 0;
22687 wxString const &arg1_defvalue = wxPyEmptyString ;
22688 wxString *arg1 = (wxString *) &arg1_defvalue ;
22689 wxString const &arg2_defvalue = wxPyEmptyString ;
22690 wxString *arg2 = (wxString *) &arg2_defvalue ;
22691 wxString const &arg3_defvalue = wxPyEmptyString ;
22692 wxString *arg3 = (wxString *) &arg3_defvalue ;
22693 wxString const &arg4_defvalue = wxPyEmptyString ;
22694 wxString *arg4 = (wxString *) &arg4_defvalue ;
22695 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22696 wxConfig *result = 0 ;
22697 bool temp1 = false ;
22698 bool temp2 = false ;
22699 bool temp3 = false ;
22700 bool temp4 = false ;
22701 long val5 ;
22702 int ecode5 = 0 ;
22703 PyObject * obj0 = 0 ;
22704 PyObject * obj1 = 0 ;
22705 PyObject * obj2 = 0 ;
22706 PyObject * obj3 = 0 ;
22707 PyObject * obj4 = 0 ;
22708 char * kwnames[] = {
22709 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22710 };
22711
22712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22713 if (obj0) {
22714 {
22715 arg1 = wxString_in_helper(obj0);
22716 if (arg1 == NULL) SWIG_fail;
22717 temp1 = true;
22718 }
22719 }
22720 if (obj1) {
22721 {
22722 arg2 = wxString_in_helper(obj1);
22723 if (arg2 == NULL) SWIG_fail;
22724 temp2 = true;
22725 }
22726 }
22727 if (obj2) {
22728 {
22729 arg3 = wxString_in_helper(obj2);
22730 if (arg3 == NULL) SWIG_fail;
22731 temp3 = true;
22732 }
22733 }
22734 if (obj3) {
22735 {
22736 arg4 = wxString_in_helper(obj3);
22737 if (arg4 == NULL) SWIG_fail;
22738 temp4 = true;
22739 }
22740 }
22741 if (obj4) {
22742 ecode5 = SWIG_AsVal_long(obj4, &val5);
22743 if (!SWIG_IsOK(ecode5)) {
22744 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22745 }
22746 arg5 = static_cast< long >(val5);
22747 }
22748 {
22749 PyThreadState* __tstate = wxPyBeginAllowThreads();
22750 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22751 wxPyEndAllowThreads(__tstate);
22752 if (PyErr_Occurred()) SWIG_fail;
22753 }
22754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22755 {
22756 if (temp1)
22757 delete arg1;
22758 }
22759 {
22760 if (temp2)
22761 delete arg2;
22762 }
22763 {
22764 if (temp3)
22765 delete arg3;
22766 }
22767 {
22768 if (temp4)
22769 delete arg4;
22770 }
22771 return resultobj;
22772 fail:
22773 {
22774 if (temp1)
22775 delete arg1;
22776 }
22777 {
22778 if (temp2)
22779 delete arg2;
22780 }
22781 {
22782 if (temp3)
22783 delete arg3;
22784 }
22785 {
22786 if (temp4)
22787 delete arg4;
22788 }
22789 return NULL;
22790 }
22791
22792
22793 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22794 PyObject *resultobj = 0;
22795 wxConfig *arg1 = (wxConfig *) 0 ;
22796 void *argp1 = 0 ;
22797 int res1 = 0 ;
22798 PyObject *swig_obj[1] ;
22799
22800 if (!args) SWIG_fail;
22801 swig_obj[0] = args;
22802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22803 if (!SWIG_IsOK(res1)) {
22804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22805 }
22806 arg1 = reinterpret_cast< wxConfig * >(argp1);
22807 {
22808 PyThreadState* __tstate = wxPyBeginAllowThreads();
22809 delete arg1;
22810
22811 wxPyEndAllowThreads(__tstate);
22812 if (PyErr_Occurred()) SWIG_fail;
22813 }
22814 resultobj = SWIG_Py_Void();
22815 return resultobj;
22816 fail:
22817 return NULL;
22818 }
22819
22820
22821 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22822 PyObject *obj;
22823 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22824 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22825 return SWIG_Py_Void();
22826 }
22827
22828 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22829 return SWIG_Python_InitShadowInstance(args);
22830 }
22831
22832 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22833 PyObject *resultobj = 0;
22834 wxString const &arg1_defvalue = wxPyEmptyString ;
22835 wxString *arg1 = (wxString *) &arg1_defvalue ;
22836 wxString const &arg2_defvalue = wxPyEmptyString ;
22837 wxString *arg2 = (wxString *) &arg2_defvalue ;
22838 wxString const &arg3_defvalue = wxPyEmptyString ;
22839 wxString *arg3 = (wxString *) &arg3_defvalue ;
22840 wxString const &arg4_defvalue = wxPyEmptyString ;
22841 wxString *arg4 = (wxString *) &arg4_defvalue ;
22842 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22843 wxFileConfig *result = 0 ;
22844 bool temp1 = false ;
22845 bool temp2 = false ;
22846 bool temp3 = false ;
22847 bool temp4 = false ;
22848 long val5 ;
22849 int ecode5 = 0 ;
22850 PyObject * obj0 = 0 ;
22851 PyObject * obj1 = 0 ;
22852 PyObject * obj2 = 0 ;
22853 PyObject * obj3 = 0 ;
22854 PyObject * obj4 = 0 ;
22855 char * kwnames[] = {
22856 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22857 };
22858
22859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22860 if (obj0) {
22861 {
22862 arg1 = wxString_in_helper(obj0);
22863 if (arg1 == NULL) SWIG_fail;
22864 temp1 = true;
22865 }
22866 }
22867 if (obj1) {
22868 {
22869 arg2 = wxString_in_helper(obj1);
22870 if (arg2 == NULL) SWIG_fail;
22871 temp2 = true;
22872 }
22873 }
22874 if (obj2) {
22875 {
22876 arg3 = wxString_in_helper(obj2);
22877 if (arg3 == NULL) SWIG_fail;
22878 temp3 = true;
22879 }
22880 }
22881 if (obj3) {
22882 {
22883 arg4 = wxString_in_helper(obj3);
22884 if (arg4 == NULL) SWIG_fail;
22885 temp4 = true;
22886 }
22887 }
22888 if (obj4) {
22889 ecode5 = SWIG_AsVal_long(obj4, &val5);
22890 if (!SWIG_IsOK(ecode5)) {
22891 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22892 }
22893 arg5 = static_cast< long >(val5);
22894 }
22895 {
22896 PyThreadState* __tstate = wxPyBeginAllowThreads();
22897 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22898 wxPyEndAllowThreads(__tstate);
22899 if (PyErr_Occurred()) SWIG_fail;
22900 }
22901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22902 {
22903 if (temp1)
22904 delete arg1;
22905 }
22906 {
22907 if (temp2)
22908 delete arg2;
22909 }
22910 {
22911 if (temp3)
22912 delete arg3;
22913 }
22914 {
22915 if (temp4)
22916 delete arg4;
22917 }
22918 return resultobj;
22919 fail:
22920 {
22921 if (temp1)
22922 delete arg1;
22923 }
22924 {
22925 if (temp2)
22926 delete arg2;
22927 }
22928 {
22929 if (temp3)
22930 delete arg3;
22931 }
22932 {
22933 if (temp4)
22934 delete arg4;
22935 }
22936 return NULL;
22937 }
22938
22939
22940 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22941 PyObject *resultobj = 0;
22942 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22943 void *argp1 = 0 ;
22944 int res1 = 0 ;
22945 PyObject *swig_obj[1] ;
22946
22947 if (!args) SWIG_fail;
22948 swig_obj[0] = args;
22949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22950 if (!SWIG_IsOK(res1)) {
22951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22952 }
22953 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22954 {
22955 PyThreadState* __tstate = wxPyBeginAllowThreads();
22956 delete arg1;
22957
22958 wxPyEndAllowThreads(__tstate);
22959 if (PyErr_Occurred()) SWIG_fail;
22960 }
22961 resultobj = SWIG_Py_Void();
22962 return resultobj;
22963 fail:
22964 return NULL;
22965 }
22966
22967
22968 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22969 PyObject *obj;
22970 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22971 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22972 return SWIG_Py_Void();
22973 }
22974
22975 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22976 return SWIG_Python_InitShadowInstance(args);
22977 }
22978
22979 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22980 PyObject *resultobj = 0;
22981 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22982 wxString *arg2 = 0 ;
22983 wxConfigPathChanger *result = 0 ;
22984 void *argp1 = 0 ;
22985 int res1 = 0 ;
22986 bool temp2 = false ;
22987 PyObject * obj0 = 0 ;
22988 PyObject * obj1 = 0 ;
22989 char * kwnames[] = {
22990 (char *) "config",(char *) "entry", NULL
22991 };
22992
22993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22995 if (!SWIG_IsOK(res1)) {
22996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22997 }
22998 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22999 {
23000 arg2 = wxString_in_helper(obj1);
23001 if (arg2 == NULL) SWIG_fail;
23002 temp2 = true;
23003 }
23004 {
23005 PyThreadState* __tstate = wxPyBeginAllowThreads();
23006 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
23007 wxPyEndAllowThreads(__tstate);
23008 if (PyErr_Occurred()) SWIG_fail;
23009 }
23010 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
23011 {
23012 if (temp2)
23013 delete arg2;
23014 }
23015 return resultobj;
23016 fail:
23017 {
23018 if (temp2)
23019 delete arg2;
23020 }
23021 return NULL;
23022 }
23023
23024
23025 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23026 PyObject *resultobj = 0;
23027 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23028 void *argp1 = 0 ;
23029 int res1 = 0 ;
23030 PyObject *swig_obj[1] ;
23031
23032 if (!args) SWIG_fail;
23033 swig_obj[0] = args;
23034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
23035 if (!SWIG_IsOK(res1)) {
23036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
23037 }
23038 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23039 {
23040 PyThreadState* __tstate = wxPyBeginAllowThreads();
23041 delete arg1;
23042
23043 wxPyEndAllowThreads(__tstate);
23044 if (PyErr_Occurred()) SWIG_fail;
23045 }
23046 resultobj = SWIG_Py_Void();
23047 return resultobj;
23048 fail:
23049 return NULL;
23050 }
23051
23052
23053 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23054 PyObject *resultobj = 0;
23055 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23056 wxString *result = 0 ;
23057 void *argp1 = 0 ;
23058 int res1 = 0 ;
23059 PyObject *swig_obj[1] ;
23060
23061 if (!args) SWIG_fail;
23062 swig_obj[0] = args;
23063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
23064 if (!SWIG_IsOK(res1)) {
23065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
23066 }
23067 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23068 {
23069 PyThreadState* __tstate = wxPyBeginAllowThreads();
23070 {
23071 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
23072 result = (wxString *) &_result_ref;
23073 }
23074 wxPyEndAllowThreads(__tstate);
23075 if (PyErr_Occurred()) SWIG_fail;
23076 }
23077 {
23078 #if wxUSE_UNICODE
23079 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23080 #else
23081 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23082 #endif
23083 }
23084 return resultobj;
23085 fail:
23086 return NULL;
23087 }
23088
23089
23090 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23091 PyObject *obj;
23092 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23093 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
23094 return SWIG_Py_Void();
23095 }
23096
23097 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23098 return SWIG_Python_InitShadowInstance(args);
23099 }
23100
23101 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23102 PyObject *resultobj = 0;
23103 wxString *arg1 = 0 ;
23104 wxString result;
23105 bool temp1 = false ;
23106 PyObject * obj0 = 0 ;
23107 char * kwnames[] = {
23108 (char *) "sz", NULL
23109 };
23110
23111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23112 {
23113 arg1 = wxString_in_helper(obj0);
23114 if (arg1 == NULL) SWIG_fail;
23115 temp1 = true;
23116 }
23117 {
23118 PyThreadState* __tstate = wxPyBeginAllowThreads();
23119 result = wxExpandEnvVars((wxString const &)*arg1);
23120 wxPyEndAllowThreads(__tstate);
23121 if (PyErr_Occurred()) SWIG_fail;
23122 }
23123 {
23124 #if wxUSE_UNICODE
23125 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23126 #else
23127 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23128 #endif
23129 }
23130 {
23131 if (temp1)
23132 delete arg1;
23133 }
23134 return resultobj;
23135 fail:
23136 {
23137 if (temp1)
23138 delete arg1;
23139 }
23140 return NULL;
23141 }
23142
23143
23144 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23145 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23146 return 1;
23147 }
23148
23149
23150 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23151 PyObject *pyobj = 0;
23152
23153 {
23154 #if wxUSE_UNICODE
23155 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23156 #else
23157 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23158 #endif
23159 }
23160 return pyobj;
23161 }
23162
23163
23164 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23165 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23166 return 1;
23167 }
23168
23169
23170 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23171 PyObject *pyobj = 0;
23172
23173 {
23174 #if wxUSE_UNICODE
23175 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23176 #else
23177 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23178 #endif
23179 }
23180 return pyobj;
23181 }
23182
23183
23184 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23185 PyObject *resultobj = 0;
23186 wxDateTime::Country arg1 ;
23187 int val1 ;
23188 int ecode1 = 0 ;
23189 PyObject * obj0 = 0 ;
23190 char * kwnames[] = {
23191 (char *) "country", NULL
23192 };
23193
23194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23195 ecode1 = SWIG_AsVal_int(obj0, &val1);
23196 if (!SWIG_IsOK(ecode1)) {
23197 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23198 }
23199 arg1 = static_cast< wxDateTime::Country >(val1);
23200 {
23201 PyThreadState* __tstate = wxPyBeginAllowThreads();
23202 wxDateTime::SetCountry(arg1);
23203 wxPyEndAllowThreads(__tstate);
23204 if (PyErr_Occurred()) SWIG_fail;
23205 }
23206 resultobj = SWIG_Py_Void();
23207 return resultobj;
23208 fail:
23209 return NULL;
23210 }
23211
23212
23213 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23214 PyObject *resultobj = 0;
23215 wxDateTime::Country result;
23216
23217 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23218 {
23219 PyThreadState* __tstate = wxPyBeginAllowThreads();
23220 result = (wxDateTime::Country)wxDateTime::GetCountry();
23221 wxPyEndAllowThreads(__tstate);
23222 if (PyErr_Occurred()) SWIG_fail;
23223 }
23224 resultobj = SWIG_From_int(static_cast< int >(result));
23225 return resultobj;
23226 fail:
23227 return NULL;
23228 }
23229
23230
23231 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23232 PyObject *resultobj = 0;
23233 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23234 bool result;
23235 int val1 ;
23236 int ecode1 = 0 ;
23237 PyObject * obj0 = 0 ;
23238 char * kwnames[] = {
23239 (char *) "country", NULL
23240 };
23241
23242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23243 if (obj0) {
23244 ecode1 = SWIG_AsVal_int(obj0, &val1);
23245 if (!SWIG_IsOK(ecode1)) {
23246 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23247 }
23248 arg1 = static_cast< wxDateTime::Country >(val1);
23249 }
23250 {
23251 PyThreadState* __tstate = wxPyBeginAllowThreads();
23252 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23253 wxPyEndAllowThreads(__tstate);
23254 if (PyErr_Occurred()) SWIG_fail;
23255 }
23256 {
23257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23258 }
23259 return resultobj;
23260 fail:
23261 return NULL;
23262 }
23263
23264
23265 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23266 PyObject *resultobj = 0;
23267 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23268 int result;
23269 int val1 ;
23270 int ecode1 = 0 ;
23271 PyObject * obj0 = 0 ;
23272 char * kwnames[] = {
23273 (char *) "cal", NULL
23274 };
23275
23276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23277 if (obj0) {
23278 ecode1 = SWIG_AsVal_int(obj0, &val1);
23279 if (!SWIG_IsOK(ecode1)) {
23280 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23281 }
23282 arg1 = static_cast< wxDateTime::Calendar >(val1);
23283 }
23284 {
23285 PyThreadState* __tstate = wxPyBeginAllowThreads();
23286 result = (int)wxDateTime::GetCurrentYear(arg1);
23287 wxPyEndAllowThreads(__tstate);
23288 if (PyErr_Occurred()) SWIG_fail;
23289 }
23290 resultobj = SWIG_From_int(static_cast< int >(result));
23291 return resultobj;
23292 fail:
23293 return NULL;
23294 }
23295
23296
23297 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23298 PyObject *resultobj = 0;
23299 int arg1 ;
23300 int result;
23301 int val1 ;
23302 int ecode1 = 0 ;
23303 PyObject * obj0 = 0 ;
23304 char * kwnames[] = {
23305 (char *) "year", NULL
23306 };
23307
23308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23309 ecode1 = SWIG_AsVal_int(obj0, &val1);
23310 if (!SWIG_IsOK(ecode1)) {
23311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23312 }
23313 arg1 = static_cast< int >(val1);
23314 {
23315 PyThreadState* __tstate = wxPyBeginAllowThreads();
23316 result = (int)wxDateTime::ConvertYearToBC(arg1);
23317 wxPyEndAllowThreads(__tstate);
23318 if (PyErr_Occurred()) SWIG_fail;
23319 }
23320 resultobj = SWIG_From_int(static_cast< int >(result));
23321 return resultobj;
23322 fail:
23323 return NULL;
23324 }
23325
23326
23327 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23328 PyObject *resultobj = 0;
23329 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23330 wxDateTime::Month result;
23331 int val1 ;
23332 int ecode1 = 0 ;
23333 PyObject * obj0 = 0 ;
23334 char * kwnames[] = {
23335 (char *) "cal", NULL
23336 };
23337
23338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23339 if (obj0) {
23340 ecode1 = SWIG_AsVal_int(obj0, &val1);
23341 if (!SWIG_IsOK(ecode1)) {
23342 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23343 }
23344 arg1 = static_cast< wxDateTime::Calendar >(val1);
23345 }
23346 {
23347 PyThreadState* __tstate = wxPyBeginAllowThreads();
23348 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23349 wxPyEndAllowThreads(__tstate);
23350 if (PyErr_Occurred()) SWIG_fail;
23351 }
23352 resultobj = SWIG_From_int(static_cast< int >(result));
23353 return resultobj;
23354 fail:
23355 return NULL;
23356 }
23357
23358
23359 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23360 PyObject *resultobj = 0;
23361 int arg1 = (int) wxDateTime::Inv_Year ;
23362 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23363 bool result;
23364 int val1 ;
23365 int ecode1 = 0 ;
23366 int val2 ;
23367 int ecode2 = 0 ;
23368 PyObject * obj0 = 0 ;
23369 PyObject * obj1 = 0 ;
23370 char * kwnames[] = {
23371 (char *) "year",(char *) "cal", NULL
23372 };
23373
23374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23375 if (obj0) {
23376 ecode1 = SWIG_AsVal_int(obj0, &val1);
23377 if (!SWIG_IsOK(ecode1)) {
23378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23379 }
23380 arg1 = static_cast< int >(val1);
23381 }
23382 if (obj1) {
23383 ecode2 = SWIG_AsVal_int(obj1, &val2);
23384 if (!SWIG_IsOK(ecode2)) {
23385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23386 }
23387 arg2 = static_cast< wxDateTime::Calendar >(val2);
23388 }
23389 {
23390 PyThreadState* __tstate = wxPyBeginAllowThreads();
23391 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23392 wxPyEndAllowThreads(__tstate);
23393 if (PyErr_Occurred()) SWIG_fail;
23394 }
23395 {
23396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23397 }
23398 return resultobj;
23399 fail:
23400 return NULL;
23401 }
23402
23403
23404 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23405 PyObject *resultobj = 0;
23406 int arg1 = (int) wxDateTime::Inv_Year ;
23407 int result;
23408 int val1 ;
23409 int ecode1 = 0 ;
23410 PyObject * obj0 = 0 ;
23411 char * kwnames[] = {
23412 (char *) "year", NULL
23413 };
23414
23415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23416 if (obj0) {
23417 ecode1 = SWIG_AsVal_int(obj0, &val1);
23418 if (!SWIG_IsOK(ecode1)) {
23419 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23420 }
23421 arg1 = static_cast< int >(val1);
23422 }
23423 {
23424 PyThreadState* __tstate = wxPyBeginAllowThreads();
23425 result = (int)wxDateTime::GetCentury(arg1);
23426 wxPyEndAllowThreads(__tstate);
23427 if (PyErr_Occurred()) SWIG_fail;
23428 }
23429 resultobj = SWIG_From_int(static_cast< int >(result));
23430 return resultobj;
23431 fail:
23432 return NULL;
23433 }
23434
23435
23436 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23437 PyObject *resultobj = 0;
23438 int arg1 ;
23439 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23440 int result;
23441 int val1 ;
23442 int ecode1 = 0 ;
23443 int val2 ;
23444 int ecode2 = 0 ;
23445 PyObject * obj0 = 0 ;
23446 PyObject * obj1 = 0 ;
23447 char * kwnames[] = {
23448 (char *) "year",(char *) "cal", NULL
23449 };
23450
23451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23452 ecode1 = SWIG_AsVal_int(obj0, &val1);
23453 if (!SWIG_IsOK(ecode1)) {
23454 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23455 }
23456 arg1 = static_cast< int >(val1);
23457 if (obj1) {
23458 ecode2 = SWIG_AsVal_int(obj1, &val2);
23459 if (!SWIG_IsOK(ecode2)) {
23460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23461 }
23462 arg2 = static_cast< wxDateTime::Calendar >(val2);
23463 }
23464 {
23465 PyThreadState* __tstate = wxPyBeginAllowThreads();
23466 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23467 wxPyEndAllowThreads(__tstate);
23468 if (PyErr_Occurred()) SWIG_fail;
23469 }
23470 resultobj = SWIG_From_int(static_cast< int >(result));
23471 return resultobj;
23472 fail:
23473 return NULL;
23474 }
23475
23476
23477 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23478 PyObject *resultobj = 0;
23479 wxDateTime::Month arg1 ;
23480 int arg2 = (int) wxDateTime::Inv_Year ;
23481 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23482 int result;
23483 int val1 ;
23484 int ecode1 = 0 ;
23485 int val2 ;
23486 int ecode2 = 0 ;
23487 int val3 ;
23488 int ecode3 = 0 ;
23489 PyObject * obj0 = 0 ;
23490 PyObject * obj1 = 0 ;
23491 PyObject * obj2 = 0 ;
23492 char * kwnames[] = {
23493 (char *) "month",(char *) "year",(char *) "cal", NULL
23494 };
23495
23496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23497 ecode1 = SWIG_AsVal_int(obj0, &val1);
23498 if (!SWIG_IsOK(ecode1)) {
23499 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23500 }
23501 arg1 = static_cast< wxDateTime::Month >(val1);
23502 if (obj1) {
23503 ecode2 = SWIG_AsVal_int(obj1, &val2);
23504 if (!SWIG_IsOK(ecode2)) {
23505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23506 }
23507 arg2 = static_cast< int >(val2);
23508 }
23509 if (obj2) {
23510 ecode3 = SWIG_AsVal_int(obj2, &val3);
23511 if (!SWIG_IsOK(ecode3)) {
23512 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23513 }
23514 arg3 = static_cast< wxDateTime::Calendar >(val3);
23515 }
23516 {
23517 PyThreadState* __tstate = wxPyBeginAllowThreads();
23518 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23519 wxPyEndAllowThreads(__tstate);
23520 if (PyErr_Occurred()) SWIG_fail;
23521 }
23522 resultobj = SWIG_From_int(static_cast< int >(result));
23523 return resultobj;
23524 fail:
23525 return NULL;
23526 }
23527
23528
23529 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23530 PyObject *resultobj = 0;
23531 wxDateTime::Month arg1 ;
23532 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23533 wxString result;
23534 int val1 ;
23535 int ecode1 = 0 ;
23536 int val2 ;
23537 int ecode2 = 0 ;
23538 PyObject * obj0 = 0 ;
23539 PyObject * obj1 = 0 ;
23540 char * kwnames[] = {
23541 (char *) "month",(char *) "flags", NULL
23542 };
23543
23544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23545 ecode1 = SWIG_AsVal_int(obj0, &val1);
23546 if (!SWIG_IsOK(ecode1)) {
23547 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23548 }
23549 arg1 = static_cast< wxDateTime::Month >(val1);
23550 if (obj1) {
23551 ecode2 = SWIG_AsVal_int(obj1, &val2);
23552 if (!SWIG_IsOK(ecode2)) {
23553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23554 }
23555 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23556 }
23557 {
23558 PyThreadState* __tstate = wxPyBeginAllowThreads();
23559 result = wxDateTime::GetMonthName(arg1,arg2);
23560 wxPyEndAllowThreads(__tstate);
23561 if (PyErr_Occurred()) SWIG_fail;
23562 }
23563 {
23564 #if wxUSE_UNICODE
23565 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23566 #else
23567 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23568 #endif
23569 }
23570 return resultobj;
23571 fail:
23572 return NULL;
23573 }
23574
23575
23576 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23577 PyObject *resultobj = 0;
23578 wxDateTime::WeekDay arg1 ;
23579 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23580 wxString result;
23581 int val1 ;
23582 int ecode1 = 0 ;
23583 int val2 ;
23584 int ecode2 = 0 ;
23585 PyObject * obj0 = 0 ;
23586 PyObject * obj1 = 0 ;
23587 char * kwnames[] = {
23588 (char *) "weekday",(char *) "flags", NULL
23589 };
23590
23591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23592 ecode1 = SWIG_AsVal_int(obj0, &val1);
23593 if (!SWIG_IsOK(ecode1)) {
23594 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23595 }
23596 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23597 if (obj1) {
23598 ecode2 = SWIG_AsVal_int(obj1, &val2);
23599 if (!SWIG_IsOK(ecode2)) {
23600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23601 }
23602 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23603 }
23604 {
23605 PyThreadState* __tstate = wxPyBeginAllowThreads();
23606 result = wxDateTime::GetWeekDayName(arg1,arg2);
23607 wxPyEndAllowThreads(__tstate);
23608 if (PyErr_Occurred()) SWIG_fail;
23609 }
23610 {
23611 #if wxUSE_UNICODE
23612 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23613 #else
23614 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23615 #endif
23616 }
23617 return resultobj;
23618 fail:
23619 return NULL;
23620 }
23621
23622
23623 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23624 PyObject *resultobj = 0;
23625 PyObject *result = 0 ;
23626
23627 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23628 {
23629 PyThreadState* __tstate = wxPyBeginAllowThreads();
23630 result = (PyObject *)wxDateTime_GetAmPmStrings();
23631 wxPyEndAllowThreads(__tstate);
23632 if (PyErr_Occurred()) SWIG_fail;
23633 }
23634 resultobj = result;
23635 return resultobj;
23636 fail:
23637 return NULL;
23638 }
23639
23640
23641 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23642 PyObject *resultobj = 0;
23643 int arg1 = (int) wxDateTime::Inv_Year ;
23644 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23645 bool result;
23646 int val1 ;
23647 int ecode1 = 0 ;
23648 int val2 ;
23649 int ecode2 = 0 ;
23650 PyObject * obj0 = 0 ;
23651 PyObject * obj1 = 0 ;
23652 char * kwnames[] = {
23653 (char *) "year",(char *) "country", NULL
23654 };
23655
23656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23657 if (obj0) {
23658 ecode1 = SWIG_AsVal_int(obj0, &val1);
23659 if (!SWIG_IsOK(ecode1)) {
23660 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23661 }
23662 arg1 = static_cast< int >(val1);
23663 }
23664 if (obj1) {
23665 ecode2 = SWIG_AsVal_int(obj1, &val2);
23666 if (!SWIG_IsOK(ecode2)) {
23667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23668 }
23669 arg2 = static_cast< wxDateTime::Country >(val2);
23670 }
23671 {
23672 PyThreadState* __tstate = wxPyBeginAllowThreads();
23673 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23674 wxPyEndAllowThreads(__tstate);
23675 if (PyErr_Occurred()) SWIG_fail;
23676 }
23677 {
23678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23679 }
23680 return resultobj;
23681 fail:
23682 return NULL;
23683 }
23684
23685
23686 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23687 PyObject *resultobj = 0;
23688 int arg1 = (int) wxDateTime::Inv_Year ;
23689 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23690 wxDateTime result;
23691 int val1 ;
23692 int ecode1 = 0 ;
23693 int val2 ;
23694 int ecode2 = 0 ;
23695 PyObject * obj0 = 0 ;
23696 PyObject * obj1 = 0 ;
23697 char * kwnames[] = {
23698 (char *) "year",(char *) "country", NULL
23699 };
23700
23701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23702 if (obj0) {
23703 ecode1 = SWIG_AsVal_int(obj0, &val1);
23704 if (!SWIG_IsOK(ecode1)) {
23705 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23706 }
23707 arg1 = static_cast< int >(val1);
23708 }
23709 if (obj1) {
23710 ecode2 = SWIG_AsVal_int(obj1, &val2);
23711 if (!SWIG_IsOK(ecode2)) {
23712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23713 }
23714 arg2 = static_cast< wxDateTime::Country >(val2);
23715 }
23716 {
23717 PyThreadState* __tstate = wxPyBeginAllowThreads();
23718 result = wxDateTime::GetBeginDST(arg1,arg2);
23719 wxPyEndAllowThreads(__tstate);
23720 if (PyErr_Occurred()) SWIG_fail;
23721 }
23722 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23723 return resultobj;
23724 fail:
23725 return NULL;
23726 }
23727
23728
23729 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23730 PyObject *resultobj = 0;
23731 int arg1 = (int) wxDateTime::Inv_Year ;
23732 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23733 wxDateTime result;
23734 int val1 ;
23735 int ecode1 = 0 ;
23736 int val2 ;
23737 int ecode2 = 0 ;
23738 PyObject * obj0 = 0 ;
23739 PyObject * obj1 = 0 ;
23740 char * kwnames[] = {
23741 (char *) "year",(char *) "country", NULL
23742 };
23743
23744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23745 if (obj0) {
23746 ecode1 = SWIG_AsVal_int(obj0, &val1);
23747 if (!SWIG_IsOK(ecode1)) {
23748 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23749 }
23750 arg1 = static_cast< int >(val1);
23751 }
23752 if (obj1) {
23753 ecode2 = SWIG_AsVal_int(obj1, &val2);
23754 if (!SWIG_IsOK(ecode2)) {
23755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23756 }
23757 arg2 = static_cast< wxDateTime::Country >(val2);
23758 }
23759 {
23760 PyThreadState* __tstate = wxPyBeginAllowThreads();
23761 result = wxDateTime::GetEndDST(arg1,arg2);
23762 wxPyEndAllowThreads(__tstate);
23763 if (PyErr_Occurred()) SWIG_fail;
23764 }
23765 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23766 return resultobj;
23767 fail:
23768 return NULL;
23769 }
23770
23771
23772 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23773 PyObject *resultobj = 0;
23774 wxDateTime result;
23775
23776 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23777 {
23778 PyThreadState* __tstate = wxPyBeginAllowThreads();
23779 result = wxDateTime::Now();
23780 wxPyEndAllowThreads(__tstate);
23781 if (PyErr_Occurred()) SWIG_fail;
23782 }
23783 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23784 return resultobj;
23785 fail:
23786 return NULL;
23787 }
23788
23789
23790 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23791 PyObject *resultobj = 0;
23792 wxDateTime result;
23793
23794 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23795 {
23796 PyThreadState* __tstate = wxPyBeginAllowThreads();
23797 result = wxDateTime::UNow();
23798 wxPyEndAllowThreads(__tstate);
23799 if (PyErr_Occurred()) SWIG_fail;
23800 }
23801 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23802 return resultobj;
23803 fail:
23804 return NULL;
23805 }
23806
23807
23808 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23809 PyObject *resultobj = 0;
23810 wxDateTime result;
23811
23812 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23813 {
23814 PyThreadState* __tstate = wxPyBeginAllowThreads();
23815 result = wxDateTime::Today();
23816 wxPyEndAllowThreads(__tstate);
23817 if (PyErr_Occurred()) SWIG_fail;
23818 }
23819 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23820 return resultobj;
23821 fail:
23822 return NULL;
23823 }
23824
23825
23826 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23827 PyObject *resultobj = 0;
23828 wxDateTime *result = 0 ;
23829
23830 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23831 {
23832 PyThreadState* __tstate = wxPyBeginAllowThreads();
23833 result = (wxDateTime *)new wxDateTime();
23834 wxPyEndAllowThreads(__tstate);
23835 if (PyErr_Occurred()) SWIG_fail;
23836 }
23837 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23838 return resultobj;
23839 fail:
23840 return NULL;
23841 }
23842
23843
23844 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23845 PyObject *resultobj = 0;
23846 time_t arg1 ;
23847 wxDateTime *result = 0 ;
23848 unsigned int val1 ;
23849 int ecode1 = 0 ;
23850 PyObject * obj0 = 0 ;
23851 char * kwnames[] = {
23852 (char *) "timet", NULL
23853 };
23854
23855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23856 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23857 if (!SWIG_IsOK(ecode1)) {
23858 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23859 }
23860 arg1 = static_cast< time_t >(val1);
23861 {
23862 PyThreadState* __tstate = wxPyBeginAllowThreads();
23863 result = (wxDateTime *)new wxDateTime(arg1);
23864 wxPyEndAllowThreads(__tstate);
23865 if (PyErr_Occurred()) SWIG_fail;
23866 }
23867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23868 return resultobj;
23869 fail:
23870 return NULL;
23871 }
23872
23873
23874 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23875 PyObject *resultobj = 0;
23876 double arg1 ;
23877 wxDateTime *result = 0 ;
23878 double val1 ;
23879 int ecode1 = 0 ;
23880 PyObject * obj0 = 0 ;
23881 char * kwnames[] = {
23882 (char *) "jdn", NULL
23883 };
23884
23885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23886 ecode1 = SWIG_AsVal_double(obj0, &val1);
23887 if (!SWIG_IsOK(ecode1)) {
23888 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23889 }
23890 arg1 = static_cast< double >(val1);
23891 {
23892 PyThreadState* __tstate = wxPyBeginAllowThreads();
23893 result = (wxDateTime *)new wxDateTime(arg1);
23894 wxPyEndAllowThreads(__tstate);
23895 if (PyErr_Occurred()) SWIG_fail;
23896 }
23897 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23898 return resultobj;
23899 fail:
23900 return NULL;
23901 }
23902
23903
23904 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23905 PyObject *resultobj = 0;
23906 int arg1 ;
23907 int arg2 = (int) 0 ;
23908 int arg3 = (int) 0 ;
23909 int arg4 = (int) 0 ;
23910 wxDateTime *result = 0 ;
23911 int val1 ;
23912 int ecode1 = 0 ;
23913 int val2 ;
23914 int ecode2 = 0 ;
23915 int val3 ;
23916 int ecode3 = 0 ;
23917 int val4 ;
23918 int ecode4 = 0 ;
23919 PyObject * obj0 = 0 ;
23920 PyObject * obj1 = 0 ;
23921 PyObject * obj2 = 0 ;
23922 PyObject * obj3 = 0 ;
23923 char * kwnames[] = {
23924 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23925 };
23926
23927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23928 ecode1 = SWIG_AsVal_int(obj0, &val1);
23929 if (!SWIG_IsOK(ecode1)) {
23930 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23931 }
23932 arg1 = static_cast< int >(val1);
23933 if (obj1) {
23934 ecode2 = SWIG_AsVal_int(obj1, &val2);
23935 if (!SWIG_IsOK(ecode2)) {
23936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23937 }
23938 arg2 = static_cast< int >(val2);
23939 }
23940 if (obj2) {
23941 ecode3 = SWIG_AsVal_int(obj2, &val3);
23942 if (!SWIG_IsOK(ecode3)) {
23943 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23944 }
23945 arg3 = static_cast< int >(val3);
23946 }
23947 if (obj3) {
23948 ecode4 = SWIG_AsVal_int(obj3, &val4);
23949 if (!SWIG_IsOK(ecode4)) {
23950 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23951 }
23952 arg4 = static_cast< int >(val4);
23953 }
23954 {
23955 PyThreadState* __tstate = wxPyBeginAllowThreads();
23956 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23957 wxPyEndAllowThreads(__tstate);
23958 if (PyErr_Occurred()) SWIG_fail;
23959 }
23960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23961 return resultobj;
23962 fail:
23963 return NULL;
23964 }
23965
23966
23967 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23968 PyObject *resultobj = 0;
23969 int arg1 ;
23970 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23971 int arg3 = (int) wxDateTime::Inv_Year ;
23972 int arg4 = (int) 0 ;
23973 int arg5 = (int) 0 ;
23974 int arg6 = (int) 0 ;
23975 int arg7 = (int) 0 ;
23976 wxDateTime *result = 0 ;
23977 int val1 ;
23978 int ecode1 = 0 ;
23979 int val2 ;
23980 int ecode2 = 0 ;
23981 int val3 ;
23982 int ecode3 = 0 ;
23983 int val4 ;
23984 int ecode4 = 0 ;
23985 int val5 ;
23986 int ecode5 = 0 ;
23987 int val6 ;
23988 int ecode6 = 0 ;
23989 int val7 ;
23990 int ecode7 = 0 ;
23991 PyObject * obj0 = 0 ;
23992 PyObject * obj1 = 0 ;
23993 PyObject * obj2 = 0 ;
23994 PyObject * obj3 = 0 ;
23995 PyObject * obj4 = 0 ;
23996 PyObject * obj5 = 0 ;
23997 PyObject * obj6 = 0 ;
23998 char * kwnames[] = {
23999 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24000 };
24001
24002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
24003 ecode1 = SWIG_AsVal_int(obj0, &val1);
24004 if (!SWIG_IsOK(ecode1)) {
24005 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
24006 }
24007 arg1 = static_cast< int >(val1);
24008 if (obj1) {
24009 ecode2 = SWIG_AsVal_int(obj1, &val2);
24010 if (!SWIG_IsOK(ecode2)) {
24011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24012 }
24013 arg2 = static_cast< wxDateTime::Month >(val2);
24014 }
24015 if (obj2) {
24016 ecode3 = SWIG_AsVal_int(obj2, &val3);
24017 if (!SWIG_IsOK(ecode3)) {
24018 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
24019 }
24020 arg3 = static_cast< int >(val3);
24021 }
24022 if (obj3) {
24023 ecode4 = SWIG_AsVal_int(obj3, &val4);
24024 if (!SWIG_IsOK(ecode4)) {
24025 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
24026 }
24027 arg4 = static_cast< int >(val4);
24028 }
24029 if (obj4) {
24030 ecode5 = SWIG_AsVal_int(obj4, &val5);
24031 if (!SWIG_IsOK(ecode5)) {
24032 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
24033 }
24034 arg5 = static_cast< int >(val5);
24035 }
24036 if (obj5) {
24037 ecode6 = SWIG_AsVal_int(obj5, &val6);
24038 if (!SWIG_IsOK(ecode6)) {
24039 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
24040 }
24041 arg6 = static_cast< int >(val6);
24042 }
24043 if (obj6) {
24044 ecode7 = SWIG_AsVal_int(obj6, &val7);
24045 if (!SWIG_IsOK(ecode7)) {
24046 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
24047 }
24048 arg7 = static_cast< int >(val7);
24049 }
24050 {
24051 PyThreadState* __tstate = wxPyBeginAllowThreads();
24052 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24053 wxPyEndAllowThreads(__tstate);
24054 if (PyErr_Occurred()) SWIG_fail;
24055 }
24056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24057 return resultobj;
24058 fail:
24059 return NULL;
24060 }
24061
24062
24063 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24064 PyObject *resultobj = 0;
24065 wxDateTime *arg1 = 0 ;
24066 wxDateTime *result = 0 ;
24067 void *argp1 = 0 ;
24068 int res1 = 0 ;
24069 PyObject * obj0 = 0 ;
24070 char * kwnames[] = {
24071 (char *) "date", NULL
24072 };
24073
24074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
24075 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
24076 if (!SWIG_IsOK(res1)) {
24077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24078 }
24079 if (!argp1) {
24080 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24081 }
24082 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24083 {
24084 PyThreadState* __tstate = wxPyBeginAllowThreads();
24085 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
24086 wxPyEndAllowThreads(__tstate);
24087 if (PyErr_Occurred()) SWIG_fail;
24088 }
24089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24090 return resultobj;
24091 fail:
24092 return NULL;
24093 }
24094
24095
24096 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24097 PyObject *resultobj = 0;
24098 wxDateTime *arg1 = (wxDateTime *) 0 ;
24099 void *argp1 = 0 ;
24100 int res1 = 0 ;
24101 PyObject *swig_obj[1] ;
24102
24103 if (!args) SWIG_fail;
24104 swig_obj[0] = args;
24105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24106 if (!SWIG_IsOK(res1)) {
24107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24108 }
24109 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24110 {
24111 PyThreadState* __tstate = wxPyBeginAllowThreads();
24112 delete arg1;
24113
24114 wxPyEndAllowThreads(__tstate);
24115 if (PyErr_Occurred()) SWIG_fail;
24116 }
24117 resultobj = SWIG_Py_Void();
24118 return resultobj;
24119 fail:
24120 return NULL;
24121 }
24122
24123
24124 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24125 PyObject *resultobj = 0;
24126 wxDateTime *arg1 = (wxDateTime *) 0 ;
24127 wxDateTime *result = 0 ;
24128 void *argp1 = 0 ;
24129 int res1 = 0 ;
24130 PyObject *swig_obj[1] ;
24131
24132 if (!args) SWIG_fail;
24133 swig_obj[0] = args;
24134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24135 if (!SWIG_IsOK(res1)) {
24136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24137 }
24138 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24139 {
24140 PyThreadState* __tstate = wxPyBeginAllowThreads();
24141 {
24142 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24143 result = (wxDateTime *) &_result_ref;
24144 }
24145 wxPyEndAllowThreads(__tstate);
24146 if (PyErr_Occurred()) SWIG_fail;
24147 }
24148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24149 return resultobj;
24150 fail:
24151 return NULL;
24152 }
24153
24154
24155 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24156 PyObject *resultobj = 0;
24157 wxDateTime *arg1 = (wxDateTime *) 0 ;
24158 time_t arg2 ;
24159 wxDateTime *result = 0 ;
24160 void *argp1 = 0 ;
24161 int res1 = 0 ;
24162 unsigned int val2 ;
24163 int ecode2 = 0 ;
24164 PyObject * obj0 = 0 ;
24165 PyObject * obj1 = 0 ;
24166 char * kwnames[] = {
24167 (char *) "self",(char *) "timet", NULL
24168 };
24169
24170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24172 if (!SWIG_IsOK(res1)) {
24173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24174 }
24175 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24176 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24177 if (!SWIG_IsOK(ecode2)) {
24178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24179 }
24180 arg2 = static_cast< time_t >(val2);
24181 {
24182 PyThreadState* __tstate = wxPyBeginAllowThreads();
24183 {
24184 wxDateTime &_result_ref = (arg1)->Set(arg2);
24185 result = (wxDateTime *) &_result_ref;
24186 }
24187 wxPyEndAllowThreads(__tstate);
24188 if (PyErr_Occurred()) SWIG_fail;
24189 }
24190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24191 return resultobj;
24192 fail:
24193 return NULL;
24194 }
24195
24196
24197 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24198 PyObject *resultobj = 0;
24199 wxDateTime *arg1 = (wxDateTime *) 0 ;
24200 double arg2 ;
24201 wxDateTime *result = 0 ;
24202 void *argp1 = 0 ;
24203 int res1 = 0 ;
24204 double val2 ;
24205 int ecode2 = 0 ;
24206 PyObject * obj0 = 0 ;
24207 PyObject * obj1 = 0 ;
24208 char * kwnames[] = {
24209 (char *) "self",(char *) "jdn", NULL
24210 };
24211
24212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24214 if (!SWIG_IsOK(res1)) {
24215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24216 }
24217 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24218 ecode2 = SWIG_AsVal_double(obj1, &val2);
24219 if (!SWIG_IsOK(ecode2)) {
24220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24221 }
24222 arg2 = static_cast< double >(val2);
24223 {
24224 PyThreadState* __tstate = wxPyBeginAllowThreads();
24225 {
24226 wxDateTime &_result_ref = (arg1)->Set(arg2);
24227 result = (wxDateTime *) &_result_ref;
24228 }
24229 wxPyEndAllowThreads(__tstate);
24230 if (PyErr_Occurred()) SWIG_fail;
24231 }
24232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24233 return resultobj;
24234 fail:
24235 return NULL;
24236 }
24237
24238
24239 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24240 PyObject *resultobj = 0;
24241 wxDateTime *arg1 = (wxDateTime *) 0 ;
24242 int arg2 ;
24243 int arg3 = (int) 0 ;
24244 int arg4 = (int) 0 ;
24245 int arg5 = (int) 0 ;
24246 wxDateTime *result = 0 ;
24247 void *argp1 = 0 ;
24248 int res1 = 0 ;
24249 int val2 ;
24250 int ecode2 = 0 ;
24251 int val3 ;
24252 int ecode3 = 0 ;
24253 int val4 ;
24254 int ecode4 = 0 ;
24255 int val5 ;
24256 int ecode5 = 0 ;
24257 PyObject * obj0 = 0 ;
24258 PyObject * obj1 = 0 ;
24259 PyObject * obj2 = 0 ;
24260 PyObject * obj3 = 0 ;
24261 PyObject * obj4 = 0 ;
24262 char * kwnames[] = {
24263 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24264 };
24265
24266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24268 if (!SWIG_IsOK(res1)) {
24269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24270 }
24271 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24272 ecode2 = SWIG_AsVal_int(obj1, &val2);
24273 if (!SWIG_IsOK(ecode2)) {
24274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24275 }
24276 arg2 = static_cast< int >(val2);
24277 if (obj2) {
24278 ecode3 = SWIG_AsVal_int(obj2, &val3);
24279 if (!SWIG_IsOK(ecode3)) {
24280 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24281 }
24282 arg3 = static_cast< int >(val3);
24283 }
24284 if (obj3) {
24285 ecode4 = SWIG_AsVal_int(obj3, &val4);
24286 if (!SWIG_IsOK(ecode4)) {
24287 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24288 }
24289 arg4 = static_cast< int >(val4);
24290 }
24291 if (obj4) {
24292 ecode5 = SWIG_AsVal_int(obj4, &val5);
24293 if (!SWIG_IsOK(ecode5)) {
24294 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24295 }
24296 arg5 = static_cast< int >(val5);
24297 }
24298 {
24299 PyThreadState* __tstate = wxPyBeginAllowThreads();
24300 {
24301 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24302 result = (wxDateTime *) &_result_ref;
24303 }
24304 wxPyEndAllowThreads(__tstate);
24305 if (PyErr_Occurred()) SWIG_fail;
24306 }
24307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24308 return resultobj;
24309 fail:
24310 return NULL;
24311 }
24312
24313
24314 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24315 PyObject *resultobj = 0;
24316 wxDateTime *arg1 = (wxDateTime *) 0 ;
24317 int arg2 ;
24318 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24319 int arg4 = (int) wxDateTime::Inv_Year ;
24320 int arg5 = (int) 0 ;
24321 int arg6 = (int) 0 ;
24322 int arg7 = (int) 0 ;
24323 int arg8 = (int) 0 ;
24324 wxDateTime *result = 0 ;
24325 void *argp1 = 0 ;
24326 int res1 = 0 ;
24327 int val2 ;
24328 int ecode2 = 0 ;
24329 int val3 ;
24330 int ecode3 = 0 ;
24331 int val4 ;
24332 int ecode4 = 0 ;
24333 int val5 ;
24334 int ecode5 = 0 ;
24335 int val6 ;
24336 int ecode6 = 0 ;
24337 int val7 ;
24338 int ecode7 = 0 ;
24339 int val8 ;
24340 int ecode8 = 0 ;
24341 PyObject * obj0 = 0 ;
24342 PyObject * obj1 = 0 ;
24343 PyObject * obj2 = 0 ;
24344 PyObject * obj3 = 0 ;
24345 PyObject * obj4 = 0 ;
24346 PyObject * obj5 = 0 ;
24347 PyObject * obj6 = 0 ;
24348 PyObject * obj7 = 0 ;
24349 char * kwnames[] = {
24350 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24351 };
24352
24353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24355 if (!SWIG_IsOK(res1)) {
24356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24357 }
24358 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24359 ecode2 = SWIG_AsVal_int(obj1, &val2);
24360 if (!SWIG_IsOK(ecode2)) {
24361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24362 }
24363 arg2 = static_cast< int >(val2);
24364 if (obj2) {
24365 ecode3 = SWIG_AsVal_int(obj2, &val3);
24366 if (!SWIG_IsOK(ecode3)) {
24367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24368 }
24369 arg3 = static_cast< wxDateTime::Month >(val3);
24370 }
24371 if (obj3) {
24372 ecode4 = SWIG_AsVal_int(obj3, &val4);
24373 if (!SWIG_IsOK(ecode4)) {
24374 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24375 }
24376 arg4 = static_cast< int >(val4);
24377 }
24378 if (obj4) {
24379 ecode5 = SWIG_AsVal_int(obj4, &val5);
24380 if (!SWIG_IsOK(ecode5)) {
24381 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24382 }
24383 arg5 = static_cast< int >(val5);
24384 }
24385 if (obj5) {
24386 ecode6 = SWIG_AsVal_int(obj5, &val6);
24387 if (!SWIG_IsOK(ecode6)) {
24388 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24389 }
24390 arg6 = static_cast< int >(val6);
24391 }
24392 if (obj6) {
24393 ecode7 = SWIG_AsVal_int(obj6, &val7);
24394 if (!SWIG_IsOK(ecode7)) {
24395 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24396 }
24397 arg7 = static_cast< int >(val7);
24398 }
24399 if (obj7) {
24400 ecode8 = SWIG_AsVal_int(obj7, &val8);
24401 if (!SWIG_IsOK(ecode8)) {
24402 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24403 }
24404 arg8 = static_cast< int >(val8);
24405 }
24406 {
24407 PyThreadState* __tstate = wxPyBeginAllowThreads();
24408 {
24409 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24410 result = (wxDateTime *) &_result_ref;
24411 }
24412 wxPyEndAllowThreads(__tstate);
24413 if (PyErr_Occurred()) SWIG_fail;
24414 }
24415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24416 return resultobj;
24417 fail:
24418 return NULL;
24419 }
24420
24421
24422 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24423 PyObject *resultobj = 0;
24424 wxDateTime *arg1 = (wxDateTime *) 0 ;
24425 wxDateTime *result = 0 ;
24426 void *argp1 = 0 ;
24427 int res1 = 0 ;
24428 PyObject *swig_obj[1] ;
24429
24430 if (!args) SWIG_fail;
24431 swig_obj[0] = args;
24432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24433 if (!SWIG_IsOK(res1)) {
24434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24435 }
24436 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24437 {
24438 PyThreadState* __tstate = wxPyBeginAllowThreads();
24439 {
24440 wxDateTime &_result_ref = (arg1)->ResetTime();
24441 result = (wxDateTime *) &_result_ref;
24442 }
24443 wxPyEndAllowThreads(__tstate);
24444 if (PyErr_Occurred()) SWIG_fail;
24445 }
24446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24447 return resultobj;
24448 fail:
24449 return NULL;
24450 }
24451
24452
24453 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24454 PyObject *resultobj = 0;
24455 wxDateTime *arg1 = (wxDateTime *) 0 ;
24456 int arg2 ;
24457 wxDateTime *result = 0 ;
24458 void *argp1 = 0 ;
24459 int res1 = 0 ;
24460 int val2 ;
24461 int ecode2 = 0 ;
24462 PyObject * obj0 = 0 ;
24463 PyObject * obj1 = 0 ;
24464 char * kwnames[] = {
24465 (char *) "self",(char *) "year", NULL
24466 };
24467
24468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24470 if (!SWIG_IsOK(res1)) {
24471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24472 }
24473 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24474 ecode2 = SWIG_AsVal_int(obj1, &val2);
24475 if (!SWIG_IsOK(ecode2)) {
24476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24477 }
24478 arg2 = static_cast< int >(val2);
24479 {
24480 PyThreadState* __tstate = wxPyBeginAllowThreads();
24481 {
24482 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24483 result = (wxDateTime *) &_result_ref;
24484 }
24485 wxPyEndAllowThreads(__tstate);
24486 if (PyErr_Occurred()) SWIG_fail;
24487 }
24488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24489 return resultobj;
24490 fail:
24491 return NULL;
24492 }
24493
24494
24495 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24496 PyObject *resultobj = 0;
24497 wxDateTime *arg1 = (wxDateTime *) 0 ;
24498 wxDateTime::Month arg2 ;
24499 wxDateTime *result = 0 ;
24500 void *argp1 = 0 ;
24501 int res1 = 0 ;
24502 int val2 ;
24503 int ecode2 = 0 ;
24504 PyObject * obj0 = 0 ;
24505 PyObject * obj1 = 0 ;
24506 char * kwnames[] = {
24507 (char *) "self",(char *) "month", NULL
24508 };
24509
24510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24512 if (!SWIG_IsOK(res1)) {
24513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24514 }
24515 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24516 ecode2 = SWIG_AsVal_int(obj1, &val2);
24517 if (!SWIG_IsOK(ecode2)) {
24518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24519 }
24520 arg2 = static_cast< wxDateTime::Month >(val2);
24521 {
24522 PyThreadState* __tstate = wxPyBeginAllowThreads();
24523 {
24524 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24525 result = (wxDateTime *) &_result_ref;
24526 }
24527 wxPyEndAllowThreads(__tstate);
24528 if (PyErr_Occurred()) SWIG_fail;
24529 }
24530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24531 return resultobj;
24532 fail:
24533 return NULL;
24534 }
24535
24536
24537 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24538 PyObject *resultobj = 0;
24539 wxDateTime *arg1 = (wxDateTime *) 0 ;
24540 int arg2 ;
24541 wxDateTime *result = 0 ;
24542 void *argp1 = 0 ;
24543 int res1 = 0 ;
24544 int val2 ;
24545 int ecode2 = 0 ;
24546 PyObject * obj0 = 0 ;
24547 PyObject * obj1 = 0 ;
24548 char * kwnames[] = {
24549 (char *) "self",(char *) "day", NULL
24550 };
24551
24552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24554 if (!SWIG_IsOK(res1)) {
24555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24556 }
24557 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24558 ecode2 = SWIG_AsVal_int(obj1, &val2);
24559 if (!SWIG_IsOK(ecode2)) {
24560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24561 }
24562 arg2 = static_cast< int >(val2);
24563 {
24564 PyThreadState* __tstate = wxPyBeginAllowThreads();
24565 {
24566 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24567 result = (wxDateTime *) &_result_ref;
24568 }
24569 wxPyEndAllowThreads(__tstate);
24570 if (PyErr_Occurred()) SWIG_fail;
24571 }
24572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24573 return resultobj;
24574 fail:
24575 return NULL;
24576 }
24577
24578
24579 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24580 PyObject *resultobj = 0;
24581 wxDateTime *arg1 = (wxDateTime *) 0 ;
24582 int arg2 ;
24583 wxDateTime *result = 0 ;
24584 void *argp1 = 0 ;
24585 int res1 = 0 ;
24586 int val2 ;
24587 int ecode2 = 0 ;
24588 PyObject * obj0 = 0 ;
24589 PyObject * obj1 = 0 ;
24590 char * kwnames[] = {
24591 (char *) "self",(char *) "hour", NULL
24592 };
24593
24594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24596 if (!SWIG_IsOK(res1)) {
24597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24598 }
24599 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24600 ecode2 = SWIG_AsVal_int(obj1, &val2);
24601 if (!SWIG_IsOK(ecode2)) {
24602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24603 }
24604 arg2 = static_cast< int >(val2);
24605 {
24606 PyThreadState* __tstate = wxPyBeginAllowThreads();
24607 {
24608 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24609 result = (wxDateTime *) &_result_ref;
24610 }
24611 wxPyEndAllowThreads(__tstate);
24612 if (PyErr_Occurred()) SWIG_fail;
24613 }
24614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24615 return resultobj;
24616 fail:
24617 return NULL;
24618 }
24619
24620
24621 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24622 PyObject *resultobj = 0;
24623 wxDateTime *arg1 = (wxDateTime *) 0 ;
24624 int arg2 ;
24625 wxDateTime *result = 0 ;
24626 void *argp1 = 0 ;
24627 int res1 = 0 ;
24628 int val2 ;
24629 int ecode2 = 0 ;
24630 PyObject * obj0 = 0 ;
24631 PyObject * obj1 = 0 ;
24632 char * kwnames[] = {
24633 (char *) "self",(char *) "minute", NULL
24634 };
24635
24636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24638 if (!SWIG_IsOK(res1)) {
24639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24640 }
24641 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24642 ecode2 = SWIG_AsVal_int(obj1, &val2);
24643 if (!SWIG_IsOK(ecode2)) {
24644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24645 }
24646 arg2 = static_cast< int >(val2);
24647 {
24648 PyThreadState* __tstate = wxPyBeginAllowThreads();
24649 {
24650 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24651 result = (wxDateTime *) &_result_ref;
24652 }
24653 wxPyEndAllowThreads(__tstate);
24654 if (PyErr_Occurred()) SWIG_fail;
24655 }
24656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24657 return resultobj;
24658 fail:
24659 return NULL;
24660 }
24661
24662
24663 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24664 PyObject *resultobj = 0;
24665 wxDateTime *arg1 = (wxDateTime *) 0 ;
24666 int arg2 ;
24667 wxDateTime *result = 0 ;
24668 void *argp1 = 0 ;
24669 int res1 = 0 ;
24670 int val2 ;
24671 int ecode2 = 0 ;
24672 PyObject * obj0 = 0 ;
24673 PyObject * obj1 = 0 ;
24674 char * kwnames[] = {
24675 (char *) "self",(char *) "second", NULL
24676 };
24677
24678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24680 if (!SWIG_IsOK(res1)) {
24681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24682 }
24683 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24684 ecode2 = SWIG_AsVal_int(obj1, &val2);
24685 if (!SWIG_IsOK(ecode2)) {
24686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24687 }
24688 arg2 = static_cast< int >(val2);
24689 {
24690 PyThreadState* __tstate = wxPyBeginAllowThreads();
24691 {
24692 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24693 result = (wxDateTime *) &_result_ref;
24694 }
24695 wxPyEndAllowThreads(__tstate);
24696 if (PyErr_Occurred()) SWIG_fail;
24697 }
24698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24699 return resultobj;
24700 fail:
24701 return NULL;
24702 }
24703
24704
24705 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24706 PyObject *resultobj = 0;
24707 wxDateTime *arg1 = (wxDateTime *) 0 ;
24708 int arg2 ;
24709 wxDateTime *result = 0 ;
24710 void *argp1 = 0 ;
24711 int res1 = 0 ;
24712 int val2 ;
24713 int ecode2 = 0 ;
24714 PyObject * obj0 = 0 ;
24715 PyObject * obj1 = 0 ;
24716 char * kwnames[] = {
24717 (char *) "self",(char *) "millisecond", NULL
24718 };
24719
24720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24722 if (!SWIG_IsOK(res1)) {
24723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24724 }
24725 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24726 ecode2 = SWIG_AsVal_int(obj1, &val2);
24727 if (!SWIG_IsOK(ecode2)) {
24728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24729 }
24730 arg2 = static_cast< int >(val2);
24731 {
24732 PyThreadState* __tstate = wxPyBeginAllowThreads();
24733 {
24734 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24735 result = (wxDateTime *) &_result_ref;
24736 }
24737 wxPyEndAllowThreads(__tstate);
24738 if (PyErr_Occurred()) SWIG_fail;
24739 }
24740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24741 return resultobj;
24742 fail:
24743 return NULL;
24744 }
24745
24746
24747 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24748 PyObject *resultobj = 0;
24749 wxDateTime *arg1 = (wxDateTime *) 0 ;
24750 wxDateTime::WeekDay arg2 ;
24751 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24752 wxDateTime *result = 0 ;
24753 void *argp1 = 0 ;
24754 int res1 = 0 ;
24755 int val2 ;
24756 int ecode2 = 0 ;
24757 int val3 ;
24758 int ecode3 = 0 ;
24759 PyObject * obj0 = 0 ;
24760 PyObject * obj1 = 0 ;
24761 PyObject * obj2 = 0 ;
24762 char * kwnames[] = {
24763 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24764 };
24765
24766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24768 if (!SWIG_IsOK(res1)) {
24769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24770 }
24771 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24772 ecode2 = SWIG_AsVal_int(obj1, &val2);
24773 if (!SWIG_IsOK(ecode2)) {
24774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24775 }
24776 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24777 if (obj2) {
24778 ecode3 = SWIG_AsVal_int(obj2, &val3);
24779 if (!SWIG_IsOK(ecode3)) {
24780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24781 }
24782 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24783 }
24784 {
24785 PyThreadState* __tstate = wxPyBeginAllowThreads();
24786 {
24787 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24788 result = (wxDateTime *) &_result_ref;
24789 }
24790 wxPyEndAllowThreads(__tstate);
24791 if (PyErr_Occurred()) SWIG_fail;
24792 }
24793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24794 return resultobj;
24795 fail:
24796 return NULL;
24797 }
24798
24799
24800 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24801 PyObject *resultobj = 0;
24802 wxDateTime *arg1 = (wxDateTime *) 0 ;
24803 wxDateTime::WeekDay arg2 ;
24804 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24805 wxDateTime result;
24806 void *argp1 = 0 ;
24807 int res1 = 0 ;
24808 int val2 ;
24809 int ecode2 = 0 ;
24810 int val3 ;
24811 int ecode3 = 0 ;
24812 PyObject * obj0 = 0 ;
24813 PyObject * obj1 = 0 ;
24814 PyObject * obj2 = 0 ;
24815 char * kwnames[] = {
24816 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24817 };
24818
24819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24821 if (!SWIG_IsOK(res1)) {
24822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24823 }
24824 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24825 ecode2 = SWIG_AsVal_int(obj1, &val2);
24826 if (!SWIG_IsOK(ecode2)) {
24827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24828 }
24829 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24830 if (obj2) {
24831 ecode3 = SWIG_AsVal_int(obj2, &val3);
24832 if (!SWIG_IsOK(ecode3)) {
24833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24834 }
24835 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24836 }
24837 {
24838 PyThreadState* __tstate = wxPyBeginAllowThreads();
24839 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24840 wxPyEndAllowThreads(__tstate);
24841 if (PyErr_Occurred()) SWIG_fail;
24842 }
24843 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24844 return resultobj;
24845 fail:
24846 return NULL;
24847 }
24848
24849
24850 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24851 PyObject *resultobj = 0;
24852 wxDateTime *arg1 = (wxDateTime *) 0 ;
24853 wxDateTime::WeekDay arg2 ;
24854 wxDateTime *result = 0 ;
24855 void *argp1 = 0 ;
24856 int res1 = 0 ;
24857 int val2 ;
24858 int ecode2 = 0 ;
24859 PyObject * obj0 = 0 ;
24860 PyObject * obj1 = 0 ;
24861 char * kwnames[] = {
24862 (char *) "self",(char *) "weekday", NULL
24863 };
24864
24865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24867 if (!SWIG_IsOK(res1)) {
24868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24869 }
24870 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24871 ecode2 = SWIG_AsVal_int(obj1, &val2);
24872 if (!SWIG_IsOK(ecode2)) {
24873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24874 }
24875 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24876 {
24877 PyThreadState* __tstate = wxPyBeginAllowThreads();
24878 {
24879 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24880 result = (wxDateTime *) &_result_ref;
24881 }
24882 wxPyEndAllowThreads(__tstate);
24883 if (PyErr_Occurred()) SWIG_fail;
24884 }
24885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24886 return resultobj;
24887 fail:
24888 return NULL;
24889 }
24890
24891
24892 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24893 PyObject *resultobj = 0;
24894 wxDateTime *arg1 = (wxDateTime *) 0 ;
24895 wxDateTime::WeekDay arg2 ;
24896 wxDateTime result;
24897 void *argp1 = 0 ;
24898 int res1 = 0 ;
24899 int val2 ;
24900 int ecode2 = 0 ;
24901 PyObject * obj0 = 0 ;
24902 PyObject * obj1 = 0 ;
24903 char * kwnames[] = {
24904 (char *) "self",(char *) "weekday", NULL
24905 };
24906
24907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24909 if (!SWIG_IsOK(res1)) {
24910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24911 }
24912 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24913 ecode2 = SWIG_AsVal_int(obj1, &val2);
24914 if (!SWIG_IsOK(ecode2)) {
24915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24916 }
24917 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24918 {
24919 PyThreadState* __tstate = wxPyBeginAllowThreads();
24920 result = (arg1)->GetNextWeekDay(arg2);
24921 wxPyEndAllowThreads(__tstate);
24922 if (PyErr_Occurred()) SWIG_fail;
24923 }
24924 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24925 return resultobj;
24926 fail:
24927 return NULL;
24928 }
24929
24930
24931 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24932 PyObject *resultobj = 0;
24933 wxDateTime *arg1 = (wxDateTime *) 0 ;
24934 wxDateTime::WeekDay arg2 ;
24935 wxDateTime *result = 0 ;
24936 void *argp1 = 0 ;
24937 int res1 = 0 ;
24938 int val2 ;
24939 int ecode2 = 0 ;
24940 PyObject * obj0 = 0 ;
24941 PyObject * obj1 = 0 ;
24942 char * kwnames[] = {
24943 (char *) "self",(char *) "weekday", NULL
24944 };
24945
24946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24948 if (!SWIG_IsOK(res1)) {
24949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24950 }
24951 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24952 ecode2 = SWIG_AsVal_int(obj1, &val2);
24953 if (!SWIG_IsOK(ecode2)) {
24954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24955 }
24956 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24957 {
24958 PyThreadState* __tstate = wxPyBeginAllowThreads();
24959 {
24960 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24961 result = (wxDateTime *) &_result_ref;
24962 }
24963 wxPyEndAllowThreads(__tstate);
24964 if (PyErr_Occurred()) SWIG_fail;
24965 }
24966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24967 return resultobj;
24968 fail:
24969 return NULL;
24970 }
24971
24972
24973 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24974 PyObject *resultobj = 0;
24975 wxDateTime *arg1 = (wxDateTime *) 0 ;
24976 wxDateTime::WeekDay arg2 ;
24977 wxDateTime result;
24978 void *argp1 = 0 ;
24979 int res1 = 0 ;
24980 int val2 ;
24981 int ecode2 = 0 ;
24982 PyObject * obj0 = 0 ;
24983 PyObject * obj1 = 0 ;
24984 char * kwnames[] = {
24985 (char *) "self",(char *) "weekday", NULL
24986 };
24987
24988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24990 if (!SWIG_IsOK(res1)) {
24991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24992 }
24993 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24994 ecode2 = SWIG_AsVal_int(obj1, &val2);
24995 if (!SWIG_IsOK(ecode2)) {
24996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24997 }
24998 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24999 {
25000 PyThreadState* __tstate = wxPyBeginAllowThreads();
25001 result = (arg1)->GetPrevWeekDay(arg2);
25002 wxPyEndAllowThreads(__tstate);
25003 if (PyErr_Occurred()) SWIG_fail;
25004 }
25005 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25006 return resultobj;
25007 fail:
25008 return NULL;
25009 }
25010
25011
25012 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25013 PyObject *resultobj = 0;
25014 wxDateTime *arg1 = (wxDateTime *) 0 ;
25015 wxDateTime::WeekDay arg2 ;
25016 int arg3 = (int) 1 ;
25017 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25018 int arg5 = (int) wxDateTime::Inv_Year ;
25019 bool result;
25020 void *argp1 = 0 ;
25021 int res1 = 0 ;
25022 int val2 ;
25023 int ecode2 = 0 ;
25024 int val3 ;
25025 int ecode3 = 0 ;
25026 int val4 ;
25027 int ecode4 = 0 ;
25028 int val5 ;
25029 int ecode5 = 0 ;
25030 PyObject * obj0 = 0 ;
25031 PyObject * obj1 = 0 ;
25032 PyObject * obj2 = 0 ;
25033 PyObject * obj3 = 0 ;
25034 PyObject * obj4 = 0 ;
25035 char * kwnames[] = {
25036 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
25037 };
25038
25039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25041 if (!SWIG_IsOK(res1)) {
25042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25043 }
25044 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25045 ecode2 = SWIG_AsVal_int(obj1, &val2);
25046 if (!SWIG_IsOK(ecode2)) {
25047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25048 }
25049 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25050 if (obj2) {
25051 ecode3 = SWIG_AsVal_int(obj2, &val3);
25052 if (!SWIG_IsOK(ecode3)) {
25053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
25054 }
25055 arg3 = static_cast< int >(val3);
25056 }
25057 if (obj3) {
25058 ecode4 = SWIG_AsVal_int(obj3, &val4);
25059 if (!SWIG_IsOK(ecode4)) {
25060 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
25061 }
25062 arg4 = static_cast< wxDateTime::Month >(val4);
25063 }
25064 if (obj4) {
25065 ecode5 = SWIG_AsVal_int(obj4, &val5);
25066 if (!SWIG_IsOK(ecode5)) {
25067 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
25068 }
25069 arg5 = static_cast< int >(val5);
25070 }
25071 {
25072 PyThreadState* __tstate = wxPyBeginAllowThreads();
25073 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
25074 wxPyEndAllowThreads(__tstate);
25075 if (PyErr_Occurred()) SWIG_fail;
25076 }
25077 {
25078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25079 }
25080 return resultobj;
25081 fail:
25082 return NULL;
25083 }
25084
25085
25086 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25087 PyObject *resultobj = 0;
25088 wxDateTime *arg1 = (wxDateTime *) 0 ;
25089 wxDateTime::WeekDay arg2 ;
25090 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25091 int arg4 = (int) wxDateTime::Inv_Year ;
25092 bool result;
25093 void *argp1 = 0 ;
25094 int res1 = 0 ;
25095 int val2 ;
25096 int ecode2 = 0 ;
25097 int val3 ;
25098 int ecode3 = 0 ;
25099 int val4 ;
25100 int ecode4 = 0 ;
25101 PyObject * obj0 = 0 ;
25102 PyObject * obj1 = 0 ;
25103 PyObject * obj2 = 0 ;
25104 PyObject * obj3 = 0 ;
25105 char * kwnames[] = {
25106 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25107 };
25108
25109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25111 if (!SWIG_IsOK(res1)) {
25112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25113 }
25114 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25115 ecode2 = SWIG_AsVal_int(obj1, &val2);
25116 if (!SWIG_IsOK(ecode2)) {
25117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25118 }
25119 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25120 if (obj2) {
25121 ecode3 = SWIG_AsVal_int(obj2, &val3);
25122 if (!SWIG_IsOK(ecode3)) {
25123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25124 }
25125 arg3 = static_cast< wxDateTime::Month >(val3);
25126 }
25127 if (obj3) {
25128 ecode4 = SWIG_AsVal_int(obj3, &val4);
25129 if (!SWIG_IsOK(ecode4)) {
25130 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25131 }
25132 arg4 = static_cast< int >(val4);
25133 }
25134 {
25135 PyThreadState* __tstate = wxPyBeginAllowThreads();
25136 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25137 wxPyEndAllowThreads(__tstate);
25138 if (PyErr_Occurred()) SWIG_fail;
25139 }
25140 {
25141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25142 }
25143 return resultobj;
25144 fail:
25145 return NULL;
25146 }
25147
25148
25149 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25150 PyObject *resultobj = 0;
25151 wxDateTime *arg1 = (wxDateTime *) 0 ;
25152 wxDateTime::WeekDay arg2 ;
25153 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25154 int arg4 = (int) wxDateTime::Inv_Year ;
25155 wxDateTime result;
25156 void *argp1 = 0 ;
25157 int res1 = 0 ;
25158 int val2 ;
25159 int ecode2 = 0 ;
25160 int val3 ;
25161 int ecode3 = 0 ;
25162 int val4 ;
25163 int ecode4 = 0 ;
25164 PyObject * obj0 = 0 ;
25165 PyObject * obj1 = 0 ;
25166 PyObject * obj2 = 0 ;
25167 PyObject * obj3 = 0 ;
25168 char * kwnames[] = {
25169 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25170 };
25171
25172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25174 if (!SWIG_IsOK(res1)) {
25175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25176 }
25177 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25178 ecode2 = SWIG_AsVal_int(obj1, &val2);
25179 if (!SWIG_IsOK(ecode2)) {
25180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25181 }
25182 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25183 if (obj2) {
25184 ecode3 = SWIG_AsVal_int(obj2, &val3);
25185 if (!SWIG_IsOK(ecode3)) {
25186 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25187 }
25188 arg3 = static_cast< wxDateTime::Month >(val3);
25189 }
25190 if (obj3) {
25191 ecode4 = SWIG_AsVal_int(obj3, &val4);
25192 if (!SWIG_IsOK(ecode4)) {
25193 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25194 }
25195 arg4 = static_cast< int >(val4);
25196 }
25197 {
25198 PyThreadState* __tstate = wxPyBeginAllowThreads();
25199 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25200 wxPyEndAllowThreads(__tstate);
25201 if (PyErr_Occurred()) SWIG_fail;
25202 }
25203 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25204 return resultobj;
25205 fail:
25206 return NULL;
25207 }
25208
25209
25210 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25211 PyObject *resultobj = 0;
25212 wxDateTime *arg1 = (wxDateTime *) 0 ;
25213 int arg2 ;
25214 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25215 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25216 bool result;
25217 void *argp1 = 0 ;
25218 int res1 = 0 ;
25219 int val2 ;
25220 int ecode2 = 0 ;
25221 int val3 ;
25222 int ecode3 = 0 ;
25223 int val4 ;
25224 int ecode4 = 0 ;
25225 PyObject * obj0 = 0 ;
25226 PyObject * obj1 = 0 ;
25227 PyObject * obj2 = 0 ;
25228 PyObject * obj3 = 0 ;
25229 char * kwnames[] = {
25230 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25231 };
25232
25233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25235 if (!SWIG_IsOK(res1)) {
25236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25237 }
25238 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25239 ecode2 = SWIG_AsVal_int(obj1, &val2);
25240 if (!SWIG_IsOK(ecode2)) {
25241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25242 }
25243 arg2 = static_cast< int >(val2);
25244 if (obj2) {
25245 ecode3 = SWIG_AsVal_int(obj2, &val3);
25246 if (!SWIG_IsOK(ecode3)) {
25247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25248 }
25249 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25250 }
25251 if (obj3) {
25252 ecode4 = SWIG_AsVal_int(obj3, &val4);
25253 if (!SWIG_IsOK(ecode4)) {
25254 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25255 }
25256 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25257 }
25258 {
25259 PyThreadState* __tstate = wxPyBeginAllowThreads();
25260 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25261 wxPyEndAllowThreads(__tstate);
25262 if (PyErr_Occurred()) SWIG_fail;
25263 }
25264 {
25265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25266 }
25267 return resultobj;
25268 fail:
25269 return NULL;
25270 }
25271
25272
25273 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25274 PyObject *resultobj = 0;
25275 wxDateTime *arg1 = (wxDateTime *) 0 ;
25276 int arg2 ;
25277 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25278 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25279 wxDateTime result;
25280 void *argp1 = 0 ;
25281 int res1 = 0 ;
25282 int val2 ;
25283 int ecode2 = 0 ;
25284 int val3 ;
25285 int ecode3 = 0 ;
25286 int val4 ;
25287 int ecode4 = 0 ;
25288 PyObject * obj0 = 0 ;
25289 PyObject * obj1 = 0 ;
25290 PyObject * obj2 = 0 ;
25291 PyObject * obj3 = 0 ;
25292 char * kwnames[] = {
25293 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25294 };
25295
25296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25298 if (!SWIG_IsOK(res1)) {
25299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25300 }
25301 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25302 ecode2 = SWIG_AsVal_int(obj1, &val2);
25303 if (!SWIG_IsOK(ecode2)) {
25304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25305 }
25306 arg2 = static_cast< int >(val2);
25307 if (obj2) {
25308 ecode3 = SWIG_AsVal_int(obj2, &val3);
25309 if (!SWIG_IsOK(ecode3)) {
25310 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25311 }
25312 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25313 }
25314 if (obj3) {
25315 ecode4 = SWIG_AsVal_int(obj3, &val4);
25316 if (!SWIG_IsOK(ecode4)) {
25317 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25318 }
25319 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25320 }
25321 {
25322 PyThreadState* __tstate = wxPyBeginAllowThreads();
25323 result = (arg1)->GetWeek(arg2,arg3,arg4);
25324 wxPyEndAllowThreads(__tstate);
25325 if (PyErr_Occurred()) SWIG_fail;
25326 }
25327 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25328 return resultobj;
25329 fail:
25330 return NULL;
25331 }
25332
25333
25334 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25335 PyObject *resultobj = 0;
25336 int arg1 ;
25337 int arg2 ;
25338 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25339 wxDateTime result;
25340 int val1 ;
25341 int ecode1 = 0 ;
25342 int val2 ;
25343 int ecode2 = 0 ;
25344 int val3 ;
25345 int ecode3 = 0 ;
25346 PyObject * obj0 = 0 ;
25347 PyObject * obj1 = 0 ;
25348 PyObject * obj2 = 0 ;
25349 char * kwnames[] = {
25350 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25351 };
25352
25353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25354 ecode1 = SWIG_AsVal_int(obj0, &val1);
25355 if (!SWIG_IsOK(ecode1)) {
25356 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25357 }
25358 arg1 = static_cast< int >(val1);
25359 ecode2 = SWIG_AsVal_int(obj1, &val2);
25360 if (!SWIG_IsOK(ecode2)) {
25361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25362 }
25363 arg2 = static_cast< int >(val2);
25364 if (obj2) {
25365 ecode3 = SWIG_AsVal_int(obj2, &val3);
25366 if (!SWIG_IsOK(ecode3)) {
25367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25368 }
25369 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25370 }
25371 {
25372 PyThreadState* __tstate = wxPyBeginAllowThreads();
25373 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25374 wxPyEndAllowThreads(__tstate);
25375 if (PyErr_Occurred()) SWIG_fail;
25376 }
25377 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25378 return resultobj;
25379 fail:
25380 return NULL;
25381 }
25382
25383
25384 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25385 PyObject *resultobj = 0;
25386 wxDateTime *arg1 = (wxDateTime *) 0 ;
25387 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25388 int arg3 = (int) wxDateTime::Inv_Year ;
25389 wxDateTime *result = 0 ;
25390 void *argp1 = 0 ;
25391 int res1 = 0 ;
25392 int val2 ;
25393 int ecode2 = 0 ;
25394 int val3 ;
25395 int ecode3 = 0 ;
25396 PyObject * obj0 = 0 ;
25397 PyObject * obj1 = 0 ;
25398 PyObject * obj2 = 0 ;
25399 char * kwnames[] = {
25400 (char *) "self",(char *) "month",(char *) "year", NULL
25401 };
25402
25403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25405 if (!SWIG_IsOK(res1)) {
25406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25407 }
25408 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25409 if (obj1) {
25410 ecode2 = SWIG_AsVal_int(obj1, &val2);
25411 if (!SWIG_IsOK(ecode2)) {
25412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25413 }
25414 arg2 = static_cast< wxDateTime::Month >(val2);
25415 }
25416 if (obj2) {
25417 ecode3 = SWIG_AsVal_int(obj2, &val3);
25418 if (!SWIG_IsOK(ecode3)) {
25419 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25420 }
25421 arg3 = static_cast< int >(val3);
25422 }
25423 {
25424 PyThreadState* __tstate = wxPyBeginAllowThreads();
25425 {
25426 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25427 result = (wxDateTime *) &_result_ref;
25428 }
25429 wxPyEndAllowThreads(__tstate);
25430 if (PyErr_Occurred()) SWIG_fail;
25431 }
25432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25433 return resultobj;
25434 fail:
25435 return NULL;
25436 }
25437
25438
25439 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25440 PyObject *resultobj = 0;
25441 wxDateTime *arg1 = (wxDateTime *) 0 ;
25442 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25443 int arg3 = (int) wxDateTime::Inv_Year ;
25444 wxDateTime result;
25445 void *argp1 = 0 ;
25446 int res1 = 0 ;
25447 int val2 ;
25448 int ecode2 = 0 ;
25449 int val3 ;
25450 int ecode3 = 0 ;
25451 PyObject * obj0 = 0 ;
25452 PyObject * obj1 = 0 ;
25453 PyObject * obj2 = 0 ;
25454 char * kwnames[] = {
25455 (char *) "self",(char *) "month",(char *) "year", NULL
25456 };
25457
25458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25460 if (!SWIG_IsOK(res1)) {
25461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25462 }
25463 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25464 if (obj1) {
25465 ecode2 = SWIG_AsVal_int(obj1, &val2);
25466 if (!SWIG_IsOK(ecode2)) {
25467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25468 }
25469 arg2 = static_cast< wxDateTime::Month >(val2);
25470 }
25471 if (obj2) {
25472 ecode3 = SWIG_AsVal_int(obj2, &val3);
25473 if (!SWIG_IsOK(ecode3)) {
25474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25475 }
25476 arg3 = static_cast< int >(val3);
25477 }
25478 {
25479 PyThreadState* __tstate = wxPyBeginAllowThreads();
25480 result = (arg1)->GetLastMonthDay(arg2,arg3);
25481 wxPyEndAllowThreads(__tstate);
25482 if (PyErr_Occurred()) SWIG_fail;
25483 }
25484 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25485 return resultobj;
25486 fail:
25487 return NULL;
25488 }
25489
25490
25491 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25492 PyObject *resultobj = 0;
25493 wxDateTime *arg1 = (wxDateTime *) 0 ;
25494 int arg2 ;
25495 wxDateTime *result = 0 ;
25496 void *argp1 = 0 ;
25497 int res1 = 0 ;
25498 int val2 ;
25499 int ecode2 = 0 ;
25500 PyObject * obj0 = 0 ;
25501 PyObject * obj1 = 0 ;
25502 char * kwnames[] = {
25503 (char *) "self",(char *) "yday", NULL
25504 };
25505
25506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25508 if (!SWIG_IsOK(res1)) {
25509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25510 }
25511 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25512 ecode2 = SWIG_AsVal_int(obj1, &val2);
25513 if (!SWIG_IsOK(ecode2)) {
25514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25515 }
25516 arg2 = static_cast< int >(val2);
25517 {
25518 PyThreadState* __tstate = wxPyBeginAllowThreads();
25519 {
25520 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25521 result = (wxDateTime *) &_result_ref;
25522 }
25523 wxPyEndAllowThreads(__tstate);
25524 if (PyErr_Occurred()) SWIG_fail;
25525 }
25526 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25527 return resultobj;
25528 fail:
25529 return NULL;
25530 }
25531
25532
25533 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25534 PyObject *resultobj = 0;
25535 wxDateTime *arg1 = (wxDateTime *) 0 ;
25536 int arg2 ;
25537 wxDateTime result;
25538 void *argp1 = 0 ;
25539 int res1 = 0 ;
25540 int val2 ;
25541 int ecode2 = 0 ;
25542 PyObject * obj0 = 0 ;
25543 PyObject * obj1 = 0 ;
25544 char * kwnames[] = {
25545 (char *) "self",(char *) "yday", NULL
25546 };
25547
25548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25550 if (!SWIG_IsOK(res1)) {
25551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25552 }
25553 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25554 ecode2 = SWIG_AsVal_int(obj1, &val2);
25555 if (!SWIG_IsOK(ecode2)) {
25556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25557 }
25558 arg2 = static_cast< int >(val2);
25559 {
25560 PyThreadState* __tstate = wxPyBeginAllowThreads();
25561 result = (arg1)->GetYearDay(arg2);
25562 wxPyEndAllowThreads(__tstate);
25563 if (PyErr_Occurred()) SWIG_fail;
25564 }
25565 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25566 return resultobj;
25567 fail:
25568 return NULL;
25569 }
25570
25571
25572 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25573 PyObject *resultobj = 0;
25574 wxDateTime *arg1 = (wxDateTime *) 0 ;
25575 double result;
25576 void *argp1 = 0 ;
25577 int res1 = 0 ;
25578 PyObject *swig_obj[1] ;
25579
25580 if (!args) SWIG_fail;
25581 swig_obj[0] = args;
25582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25583 if (!SWIG_IsOK(res1)) {
25584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25585 }
25586 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25587 {
25588 PyThreadState* __tstate = wxPyBeginAllowThreads();
25589 result = (double)(arg1)->GetJulianDayNumber();
25590 wxPyEndAllowThreads(__tstate);
25591 if (PyErr_Occurred()) SWIG_fail;
25592 }
25593 resultobj = SWIG_From_double(static_cast< double >(result));
25594 return resultobj;
25595 fail:
25596 return NULL;
25597 }
25598
25599
25600 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25601 PyObject *resultobj = 0;
25602 wxDateTime *arg1 = (wxDateTime *) 0 ;
25603 double result;
25604 void *argp1 = 0 ;
25605 int res1 = 0 ;
25606 PyObject *swig_obj[1] ;
25607
25608 if (!args) SWIG_fail;
25609 swig_obj[0] = args;
25610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25611 if (!SWIG_IsOK(res1)) {
25612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25613 }
25614 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25615 {
25616 PyThreadState* __tstate = wxPyBeginAllowThreads();
25617 result = (double)(arg1)->GetJDN();
25618 wxPyEndAllowThreads(__tstate);
25619 if (PyErr_Occurred()) SWIG_fail;
25620 }
25621 resultobj = SWIG_From_double(static_cast< double >(result));
25622 return resultobj;
25623 fail:
25624 return NULL;
25625 }
25626
25627
25628 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25629 PyObject *resultobj = 0;
25630 wxDateTime *arg1 = (wxDateTime *) 0 ;
25631 double result;
25632 void *argp1 = 0 ;
25633 int res1 = 0 ;
25634 PyObject *swig_obj[1] ;
25635
25636 if (!args) SWIG_fail;
25637 swig_obj[0] = args;
25638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25639 if (!SWIG_IsOK(res1)) {
25640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25641 }
25642 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25643 {
25644 PyThreadState* __tstate = wxPyBeginAllowThreads();
25645 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25646 wxPyEndAllowThreads(__tstate);
25647 if (PyErr_Occurred()) SWIG_fail;
25648 }
25649 resultobj = SWIG_From_double(static_cast< double >(result));
25650 return resultobj;
25651 fail:
25652 return NULL;
25653 }
25654
25655
25656 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25657 PyObject *resultobj = 0;
25658 wxDateTime *arg1 = (wxDateTime *) 0 ;
25659 double result;
25660 void *argp1 = 0 ;
25661 int res1 = 0 ;
25662 PyObject *swig_obj[1] ;
25663
25664 if (!args) SWIG_fail;
25665 swig_obj[0] = args;
25666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25667 if (!SWIG_IsOK(res1)) {
25668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25669 }
25670 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25671 {
25672 PyThreadState* __tstate = wxPyBeginAllowThreads();
25673 result = (double)(arg1)->GetMJD();
25674 wxPyEndAllowThreads(__tstate);
25675 if (PyErr_Occurred()) SWIG_fail;
25676 }
25677 resultobj = SWIG_From_double(static_cast< double >(result));
25678 return resultobj;
25679 fail:
25680 return NULL;
25681 }
25682
25683
25684 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25685 PyObject *resultobj = 0;
25686 wxDateTime *arg1 = (wxDateTime *) 0 ;
25687 double result;
25688 void *argp1 = 0 ;
25689 int res1 = 0 ;
25690 PyObject *swig_obj[1] ;
25691
25692 if (!args) SWIG_fail;
25693 swig_obj[0] = args;
25694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25695 if (!SWIG_IsOK(res1)) {
25696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25697 }
25698 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25699 {
25700 PyThreadState* __tstate = wxPyBeginAllowThreads();
25701 result = (double)(arg1)->GetRataDie();
25702 wxPyEndAllowThreads(__tstate);
25703 if (PyErr_Occurred()) SWIG_fail;
25704 }
25705 resultobj = SWIG_From_double(static_cast< double >(result));
25706 return resultobj;
25707 fail:
25708 return NULL;
25709 }
25710
25711
25712 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25713 PyObject *resultobj = 0;
25714 wxDateTime *arg1 = (wxDateTime *) 0 ;
25715 wxDateTime::TimeZone *arg2 = 0 ;
25716 bool arg3 = (bool) false ;
25717 wxDateTime result;
25718 void *argp1 = 0 ;
25719 int res1 = 0 ;
25720 bool temp2 = false ;
25721 bool val3 ;
25722 int ecode3 = 0 ;
25723 PyObject * obj0 = 0 ;
25724 PyObject * obj1 = 0 ;
25725 PyObject * obj2 = 0 ;
25726 char * kwnames[] = {
25727 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25728 };
25729
25730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25732 if (!SWIG_IsOK(res1)) {
25733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25734 }
25735 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25736 {
25737 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25738 temp2 = true;
25739 }
25740 if (obj2) {
25741 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25742 if (!SWIG_IsOK(ecode3)) {
25743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25744 }
25745 arg3 = static_cast< bool >(val3);
25746 }
25747 {
25748 PyThreadState* __tstate = wxPyBeginAllowThreads();
25749 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25750 wxPyEndAllowThreads(__tstate);
25751 if (PyErr_Occurred()) SWIG_fail;
25752 }
25753 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25754 {
25755 if (temp2) delete arg2;
25756 }
25757 return resultobj;
25758 fail:
25759 {
25760 if (temp2) delete arg2;
25761 }
25762 return NULL;
25763 }
25764
25765
25766 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25767 PyObject *resultobj = 0;
25768 wxDateTime *arg1 = (wxDateTime *) 0 ;
25769 wxDateTime::TimeZone *arg2 = 0 ;
25770 bool arg3 = (bool) false ;
25771 wxDateTime *result = 0 ;
25772 void *argp1 = 0 ;
25773 int res1 = 0 ;
25774 bool temp2 = false ;
25775 bool val3 ;
25776 int ecode3 = 0 ;
25777 PyObject * obj0 = 0 ;
25778 PyObject * obj1 = 0 ;
25779 PyObject * obj2 = 0 ;
25780 char * kwnames[] = {
25781 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25782 };
25783
25784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25786 if (!SWIG_IsOK(res1)) {
25787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25788 }
25789 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25790 {
25791 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25792 temp2 = true;
25793 }
25794 if (obj2) {
25795 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25796 if (!SWIG_IsOK(ecode3)) {
25797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25798 }
25799 arg3 = static_cast< bool >(val3);
25800 }
25801 {
25802 PyThreadState* __tstate = wxPyBeginAllowThreads();
25803 {
25804 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25805 result = (wxDateTime *) &_result_ref;
25806 }
25807 wxPyEndAllowThreads(__tstate);
25808 if (PyErr_Occurred()) SWIG_fail;
25809 }
25810 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25811 {
25812 if (temp2) delete arg2;
25813 }
25814 return resultobj;
25815 fail:
25816 {
25817 if (temp2) delete arg2;
25818 }
25819 return NULL;
25820 }
25821
25822
25823 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25824 PyObject *resultobj = 0;
25825 wxDateTime *arg1 = (wxDateTime *) 0 ;
25826 wxDateTime::TimeZone *arg2 = 0 ;
25827 bool arg3 = (bool) false ;
25828 wxDateTime result;
25829 void *argp1 = 0 ;
25830 int res1 = 0 ;
25831 bool temp2 = false ;
25832 bool val3 ;
25833 int ecode3 = 0 ;
25834 PyObject * obj0 = 0 ;
25835 PyObject * obj1 = 0 ;
25836 PyObject * obj2 = 0 ;
25837 char * kwnames[] = {
25838 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25839 };
25840
25841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25843 if (!SWIG_IsOK(res1)) {
25844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25845 }
25846 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25847 {
25848 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25849 temp2 = true;
25850 }
25851 if (obj2) {
25852 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25853 if (!SWIG_IsOK(ecode3)) {
25854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25855 }
25856 arg3 = static_cast< bool >(val3);
25857 }
25858 {
25859 PyThreadState* __tstate = wxPyBeginAllowThreads();
25860 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25861 wxPyEndAllowThreads(__tstate);
25862 if (PyErr_Occurred()) SWIG_fail;
25863 }
25864 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25865 {
25866 if (temp2) delete arg2;
25867 }
25868 return resultobj;
25869 fail:
25870 {
25871 if (temp2) delete arg2;
25872 }
25873 return NULL;
25874 }
25875
25876
25877 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25878 PyObject *resultobj = 0;
25879 wxDateTime *arg1 = (wxDateTime *) 0 ;
25880 wxDateTime::TimeZone *arg2 = 0 ;
25881 bool arg3 = (bool) false ;
25882 wxDateTime *result = 0 ;
25883 void *argp1 = 0 ;
25884 int res1 = 0 ;
25885 bool temp2 = false ;
25886 bool val3 ;
25887 int ecode3 = 0 ;
25888 PyObject * obj0 = 0 ;
25889 PyObject * obj1 = 0 ;
25890 PyObject * obj2 = 0 ;
25891 char * kwnames[] = {
25892 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25893 };
25894
25895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25897 if (!SWIG_IsOK(res1)) {
25898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25899 }
25900 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25901 {
25902 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25903 temp2 = true;
25904 }
25905 if (obj2) {
25906 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25907 if (!SWIG_IsOK(ecode3)) {
25908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25909 }
25910 arg3 = static_cast< bool >(val3);
25911 }
25912 {
25913 PyThreadState* __tstate = wxPyBeginAllowThreads();
25914 {
25915 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25916 result = (wxDateTime *) &_result_ref;
25917 }
25918 wxPyEndAllowThreads(__tstate);
25919 if (PyErr_Occurred()) SWIG_fail;
25920 }
25921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25922 {
25923 if (temp2) delete arg2;
25924 }
25925 return resultobj;
25926 fail:
25927 {
25928 if (temp2) delete arg2;
25929 }
25930 return NULL;
25931 }
25932
25933
25934 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25935 PyObject *resultobj = 0;
25936 wxDateTime *arg1 = (wxDateTime *) 0 ;
25937 bool arg2 = (bool) false ;
25938 wxDateTime result;
25939 void *argp1 = 0 ;
25940 int res1 = 0 ;
25941 bool val2 ;
25942 int ecode2 = 0 ;
25943 PyObject * obj0 = 0 ;
25944 PyObject * obj1 = 0 ;
25945 char * kwnames[] = {
25946 (char *) "self",(char *) "noDST", NULL
25947 };
25948
25949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25951 if (!SWIG_IsOK(res1)) {
25952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25953 }
25954 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25955 if (obj1) {
25956 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25957 if (!SWIG_IsOK(ecode2)) {
25958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25959 }
25960 arg2 = static_cast< bool >(val2);
25961 }
25962 {
25963 PyThreadState* __tstate = wxPyBeginAllowThreads();
25964 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25965 wxPyEndAllowThreads(__tstate);
25966 if (PyErr_Occurred()) SWIG_fail;
25967 }
25968 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25969 return resultobj;
25970 fail:
25971 return NULL;
25972 }
25973
25974
25975 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25976 PyObject *resultobj = 0;
25977 wxDateTime *arg1 = (wxDateTime *) 0 ;
25978 bool arg2 = (bool) false ;
25979 wxDateTime *result = 0 ;
25980 void *argp1 = 0 ;
25981 int res1 = 0 ;
25982 bool val2 ;
25983 int ecode2 = 0 ;
25984 PyObject * obj0 = 0 ;
25985 PyObject * obj1 = 0 ;
25986 char * kwnames[] = {
25987 (char *) "self",(char *) "noDST", NULL
25988 };
25989
25990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25992 if (!SWIG_IsOK(res1)) {
25993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25994 }
25995 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25996 if (obj1) {
25997 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25998 if (!SWIG_IsOK(ecode2)) {
25999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
26000 }
26001 arg2 = static_cast< bool >(val2);
26002 }
26003 {
26004 PyThreadState* __tstate = wxPyBeginAllowThreads();
26005 {
26006 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
26007 result = (wxDateTime *) &_result_ref;
26008 }
26009 wxPyEndAllowThreads(__tstate);
26010 if (PyErr_Occurred()) SWIG_fail;
26011 }
26012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26013 return resultobj;
26014 fail:
26015 return NULL;
26016 }
26017
26018
26019 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26020 PyObject *resultobj = 0;
26021 wxDateTime *arg1 = (wxDateTime *) 0 ;
26022 bool arg2 = (bool) false ;
26023 wxDateTime result;
26024 void *argp1 = 0 ;
26025 int res1 = 0 ;
26026 bool val2 ;
26027 int ecode2 = 0 ;
26028 PyObject * obj0 = 0 ;
26029 PyObject * obj1 = 0 ;
26030 char * kwnames[] = {
26031 (char *) "self",(char *) "noDST", NULL
26032 };
26033
26034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26036 if (!SWIG_IsOK(res1)) {
26037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26038 }
26039 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26040 if (obj1) {
26041 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26042 if (!SWIG_IsOK(ecode2)) {
26043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
26044 }
26045 arg2 = static_cast< bool >(val2);
26046 }
26047 {
26048 PyThreadState* __tstate = wxPyBeginAllowThreads();
26049 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
26050 wxPyEndAllowThreads(__tstate);
26051 if (PyErr_Occurred()) SWIG_fail;
26052 }
26053 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26054 return resultobj;
26055 fail:
26056 return NULL;
26057 }
26058
26059
26060 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26061 PyObject *resultobj = 0;
26062 wxDateTime *arg1 = (wxDateTime *) 0 ;
26063 bool arg2 = (bool) false ;
26064 wxDateTime *result = 0 ;
26065 void *argp1 = 0 ;
26066 int res1 = 0 ;
26067 bool val2 ;
26068 int ecode2 = 0 ;
26069 PyObject * obj0 = 0 ;
26070 PyObject * obj1 = 0 ;
26071 char * kwnames[] = {
26072 (char *) "self",(char *) "noDST", NULL
26073 };
26074
26075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26077 if (!SWIG_IsOK(res1)) {
26078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
26079 }
26080 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26081 if (obj1) {
26082 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26083 if (!SWIG_IsOK(ecode2)) {
26084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
26085 }
26086 arg2 = static_cast< bool >(val2);
26087 }
26088 {
26089 PyThreadState* __tstate = wxPyBeginAllowThreads();
26090 {
26091 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
26092 result = (wxDateTime *) &_result_ref;
26093 }
26094 wxPyEndAllowThreads(__tstate);
26095 if (PyErr_Occurred()) SWIG_fail;
26096 }
26097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26098 return resultobj;
26099 fail:
26100 return NULL;
26101 }
26102
26103
26104 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26105 PyObject *resultobj = 0;
26106 wxDateTime *arg1 = (wxDateTime *) 0 ;
26107 bool arg2 = (bool) false ;
26108 wxDateTime result;
26109 void *argp1 = 0 ;
26110 int res1 = 0 ;
26111 bool val2 ;
26112 int ecode2 = 0 ;
26113 PyObject * obj0 = 0 ;
26114 PyObject * obj1 = 0 ;
26115 char * kwnames[] = {
26116 (char *) "self",(char *) "noDST", NULL
26117 };
26118
26119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26121 if (!SWIG_IsOK(res1)) {
26122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26123 }
26124 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26125 if (obj1) {
26126 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26127 if (!SWIG_IsOK(ecode2)) {
26128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26129 }
26130 arg2 = static_cast< bool >(val2);
26131 }
26132 {
26133 PyThreadState* __tstate = wxPyBeginAllowThreads();
26134 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26135 wxPyEndAllowThreads(__tstate);
26136 if (PyErr_Occurred()) SWIG_fail;
26137 }
26138 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26139 return resultobj;
26140 fail:
26141 return NULL;
26142 }
26143
26144
26145 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26146 PyObject *resultobj = 0;
26147 wxDateTime *arg1 = (wxDateTime *) 0 ;
26148 bool arg2 = (bool) false ;
26149 wxDateTime *result = 0 ;
26150 void *argp1 = 0 ;
26151 int res1 = 0 ;
26152 bool val2 ;
26153 int ecode2 = 0 ;
26154 PyObject * obj0 = 0 ;
26155 PyObject * obj1 = 0 ;
26156 char * kwnames[] = {
26157 (char *) "self",(char *) "noDST", NULL
26158 };
26159
26160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26162 if (!SWIG_IsOK(res1)) {
26163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26164 }
26165 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26166 if (obj1) {
26167 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26168 if (!SWIG_IsOK(ecode2)) {
26169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26170 }
26171 arg2 = static_cast< bool >(val2);
26172 }
26173 {
26174 PyThreadState* __tstate = wxPyBeginAllowThreads();
26175 {
26176 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26177 result = (wxDateTime *) &_result_ref;
26178 }
26179 wxPyEndAllowThreads(__tstate);
26180 if (PyErr_Occurred()) SWIG_fail;
26181 }
26182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26183 return resultobj;
26184 fail:
26185 return NULL;
26186 }
26187
26188
26189 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26190 PyObject *resultobj = 0;
26191 wxDateTime *arg1 = (wxDateTime *) 0 ;
26192 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26193 int result;
26194 void *argp1 = 0 ;
26195 int res1 = 0 ;
26196 int val2 ;
26197 int ecode2 = 0 ;
26198 PyObject * obj0 = 0 ;
26199 PyObject * obj1 = 0 ;
26200 char * kwnames[] = {
26201 (char *) "self",(char *) "country", NULL
26202 };
26203
26204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26206 if (!SWIG_IsOK(res1)) {
26207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26208 }
26209 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26210 if (obj1) {
26211 ecode2 = SWIG_AsVal_int(obj1, &val2);
26212 if (!SWIG_IsOK(ecode2)) {
26213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26214 }
26215 arg2 = static_cast< wxDateTime::Country >(val2);
26216 }
26217 {
26218 PyThreadState* __tstate = wxPyBeginAllowThreads();
26219 result = (int)(arg1)->IsDST(arg2);
26220 wxPyEndAllowThreads(__tstate);
26221 if (PyErr_Occurred()) SWIG_fail;
26222 }
26223 resultobj = SWIG_From_int(static_cast< int >(result));
26224 return resultobj;
26225 fail:
26226 return NULL;
26227 }
26228
26229
26230 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26231 PyObject *resultobj = 0;
26232 wxDateTime *arg1 = (wxDateTime *) 0 ;
26233 bool result;
26234 void *argp1 = 0 ;
26235 int res1 = 0 ;
26236 PyObject *swig_obj[1] ;
26237
26238 if (!args) SWIG_fail;
26239 swig_obj[0] = args;
26240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26241 if (!SWIG_IsOK(res1)) {
26242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26243 }
26244 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26245 {
26246 PyThreadState* __tstate = wxPyBeginAllowThreads();
26247 result = (bool)((wxDateTime const *)arg1)->IsValid();
26248 wxPyEndAllowThreads(__tstate);
26249 if (PyErr_Occurred()) SWIG_fail;
26250 }
26251 {
26252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26253 }
26254 return resultobj;
26255 fail:
26256 return NULL;
26257 }
26258
26259
26260 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26261 PyObject *resultobj = 0;
26262 wxDateTime *arg1 = (wxDateTime *) 0 ;
26263 time_t result;
26264 void *argp1 = 0 ;
26265 int res1 = 0 ;
26266 PyObject *swig_obj[1] ;
26267
26268 if (!args) SWIG_fail;
26269 swig_obj[0] = args;
26270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26271 if (!SWIG_IsOK(res1)) {
26272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26273 }
26274 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26275 {
26276 PyThreadState* __tstate = wxPyBeginAllowThreads();
26277 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26278 wxPyEndAllowThreads(__tstate);
26279 if (PyErr_Occurred()) SWIG_fail;
26280 }
26281 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26282 return resultobj;
26283 fail:
26284 return NULL;
26285 }
26286
26287
26288 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26289 PyObject *resultobj = 0;
26290 wxDateTime *arg1 = (wxDateTime *) 0 ;
26291 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26292 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26293 int result;
26294 void *argp1 = 0 ;
26295 int res1 = 0 ;
26296 bool temp2 = false ;
26297 PyObject * obj0 = 0 ;
26298 PyObject * obj1 = 0 ;
26299 char * kwnames[] = {
26300 (char *) "self",(char *) "tz", NULL
26301 };
26302
26303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26305 if (!SWIG_IsOK(res1)) {
26306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26307 }
26308 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26309 if (obj1) {
26310 {
26311 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26312 temp2 = true;
26313 }
26314 }
26315 {
26316 PyThreadState* __tstate = wxPyBeginAllowThreads();
26317 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26318 wxPyEndAllowThreads(__tstate);
26319 if (PyErr_Occurred()) SWIG_fail;
26320 }
26321 resultobj = SWIG_From_int(static_cast< int >(result));
26322 {
26323 if (temp2) delete arg2;
26324 }
26325 return resultobj;
26326 fail:
26327 {
26328 if (temp2) delete arg2;
26329 }
26330 return NULL;
26331 }
26332
26333
26334 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26335 PyObject *resultobj = 0;
26336 wxDateTime *arg1 = (wxDateTime *) 0 ;
26337 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26338 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26339 wxDateTime::Month result;
26340 void *argp1 = 0 ;
26341 int res1 = 0 ;
26342 bool temp2 = false ;
26343 PyObject * obj0 = 0 ;
26344 PyObject * obj1 = 0 ;
26345 char * kwnames[] = {
26346 (char *) "self",(char *) "tz", NULL
26347 };
26348
26349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26351 if (!SWIG_IsOK(res1)) {
26352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26353 }
26354 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26355 if (obj1) {
26356 {
26357 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26358 temp2 = true;
26359 }
26360 }
26361 {
26362 PyThreadState* __tstate = wxPyBeginAllowThreads();
26363 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26364 wxPyEndAllowThreads(__tstate);
26365 if (PyErr_Occurred()) SWIG_fail;
26366 }
26367 resultobj = SWIG_From_int(static_cast< int >(result));
26368 {
26369 if (temp2) delete arg2;
26370 }
26371 return resultobj;
26372 fail:
26373 {
26374 if (temp2) delete arg2;
26375 }
26376 return NULL;
26377 }
26378
26379
26380 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26381 PyObject *resultobj = 0;
26382 wxDateTime *arg1 = (wxDateTime *) 0 ;
26383 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26384 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26385 int result;
26386 void *argp1 = 0 ;
26387 int res1 = 0 ;
26388 bool temp2 = false ;
26389 PyObject * obj0 = 0 ;
26390 PyObject * obj1 = 0 ;
26391 char * kwnames[] = {
26392 (char *) "self",(char *) "tz", NULL
26393 };
26394
26395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26397 if (!SWIG_IsOK(res1)) {
26398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26399 }
26400 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26401 if (obj1) {
26402 {
26403 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26404 temp2 = true;
26405 }
26406 }
26407 {
26408 PyThreadState* __tstate = wxPyBeginAllowThreads();
26409 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26410 wxPyEndAllowThreads(__tstate);
26411 if (PyErr_Occurred()) SWIG_fail;
26412 }
26413 resultobj = SWIG_From_int(static_cast< int >(result));
26414 {
26415 if (temp2) delete arg2;
26416 }
26417 return resultobj;
26418 fail:
26419 {
26420 if (temp2) delete arg2;
26421 }
26422 return NULL;
26423 }
26424
26425
26426 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26427 PyObject *resultobj = 0;
26428 wxDateTime *arg1 = (wxDateTime *) 0 ;
26429 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26430 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26431 wxDateTime::WeekDay result;
26432 void *argp1 = 0 ;
26433 int res1 = 0 ;
26434 bool temp2 = false ;
26435 PyObject * obj0 = 0 ;
26436 PyObject * obj1 = 0 ;
26437 char * kwnames[] = {
26438 (char *) "self",(char *) "tz", NULL
26439 };
26440
26441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26443 if (!SWIG_IsOK(res1)) {
26444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26445 }
26446 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26447 if (obj1) {
26448 {
26449 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26450 temp2 = true;
26451 }
26452 }
26453 {
26454 PyThreadState* __tstate = wxPyBeginAllowThreads();
26455 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26456 wxPyEndAllowThreads(__tstate);
26457 if (PyErr_Occurred()) SWIG_fail;
26458 }
26459 resultobj = SWIG_From_int(static_cast< int >(result));
26460 {
26461 if (temp2) delete arg2;
26462 }
26463 return resultobj;
26464 fail:
26465 {
26466 if (temp2) delete arg2;
26467 }
26468 return NULL;
26469 }
26470
26471
26472 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26473 PyObject *resultobj = 0;
26474 wxDateTime *arg1 = (wxDateTime *) 0 ;
26475 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26476 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26477 int result;
26478 void *argp1 = 0 ;
26479 int res1 = 0 ;
26480 bool temp2 = false ;
26481 PyObject * obj0 = 0 ;
26482 PyObject * obj1 = 0 ;
26483 char * kwnames[] = {
26484 (char *) "self",(char *) "tz", NULL
26485 };
26486
26487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26489 if (!SWIG_IsOK(res1)) {
26490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26491 }
26492 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26493 if (obj1) {
26494 {
26495 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26496 temp2 = true;
26497 }
26498 }
26499 {
26500 PyThreadState* __tstate = wxPyBeginAllowThreads();
26501 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26502 wxPyEndAllowThreads(__tstate);
26503 if (PyErr_Occurred()) SWIG_fail;
26504 }
26505 resultobj = SWIG_From_int(static_cast< int >(result));
26506 {
26507 if (temp2) delete arg2;
26508 }
26509 return resultobj;
26510 fail:
26511 {
26512 if (temp2) delete arg2;
26513 }
26514 return NULL;
26515 }
26516
26517
26518 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26519 PyObject *resultobj = 0;
26520 wxDateTime *arg1 = (wxDateTime *) 0 ;
26521 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26522 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26523 int result;
26524 void *argp1 = 0 ;
26525 int res1 = 0 ;
26526 bool temp2 = false ;
26527 PyObject * obj0 = 0 ;
26528 PyObject * obj1 = 0 ;
26529 char * kwnames[] = {
26530 (char *) "self",(char *) "tz", NULL
26531 };
26532
26533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26535 if (!SWIG_IsOK(res1)) {
26536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26537 }
26538 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26539 if (obj1) {
26540 {
26541 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26542 temp2 = true;
26543 }
26544 }
26545 {
26546 PyThreadState* __tstate = wxPyBeginAllowThreads();
26547 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26548 wxPyEndAllowThreads(__tstate);
26549 if (PyErr_Occurred()) SWIG_fail;
26550 }
26551 resultobj = SWIG_From_int(static_cast< int >(result));
26552 {
26553 if (temp2) delete arg2;
26554 }
26555 return resultobj;
26556 fail:
26557 {
26558 if (temp2) delete arg2;
26559 }
26560 return NULL;
26561 }
26562
26563
26564 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26565 PyObject *resultobj = 0;
26566 wxDateTime *arg1 = (wxDateTime *) 0 ;
26567 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26568 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26569 int result;
26570 void *argp1 = 0 ;
26571 int res1 = 0 ;
26572 bool temp2 = false ;
26573 PyObject * obj0 = 0 ;
26574 PyObject * obj1 = 0 ;
26575 char * kwnames[] = {
26576 (char *) "self",(char *) "tz", NULL
26577 };
26578
26579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26581 if (!SWIG_IsOK(res1)) {
26582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26583 }
26584 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26585 if (obj1) {
26586 {
26587 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26588 temp2 = true;
26589 }
26590 }
26591 {
26592 PyThreadState* __tstate = wxPyBeginAllowThreads();
26593 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26594 wxPyEndAllowThreads(__tstate);
26595 if (PyErr_Occurred()) SWIG_fail;
26596 }
26597 resultobj = SWIG_From_int(static_cast< int >(result));
26598 {
26599 if (temp2) delete arg2;
26600 }
26601 return resultobj;
26602 fail:
26603 {
26604 if (temp2) delete arg2;
26605 }
26606 return NULL;
26607 }
26608
26609
26610 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26611 PyObject *resultobj = 0;
26612 wxDateTime *arg1 = (wxDateTime *) 0 ;
26613 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26614 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26615 int result;
26616 void *argp1 = 0 ;
26617 int res1 = 0 ;
26618 bool temp2 = false ;
26619 PyObject * obj0 = 0 ;
26620 PyObject * obj1 = 0 ;
26621 char * kwnames[] = {
26622 (char *) "self",(char *) "tz", NULL
26623 };
26624
26625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26627 if (!SWIG_IsOK(res1)) {
26628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26629 }
26630 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26631 if (obj1) {
26632 {
26633 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26634 temp2 = true;
26635 }
26636 }
26637 {
26638 PyThreadState* __tstate = wxPyBeginAllowThreads();
26639 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26640 wxPyEndAllowThreads(__tstate);
26641 if (PyErr_Occurred()) SWIG_fail;
26642 }
26643 resultobj = SWIG_From_int(static_cast< int >(result));
26644 {
26645 if (temp2) delete arg2;
26646 }
26647 return resultobj;
26648 fail:
26649 {
26650 if (temp2) delete arg2;
26651 }
26652 return NULL;
26653 }
26654
26655
26656 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26657 PyObject *resultobj = 0;
26658 wxDateTime *arg1 = (wxDateTime *) 0 ;
26659 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26660 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26661 int result;
26662 void *argp1 = 0 ;
26663 int res1 = 0 ;
26664 bool temp2 = false ;
26665 PyObject * obj0 = 0 ;
26666 PyObject * obj1 = 0 ;
26667 char * kwnames[] = {
26668 (char *) "self",(char *) "tz", NULL
26669 };
26670
26671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26673 if (!SWIG_IsOK(res1)) {
26674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26675 }
26676 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26677 if (obj1) {
26678 {
26679 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26680 temp2 = true;
26681 }
26682 }
26683 {
26684 PyThreadState* __tstate = wxPyBeginAllowThreads();
26685 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26686 wxPyEndAllowThreads(__tstate);
26687 if (PyErr_Occurred()) SWIG_fail;
26688 }
26689 resultobj = SWIG_From_int(static_cast< int >(result));
26690 {
26691 if (temp2) delete arg2;
26692 }
26693 return resultobj;
26694 fail:
26695 {
26696 if (temp2) delete arg2;
26697 }
26698 return NULL;
26699 }
26700
26701
26702 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26703 PyObject *resultobj = 0;
26704 wxDateTime *arg1 = (wxDateTime *) 0 ;
26705 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26706 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26707 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26708 int result;
26709 void *argp1 = 0 ;
26710 int res1 = 0 ;
26711 int val2 ;
26712 int ecode2 = 0 ;
26713 bool temp3 = false ;
26714 PyObject * obj0 = 0 ;
26715 PyObject * obj1 = 0 ;
26716 PyObject * obj2 = 0 ;
26717 char * kwnames[] = {
26718 (char *) "self",(char *) "flags",(char *) "tz", NULL
26719 };
26720
26721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26723 if (!SWIG_IsOK(res1)) {
26724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26725 }
26726 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26727 if (obj1) {
26728 ecode2 = SWIG_AsVal_int(obj1, &val2);
26729 if (!SWIG_IsOK(ecode2)) {
26730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26731 }
26732 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26733 }
26734 if (obj2) {
26735 {
26736 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26737 temp3 = true;
26738 }
26739 }
26740 {
26741 PyThreadState* __tstate = wxPyBeginAllowThreads();
26742 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26743 wxPyEndAllowThreads(__tstate);
26744 if (PyErr_Occurred()) SWIG_fail;
26745 }
26746 resultobj = SWIG_From_int(static_cast< int >(result));
26747 {
26748 if (temp3) delete arg3;
26749 }
26750 return resultobj;
26751 fail:
26752 {
26753 if (temp3) delete arg3;
26754 }
26755 return NULL;
26756 }
26757
26758
26759 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26760 PyObject *resultobj = 0;
26761 wxDateTime *arg1 = (wxDateTime *) 0 ;
26762 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26763 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26764 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26765 int result;
26766 void *argp1 = 0 ;
26767 int res1 = 0 ;
26768 int val2 ;
26769 int ecode2 = 0 ;
26770 bool temp3 = false ;
26771 PyObject * obj0 = 0 ;
26772 PyObject * obj1 = 0 ;
26773 PyObject * obj2 = 0 ;
26774 char * kwnames[] = {
26775 (char *) "self",(char *) "flags",(char *) "tz", NULL
26776 };
26777
26778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26780 if (!SWIG_IsOK(res1)) {
26781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26782 }
26783 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26784 if (obj1) {
26785 ecode2 = SWIG_AsVal_int(obj1, &val2);
26786 if (!SWIG_IsOK(ecode2)) {
26787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26788 }
26789 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26790 }
26791 if (obj2) {
26792 {
26793 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26794 temp3 = true;
26795 }
26796 }
26797 {
26798 PyThreadState* __tstate = wxPyBeginAllowThreads();
26799 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26800 wxPyEndAllowThreads(__tstate);
26801 if (PyErr_Occurred()) SWIG_fail;
26802 }
26803 resultobj = SWIG_From_int(static_cast< int >(result));
26804 {
26805 if (temp3) delete arg3;
26806 }
26807 return resultobj;
26808 fail:
26809 {
26810 if (temp3) delete arg3;
26811 }
26812 return NULL;
26813 }
26814
26815
26816 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26817 PyObject *resultobj = 0;
26818 wxDateTime *arg1 = (wxDateTime *) 0 ;
26819 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26820 bool result;
26821 void *argp1 = 0 ;
26822 int res1 = 0 ;
26823 int val2 ;
26824 int ecode2 = 0 ;
26825 PyObject * obj0 = 0 ;
26826 PyObject * obj1 = 0 ;
26827 char * kwnames[] = {
26828 (char *) "self",(char *) "country", NULL
26829 };
26830
26831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26833 if (!SWIG_IsOK(res1)) {
26834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26835 }
26836 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26837 if (obj1) {
26838 ecode2 = SWIG_AsVal_int(obj1, &val2);
26839 if (!SWIG_IsOK(ecode2)) {
26840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26841 }
26842 arg2 = static_cast< wxDateTime::Country >(val2);
26843 }
26844 {
26845 PyThreadState* __tstate = wxPyBeginAllowThreads();
26846 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26847 wxPyEndAllowThreads(__tstate);
26848 if (PyErr_Occurred()) SWIG_fail;
26849 }
26850 {
26851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26852 }
26853 return resultobj;
26854 fail:
26855 return NULL;
26856 }
26857
26858
26859 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26860 PyObject *resultobj = 0;
26861 wxDateTime *arg1 = (wxDateTime *) 0 ;
26862 wxDateTime *arg2 = 0 ;
26863 bool result;
26864 void *argp1 = 0 ;
26865 int res1 = 0 ;
26866 void *argp2 = 0 ;
26867 int res2 = 0 ;
26868 PyObject * obj0 = 0 ;
26869 PyObject * obj1 = 0 ;
26870 char * kwnames[] = {
26871 (char *) "self",(char *) "datetime", NULL
26872 };
26873
26874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26876 if (!SWIG_IsOK(res1)) {
26877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26878 }
26879 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26880 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26881 if (!SWIG_IsOK(res2)) {
26882 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26883 }
26884 if (!argp2) {
26885 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26886 }
26887 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26888 {
26889 PyThreadState* __tstate = wxPyBeginAllowThreads();
26890 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26891 wxPyEndAllowThreads(__tstate);
26892 if (PyErr_Occurred()) SWIG_fail;
26893 }
26894 {
26895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26896 }
26897 return resultobj;
26898 fail:
26899 return NULL;
26900 }
26901
26902
26903 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26904 PyObject *resultobj = 0;
26905 wxDateTime *arg1 = (wxDateTime *) 0 ;
26906 wxDateTime *arg2 = 0 ;
26907 bool result;
26908 void *argp1 = 0 ;
26909 int res1 = 0 ;
26910 void *argp2 = 0 ;
26911 int res2 = 0 ;
26912 PyObject * obj0 = 0 ;
26913 PyObject * obj1 = 0 ;
26914 char * kwnames[] = {
26915 (char *) "self",(char *) "datetime", NULL
26916 };
26917
26918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26920 if (!SWIG_IsOK(res1)) {
26921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26922 }
26923 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26924 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26925 if (!SWIG_IsOK(res2)) {
26926 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26927 }
26928 if (!argp2) {
26929 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26930 }
26931 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26932 {
26933 PyThreadState* __tstate = wxPyBeginAllowThreads();
26934 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26935 wxPyEndAllowThreads(__tstate);
26936 if (PyErr_Occurred()) SWIG_fail;
26937 }
26938 {
26939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26940 }
26941 return resultobj;
26942 fail:
26943 return NULL;
26944 }
26945
26946
26947 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26948 PyObject *resultobj = 0;
26949 wxDateTime *arg1 = (wxDateTime *) 0 ;
26950 wxDateTime *arg2 = 0 ;
26951 bool result;
26952 void *argp1 = 0 ;
26953 int res1 = 0 ;
26954 void *argp2 = 0 ;
26955 int res2 = 0 ;
26956 PyObject * obj0 = 0 ;
26957 PyObject * obj1 = 0 ;
26958 char * kwnames[] = {
26959 (char *) "self",(char *) "datetime", NULL
26960 };
26961
26962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26964 if (!SWIG_IsOK(res1)) {
26965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26966 }
26967 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26968 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26969 if (!SWIG_IsOK(res2)) {
26970 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26971 }
26972 if (!argp2) {
26973 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26974 }
26975 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26976 {
26977 PyThreadState* __tstate = wxPyBeginAllowThreads();
26978 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26979 wxPyEndAllowThreads(__tstate);
26980 if (PyErr_Occurred()) SWIG_fail;
26981 }
26982 {
26983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26984 }
26985 return resultobj;
26986 fail:
26987 return NULL;
26988 }
26989
26990
26991 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26992 PyObject *resultobj = 0;
26993 wxDateTime *arg1 = (wxDateTime *) 0 ;
26994 wxDateTime *arg2 = 0 ;
26995 wxDateTime *arg3 = 0 ;
26996 bool result;
26997 void *argp1 = 0 ;
26998 int res1 = 0 ;
26999 void *argp2 = 0 ;
27000 int res2 = 0 ;
27001 void *argp3 = 0 ;
27002 int res3 = 0 ;
27003 PyObject * obj0 = 0 ;
27004 PyObject * obj1 = 0 ;
27005 PyObject * obj2 = 0 ;
27006 char * kwnames[] = {
27007 (char *) "self",(char *) "t1",(char *) "t2", NULL
27008 };
27009
27010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27012 if (!SWIG_IsOK(res1)) {
27013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27014 }
27015 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27016 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27017 if (!SWIG_IsOK(res2)) {
27018 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27019 }
27020 if (!argp2) {
27021 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27022 }
27023 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27024 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27025 if (!SWIG_IsOK(res3)) {
27026 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27027 }
27028 if (!argp3) {
27029 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27030 }
27031 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27032 {
27033 PyThreadState* __tstate = wxPyBeginAllowThreads();
27034 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27035 wxPyEndAllowThreads(__tstate);
27036 if (PyErr_Occurred()) SWIG_fail;
27037 }
27038 {
27039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27040 }
27041 return resultobj;
27042 fail:
27043 return NULL;
27044 }
27045
27046
27047 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27048 PyObject *resultobj = 0;
27049 wxDateTime *arg1 = (wxDateTime *) 0 ;
27050 wxDateTime *arg2 = 0 ;
27051 wxDateTime *arg3 = 0 ;
27052 bool result;
27053 void *argp1 = 0 ;
27054 int res1 = 0 ;
27055 void *argp2 = 0 ;
27056 int res2 = 0 ;
27057 void *argp3 = 0 ;
27058 int res3 = 0 ;
27059 PyObject * obj0 = 0 ;
27060 PyObject * obj1 = 0 ;
27061 PyObject * obj2 = 0 ;
27062 char * kwnames[] = {
27063 (char *) "self",(char *) "t1",(char *) "t2", NULL
27064 };
27065
27066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27068 if (!SWIG_IsOK(res1)) {
27069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27070 }
27071 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27072 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27073 if (!SWIG_IsOK(res2)) {
27074 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27075 }
27076 if (!argp2) {
27077 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27078 }
27079 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27080 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27081 if (!SWIG_IsOK(res3)) {
27082 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27083 }
27084 if (!argp3) {
27085 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27086 }
27087 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27088 {
27089 PyThreadState* __tstate = wxPyBeginAllowThreads();
27090 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27091 wxPyEndAllowThreads(__tstate);
27092 if (PyErr_Occurred()) SWIG_fail;
27093 }
27094 {
27095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27096 }
27097 return resultobj;
27098 fail:
27099 return NULL;
27100 }
27101
27102
27103 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27104 PyObject *resultobj = 0;
27105 wxDateTime *arg1 = (wxDateTime *) 0 ;
27106 wxDateTime *arg2 = 0 ;
27107 bool result;
27108 void *argp1 = 0 ;
27109 int res1 = 0 ;
27110 void *argp2 = 0 ;
27111 int res2 = 0 ;
27112 PyObject * obj0 = 0 ;
27113 PyObject * obj1 = 0 ;
27114 char * kwnames[] = {
27115 (char *) "self",(char *) "dt", NULL
27116 };
27117
27118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27120 if (!SWIG_IsOK(res1)) {
27121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27122 }
27123 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27124 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27125 if (!SWIG_IsOK(res2)) {
27126 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27127 }
27128 if (!argp2) {
27129 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27130 }
27131 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27132 {
27133 PyThreadState* __tstate = wxPyBeginAllowThreads();
27134 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27135 wxPyEndAllowThreads(__tstate);
27136 if (PyErr_Occurred()) SWIG_fail;
27137 }
27138 {
27139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27140 }
27141 return resultobj;
27142 fail:
27143 return NULL;
27144 }
27145
27146
27147 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27148 PyObject *resultobj = 0;
27149 wxDateTime *arg1 = (wxDateTime *) 0 ;
27150 wxDateTime *arg2 = 0 ;
27151 bool result;
27152 void *argp1 = 0 ;
27153 int res1 = 0 ;
27154 void *argp2 = 0 ;
27155 int res2 = 0 ;
27156 PyObject * obj0 = 0 ;
27157 PyObject * obj1 = 0 ;
27158 char * kwnames[] = {
27159 (char *) "self",(char *) "dt", NULL
27160 };
27161
27162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27164 if (!SWIG_IsOK(res1)) {
27165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27166 }
27167 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27168 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27169 if (!SWIG_IsOK(res2)) {
27170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27171 }
27172 if (!argp2) {
27173 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27174 }
27175 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27176 {
27177 PyThreadState* __tstate = wxPyBeginAllowThreads();
27178 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27179 wxPyEndAllowThreads(__tstate);
27180 if (PyErr_Occurred()) SWIG_fail;
27181 }
27182 {
27183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27184 }
27185 return resultobj;
27186 fail:
27187 return NULL;
27188 }
27189
27190
27191 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27192 PyObject *resultobj = 0;
27193 wxDateTime *arg1 = (wxDateTime *) 0 ;
27194 wxDateTime *arg2 = 0 ;
27195 wxTimeSpan *arg3 = 0 ;
27196 bool result;
27197 void *argp1 = 0 ;
27198 int res1 = 0 ;
27199 void *argp2 = 0 ;
27200 int res2 = 0 ;
27201 void *argp3 = 0 ;
27202 int res3 = 0 ;
27203 PyObject * obj0 = 0 ;
27204 PyObject * obj1 = 0 ;
27205 PyObject * obj2 = 0 ;
27206 char * kwnames[] = {
27207 (char *) "self",(char *) "dt",(char *) "ts", NULL
27208 };
27209
27210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27212 if (!SWIG_IsOK(res1)) {
27213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27214 }
27215 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27216 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27217 if (!SWIG_IsOK(res2)) {
27218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27219 }
27220 if (!argp2) {
27221 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27222 }
27223 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27224 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27225 if (!SWIG_IsOK(res3)) {
27226 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27227 }
27228 if (!argp3) {
27229 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27230 }
27231 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27232 {
27233 PyThreadState* __tstate = wxPyBeginAllowThreads();
27234 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27235 wxPyEndAllowThreads(__tstate);
27236 if (PyErr_Occurred()) SWIG_fail;
27237 }
27238 {
27239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27240 }
27241 return resultobj;
27242 fail:
27243 return NULL;
27244 }
27245
27246
27247 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27248 PyObject *resultobj = 0;
27249 wxDateTime *arg1 = (wxDateTime *) 0 ;
27250 wxTimeSpan *arg2 = 0 ;
27251 wxDateTime *result = 0 ;
27252 void *argp1 = 0 ;
27253 int res1 = 0 ;
27254 void *argp2 = 0 ;
27255 int res2 = 0 ;
27256 PyObject * obj0 = 0 ;
27257 PyObject * obj1 = 0 ;
27258 char * kwnames[] = {
27259 (char *) "self",(char *) "diff", NULL
27260 };
27261
27262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27264 if (!SWIG_IsOK(res1)) {
27265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27266 }
27267 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27268 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27269 if (!SWIG_IsOK(res2)) {
27270 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27271 }
27272 if (!argp2) {
27273 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27274 }
27275 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27276 {
27277 PyThreadState* __tstate = wxPyBeginAllowThreads();
27278 {
27279 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27280 result = (wxDateTime *) &_result_ref;
27281 }
27282 wxPyEndAllowThreads(__tstate);
27283 if (PyErr_Occurred()) SWIG_fail;
27284 }
27285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27286 return resultobj;
27287 fail:
27288 return NULL;
27289 }
27290
27291
27292 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27293 PyObject *resultobj = 0;
27294 wxDateTime *arg1 = (wxDateTime *) 0 ;
27295 wxDateSpan *arg2 = 0 ;
27296 wxDateTime *result = 0 ;
27297 void *argp1 = 0 ;
27298 int res1 = 0 ;
27299 void *argp2 = 0 ;
27300 int res2 = 0 ;
27301 PyObject * obj0 = 0 ;
27302 PyObject * obj1 = 0 ;
27303 char * kwnames[] = {
27304 (char *) "self",(char *) "diff", NULL
27305 };
27306
27307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27309 if (!SWIG_IsOK(res1)) {
27310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27311 }
27312 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27313 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27314 if (!SWIG_IsOK(res2)) {
27315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27316 }
27317 if (!argp2) {
27318 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27319 }
27320 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27321 {
27322 PyThreadState* __tstate = wxPyBeginAllowThreads();
27323 {
27324 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27325 result = (wxDateTime *) &_result_ref;
27326 }
27327 wxPyEndAllowThreads(__tstate);
27328 if (PyErr_Occurred()) SWIG_fail;
27329 }
27330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27331 return resultobj;
27332 fail:
27333 return NULL;
27334 }
27335
27336
27337 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27338 PyObject *resultobj = 0;
27339 wxDateTime *arg1 = (wxDateTime *) 0 ;
27340 wxTimeSpan *arg2 = 0 ;
27341 wxDateTime *result = 0 ;
27342 void *argp1 = 0 ;
27343 int res1 = 0 ;
27344 void *argp2 = 0 ;
27345 int res2 = 0 ;
27346 PyObject * obj0 = 0 ;
27347 PyObject * obj1 = 0 ;
27348 char * kwnames[] = {
27349 (char *) "self",(char *) "diff", NULL
27350 };
27351
27352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27354 if (!SWIG_IsOK(res1)) {
27355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27356 }
27357 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27358 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27359 if (!SWIG_IsOK(res2)) {
27360 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27361 }
27362 if (!argp2) {
27363 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27364 }
27365 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27366 {
27367 PyThreadState* __tstate = wxPyBeginAllowThreads();
27368 {
27369 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27370 result = (wxDateTime *) &_result_ref;
27371 }
27372 wxPyEndAllowThreads(__tstate);
27373 if (PyErr_Occurred()) SWIG_fail;
27374 }
27375 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27376 return resultobj;
27377 fail:
27378 return NULL;
27379 }
27380
27381
27382 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27383 PyObject *resultobj = 0;
27384 wxDateTime *arg1 = (wxDateTime *) 0 ;
27385 wxDateSpan *arg2 = 0 ;
27386 wxDateTime *result = 0 ;
27387 void *argp1 = 0 ;
27388 int res1 = 0 ;
27389 void *argp2 = 0 ;
27390 int res2 = 0 ;
27391 PyObject * obj0 = 0 ;
27392 PyObject * obj1 = 0 ;
27393 char * kwnames[] = {
27394 (char *) "self",(char *) "diff", NULL
27395 };
27396
27397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27399 if (!SWIG_IsOK(res1)) {
27400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27401 }
27402 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27403 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27404 if (!SWIG_IsOK(res2)) {
27405 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27406 }
27407 if (!argp2) {
27408 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27409 }
27410 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27411 {
27412 PyThreadState* __tstate = wxPyBeginAllowThreads();
27413 {
27414 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27415 result = (wxDateTime *) &_result_ref;
27416 }
27417 wxPyEndAllowThreads(__tstate);
27418 if (PyErr_Occurred()) SWIG_fail;
27419 }
27420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27421 return resultobj;
27422 fail:
27423 return NULL;
27424 }
27425
27426
27427 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27428 PyObject *resultobj = 0;
27429 wxDateTime *arg1 = (wxDateTime *) 0 ;
27430 wxDateTime *arg2 = 0 ;
27431 wxTimeSpan result;
27432 void *argp1 = 0 ;
27433 int res1 = 0 ;
27434 void *argp2 = 0 ;
27435 int res2 = 0 ;
27436 PyObject * obj0 = 0 ;
27437 PyObject * obj1 = 0 ;
27438 char * kwnames[] = {
27439 (char *) "self",(char *) "dt", NULL
27440 };
27441
27442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27444 if (!SWIG_IsOK(res1)) {
27445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27446 }
27447 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27448 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27449 if (!SWIG_IsOK(res2)) {
27450 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27451 }
27452 if (!argp2) {
27453 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27454 }
27455 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27456 {
27457 PyThreadState* __tstate = wxPyBeginAllowThreads();
27458 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27459 wxPyEndAllowThreads(__tstate);
27460 if (PyErr_Occurred()) SWIG_fail;
27461 }
27462 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27463 return resultobj;
27464 fail:
27465 return NULL;
27466 }
27467
27468
27469 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27470 PyObject *resultobj = 0;
27471 wxDateTime *arg1 = (wxDateTime *) 0 ;
27472 wxTimeSpan *arg2 = 0 ;
27473 wxDateTime *result = 0 ;
27474 void *argp1 = 0 ;
27475 int res1 = 0 ;
27476 void *argp2 = 0 ;
27477 int res2 = 0 ;
27478
27479 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27481 if (!SWIG_IsOK(res1)) {
27482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27483 }
27484 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27485 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27486 if (!SWIG_IsOK(res2)) {
27487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27488 }
27489 if (!argp2) {
27490 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27491 }
27492 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27493 {
27494 PyThreadState* __tstate = wxPyBeginAllowThreads();
27495 {
27496 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27497 result = (wxDateTime *) &_result_ref;
27498 }
27499 wxPyEndAllowThreads(__tstate);
27500 if (PyErr_Occurred()) SWIG_fail;
27501 }
27502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27503 return resultobj;
27504 fail:
27505 return NULL;
27506 }
27507
27508
27509 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27510 PyObject *resultobj = 0;
27511 wxDateTime *arg1 = (wxDateTime *) 0 ;
27512 wxDateSpan *arg2 = 0 ;
27513 wxDateTime *result = 0 ;
27514 void *argp1 = 0 ;
27515 int res1 = 0 ;
27516 void *argp2 = 0 ;
27517 int res2 = 0 ;
27518
27519 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27521 if (!SWIG_IsOK(res1)) {
27522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27523 }
27524 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27525 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27526 if (!SWIG_IsOK(res2)) {
27527 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27528 }
27529 if (!argp2) {
27530 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27531 }
27532 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27533 {
27534 PyThreadState* __tstate = wxPyBeginAllowThreads();
27535 {
27536 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27537 result = (wxDateTime *) &_result_ref;
27538 }
27539 wxPyEndAllowThreads(__tstate);
27540 if (PyErr_Occurred()) SWIG_fail;
27541 }
27542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27543 return resultobj;
27544 fail:
27545 return NULL;
27546 }
27547
27548
27549 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27550 int argc;
27551 PyObject *argv[3];
27552
27553 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27554 --argc;
27555 if (argc == 2) {
27556 int _v = 0;
27557 {
27558 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27559 _v = SWIG_CheckState(res);
27560 }
27561 if (!_v) goto check_1;
27562 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27563 }
27564 check_1:
27565
27566 if (argc == 2) {
27567 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27568 }
27569
27570 fail:
27571 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27572 return NULL;
27573 }
27574
27575
27576 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27577 PyObject *resultobj = 0;
27578 wxDateTime *arg1 = (wxDateTime *) 0 ;
27579 wxTimeSpan *arg2 = 0 ;
27580 wxDateTime *result = 0 ;
27581 void *argp1 = 0 ;
27582 int res1 = 0 ;
27583 void *argp2 = 0 ;
27584 int res2 = 0 ;
27585
27586 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27588 if (!SWIG_IsOK(res1)) {
27589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27590 }
27591 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27592 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27593 if (!SWIG_IsOK(res2)) {
27594 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27595 }
27596 if (!argp2) {
27597 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27598 }
27599 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27600 {
27601 PyThreadState* __tstate = wxPyBeginAllowThreads();
27602 {
27603 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27604 result = (wxDateTime *) &_result_ref;
27605 }
27606 wxPyEndAllowThreads(__tstate);
27607 if (PyErr_Occurred()) SWIG_fail;
27608 }
27609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27610 return resultobj;
27611 fail:
27612 return NULL;
27613 }
27614
27615
27616 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27617 PyObject *resultobj = 0;
27618 wxDateTime *arg1 = (wxDateTime *) 0 ;
27619 wxDateSpan *arg2 = 0 ;
27620 wxDateTime *result = 0 ;
27621 void *argp1 = 0 ;
27622 int res1 = 0 ;
27623 void *argp2 = 0 ;
27624 int res2 = 0 ;
27625
27626 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27628 if (!SWIG_IsOK(res1)) {
27629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27630 }
27631 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27632 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27633 if (!SWIG_IsOK(res2)) {
27634 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27635 }
27636 if (!argp2) {
27637 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27638 }
27639 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27640 {
27641 PyThreadState* __tstate = wxPyBeginAllowThreads();
27642 {
27643 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27644 result = (wxDateTime *) &_result_ref;
27645 }
27646 wxPyEndAllowThreads(__tstate);
27647 if (PyErr_Occurred()) SWIG_fail;
27648 }
27649 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27650 return resultobj;
27651 fail:
27652 return NULL;
27653 }
27654
27655
27656 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27657 int argc;
27658 PyObject *argv[3];
27659
27660 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27661 --argc;
27662 if (argc == 2) {
27663 int _v = 0;
27664 {
27665 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27666 _v = SWIG_CheckState(res);
27667 }
27668 if (!_v) goto check_1;
27669 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27670 }
27671 check_1:
27672
27673 if (argc == 2) {
27674 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27675 }
27676
27677 fail:
27678 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27679 return NULL;
27680 }
27681
27682
27683 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27684 PyObject *resultobj = 0;
27685 wxDateTime *arg1 = (wxDateTime *) 0 ;
27686 wxTimeSpan *arg2 = 0 ;
27687 wxDateTime result;
27688 void *argp1 = 0 ;
27689 int res1 = 0 ;
27690 void *argp2 = 0 ;
27691 int res2 = 0 ;
27692
27693 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27695 if (!SWIG_IsOK(res1)) {
27696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27697 }
27698 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27699 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27700 if (!SWIG_IsOK(res2)) {
27701 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27702 }
27703 if (!argp2) {
27704 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27705 }
27706 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27707 {
27708 PyThreadState* __tstate = wxPyBeginAllowThreads();
27709 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27710 wxPyEndAllowThreads(__tstate);
27711 if (PyErr_Occurred()) SWIG_fail;
27712 }
27713 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27714 return resultobj;
27715 fail:
27716 return NULL;
27717 }
27718
27719
27720 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27721 PyObject *resultobj = 0;
27722 wxDateTime *arg1 = (wxDateTime *) 0 ;
27723 wxDateSpan *arg2 = 0 ;
27724 wxDateTime result;
27725 void *argp1 = 0 ;
27726 int res1 = 0 ;
27727 void *argp2 = 0 ;
27728 int res2 = 0 ;
27729
27730 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27732 if (!SWIG_IsOK(res1)) {
27733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27734 }
27735 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27736 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27737 if (!SWIG_IsOK(res2)) {
27738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27739 }
27740 if (!argp2) {
27741 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27742 }
27743 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27744 {
27745 PyThreadState* __tstate = wxPyBeginAllowThreads();
27746 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27747 wxPyEndAllowThreads(__tstate);
27748 if (PyErr_Occurred()) SWIG_fail;
27749 }
27750 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27751 return resultobj;
27752 fail:
27753 return NULL;
27754 }
27755
27756
27757 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27758 int argc;
27759 PyObject *argv[3];
27760
27761 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27762 --argc;
27763 if (argc == 2) {
27764 int _v = 0;
27765 {
27766 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27767 _v = SWIG_CheckState(res);
27768 }
27769 if (!_v) goto check_1;
27770 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27771 }
27772 check_1:
27773
27774 if (argc == 2) {
27775 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27776 }
27777
27778 fail:
27779 Py_INCREF(Py_NotImplemented);
27780 return Py_NotImplemented;
27781 }
27782
27783
27784 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27785 PyObject *resultobj = 0;
27786 wxDateTime *arg1 = (wxDateTime *) 0 ;
27787 wxDateTime *arg2 = 0 ;
27788 wxTimeSpan result;
27789 void *argp1 = 0 ;
27790 int res1 = 0 ;
27791 void *argp2 = 0 ;
27792 int res2 = 0 ;
27793
27794 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27796 if (!SWIG_IsOK(res1)) {
27797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27798 }
27799 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27800 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27801 if (!SWIG_IsOK(res2)) {
27802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27803 }
27804 if (!argp2) {
27805 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27806 }
27807 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27808 {
27809 PyThreadState* __tstate = wxPyBeginAllowThreads();
27810 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27811 wxPyEndAllowThreads(__tstate);
27812 if (PyErr_Occurred()) SWIG_fail;
27813 }
27814 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27815 return resultobj;
27816 fail:
27817 return NULL;
27818 }
27819
27820
27821 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27822 PyObject *resultobj = 0;
27823 wxDateTime *arg1 = (wxDateTime *) 0 ;
27824 wxTimeSpan *arg2 = 0 ;
27825 wxDateTime result;
27826 void *argp1 = 0 ;
27827 int res1 = 0 ;
27828 void *argp2 = 0 ;
27829 int res2 = 0 ;
27830
27831 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27833 if (!SWIG_IsOK(res1)) {
27834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27835 }
27836 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27837 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27838 if (!SWIG_IsOK(res2)) {
27839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27840 }
27841 if (!argp2) {
27842 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27843 }
27844 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27845 {
27846 PyThreadState* __tstate = wxPyBeginAllowThreads();
27847 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27848 wxPyEndAllowThreads(__tstate);
27849 if (PyErr_Occurred()) SWIG_fail;
27850 }
27851 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27852 return resultobj;
27853 fail:
27854 return NULL;
27855 }
27856
27857
27858 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27859 PyObject *resultobj = 0;
27860 wxDateTime *arg1 = (wxDateTime *) 0 ;
27861 wxDateSpan *arg2 = 0 ;
27862 wxDateTime result;
27863 void *argp1 = 0 ;
27864 int res1 = 0 ;
27865 void *argp2 = 0 ;
27866 int res2 = 0 ;
27867
27868 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27870 if (!SWIG_IsOK(res1)) {
27871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27872 }
27873 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27874 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27875 if (!SWIG_IsOK(res2)) {
27876 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27877 }
27878 if (!argp2) {
27879 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27880 }
27881 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27882 {
27883 PyThreadState* __tstate = wxPyBeginAllowThreads();
27884 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27885 wxPyEndAllowThreads(__tstate);
27886 if (PyErr_Occurred()) SWIG_fail;
27887 }
27888 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27889 return resultobj;
27890 fail:
27891 return NULL;
27892 }
27893
27894
27895 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27896 int argc;
27897 PyObject *argv[3];
27898
27899 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27900 --argc;
27901 if (argc == 2) {
27902 int _v = 0;
27903 {
27904 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27905 _v = SWIG_CheckState(res);
27906 }
27907 if (!_v) goto check_1;
27908 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27909 }
27910 check_1:
27911
27912 if (argc == 2) {
27913 int _v = 0;
27914 {
27915 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27916 _v = SWIG_CheckState(res);
27917 }
27918 if (!_v) goto check_2;
27919 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27920 }
27921 check_2:
27922
27923 if (argc == 2) {
27924 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27925 }
27926
27927 fail:
27928 Py_INCREF(Py_NotImplemented);
27929 return Py_NotImplemented;
27930 }
27931
27932
27933 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27934 PyObject *resultobj = 0;
27935 wxDateTime *arg1 = (wxDateTime *) 0 ;
27936 wxDateTime *arg2 = (wxDateTime *) 0 ;
27937 bool result;
27938 void *argp1 = 0 ;
27939 int res1 = 0 ;
27940 void *argp2 = 0 ;
27941 int res2 = 0 ;
27942 PyObject * obj0 = 0 ;
27943 PyObject * obj1 = 0 ;
27944 char * kwnames[] = {
27945 (char *) "self",(char *) "other", NULL
27946 };
27947
27948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27950 if (!SWIG_IsOK(res1)) {
27951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27952 }
27953 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27954 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27955 if (!SWIG_IsOK(res2)) {
27956 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27957 }
27958 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27959 {
27960 PyThreadState* __tstate = wxPyBeginAllowThreads();
27961 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27962 wxPyEndAllowThreads(__tstate);
27963 if (PyErr_Occurred()) SWIG_fail;
27964 }
27965 {
27966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27967 }
27968 return resultobj;
27969 fail:
27970 return NULL;
27971 }
27972
27973
27974 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27975 PyObject *resultobj = 0;
27976 wxDateTime *arg1 = (wxDateTime *) 0 ;
27977 wxDateTime *arg2 = (wxDateTime *) 0 ;
27978 bool result;
27979 void *argp1 = 0 ;
27980 int res1 = 0 ;
27981 void *argp2 = 0 ;
27982 int res2 = 0 ;
27983 PyObject * obj0 = 0 ;
27984 PyObject * obj1 = 0 ;
27985 char * kwnames[] = {
27986 (char *) "self",(char *) "other", NULL
27987 };
27988
27989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27991 if (!SWIG_IsOK(res1)) {
27992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27993 }
27994 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27995 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27996 if (!SWIG_IsOK(res2)) {
27997 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27998 }
27999 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28000 {
28001 PyThreadState* __tstate = wxPyBeginAllowThreads();
28002 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
28003 wxPyEndAllowThreads(__tstate);
28004 if (PyErr_Occurred()) SWIG_fail;
28005 }
28006 {
28007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28008 }
28009 return resultobj;
28010 fail:
28011 return NULL;
28012 }
28013
28014
28015 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28016 PyObject *resultobj = 0;
28017 wxDateTime *arg1 = (wxDateTime *) 0 ;
28018 wxDateTime *arg2 = (wxDateTime *) 0 ;
28019 bool result;
28020 void *argp1 = 0 ;
28021 int res1 = 0 ;
28022 void *argp2 = 0 ;
28023 int res2 = 0 ;
28024 PyObject * obj0 = 0 ;
28025 PyObject * obj1 = 0 ;
28026 char * kwnames[] = {
28027 (char *) "self",(char *) "other", NULL
28028 };
28029
28030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28032 if (!SWIG_IsOK(res1)) {
28033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28034 }
28035 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28036 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28037 if (!SWIG_IsOK(res2)) {
28038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28039 }
28040 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28041 {
28042 PyThreadState* __tstate = wxPyBeginAllowThreads();
28043 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
28044 wxPyEndAllowThreads(__tstate);
28045 if (PyErr_Occurred()) SWIG_fail;
28046 }
28047 {
28048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28049 }
28050 return resultobj;
28051 fail:
28052 return NULL;
28053 }
28054
28055
28056 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28057 PyObject *resultobj = 0;
28058 wxDateTime *arg1 = (wxDateTime *) 0 ;
28059 wxDateTime *arg2 = (wxDateTime *) 0 ;
28060 bool result;
28061 void *argp1 = 0 ;
28062 int res1 = 0 ;
28063 void *argp2 = 0 ;
28064 int res2 = 0 ;
28065 PyObject * obj0 = 0 ;
28066 PyObject * obj1 = 0 ;
28067 char * kwnames[] = {
28068 (char *) "self",(char *) "other", NULL
28069 };
28070
28071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28073 if (!SWIG_IsOK(res1)) {
28074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28075 }
28076 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28077 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28078 if (!SWIG_IsOK(res2)) {
28079 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28080 }
28081 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28082 {
28083 PyThreadState* __tstate = wxPyBeginAllowThreads();
28084 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
28085 wxPyEndAllowThreads(__tstate);
28086 if (PyErr_Occurred()) SWIG_fail;
28087 }
28088 {
28089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28090 }
28091 return resultobj;
28092 fail:
28093 return NULL;
28094 }
28095
28096
28097 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28098 PyObject *resultobj = 0;
28099 wxDateTime *arg1 = (wxDateTime *) 0 ;
28100 wxDateTime *arg2 = (wxDateTime *) 0 ;
28101 bool result;
28102 void *argp1 = 0 ;
28103 int res1 = 0 ;
28104 void *argp2 = 0 ;
28105 int res2 = 0 ;
28106 PyObject * obj0 = 0 ;
28107 PyObject * obj1 = 0 ;
28108 char * kwnames[] = {
28109 (char *) "self",(char *) "other", NULL
28110 };
28111
28112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28114 if (!SWIG_IsOK(res1)) {
28115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28116 }
28117 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28118 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28119 if (!SWIG_IsOK(res2)) {
28120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28121 }
28122 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28123 {
28124 PyThreadState* __tstate = wxPyBeginAllowThreads();
28125 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28126 wxPyEndAllowThreads(__tstate);
28127 if (PyErr_Occurred()) SWIG_fail;
28128 }
28129 {
28130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28131 }
28132 return resultobj;
28133 fail:
28134 return NULL;
28135 }
28136
28137
28138 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28139 PyObject *resultobj = 0;
28140 wxDateTime *arg1 = (wxDateTime *) 0 ;
28141 wxDateTime *arg2 = (wxDateTime *) 0 ;
28142 bool result;
28143 void *argp1 = 0 ;
28144 int res1 = 0 ;
28145 void *argp2 = 0 ;
28146 int res2 = 0 ;
28147 PyObject * obj0 = 0 ;
28148 PyObject * obj1 = 0 ;
28149 char * kwnames[] = {
28150 (char *) "self",(char *) "other", NULL
28151 };
28152
28153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28155 if (!SWIG_IsOK(res1)) {
28156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28157 }
28158 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28159 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28160 if (!SWIG_IsOK(res2)) {
28161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28162 }
28163 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28164 {
28165 PyThreadState* __tstate = wxPyBeginAllowThreads();
28166 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28167 wxPyEndAllowThreads(__tstate);
28168 if (PyErr_Occurred()) SWIG_fail;
28169 }
28170 {
28171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28172 }
28173 return resultobj;
28174 fail:
28175 return NULL;
28176 }
28177
28178
28179 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28180 PyObject *resultobj = 0;
28181 wxDateTime *arg1 = (wxDateTime *) 0 ;
28182 wxString *arg2 = 0 ;
28183 int result;
28184 void *argp1 = 0 ;
28185 int res1 = 0 ;
28186 bool temp2 = false ;
28187 PyObject * obj0 = 0 ;
28188 PyObject * obj1 = 0 ;
28189 char * kwnames[] = {
28190 (char *) "self",(char *) "date", NULL
28191 };
28192
28193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28195 if (!SWIG_IsOK(res1)) {
28196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28197 }
28198 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28199 {
28200 arg2 = wxString_in_helper(obj1);
28201 if (arg2 == NULL) SWIG_fail;
28202 temp2 = true;
28203 }
28204 {
28205 PyThreadState* __tstate = wxPyBeginAllowThreads();
28206 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28207 wxPyEndAllowThreads(__tstate);
28208 if (PyErr_Occurred()) SWIG_fail;
28209 }
28210 resultobj = SWIG_From_int(static_cast< int >(result));
28211 {
28212 if (temp2)
28213 delete arg2;
28214 }
28215 return resultobj;
28216 fail:
28217 {
28218 if (temp2)
28219 delete arg2;
28220 }
28221 return NULL;
28222 }
28223
28224
28225 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28226 PyObject *resultobj = 0;
28227 wxDateTime *arg1 = (wxDateTime *) 0 ;
28228 wxString *arg2 = 0 ;
28229 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28230 wxString *arg3 = (wxString *) &arg3_defvalue ;
28231 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28232 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28233 int result;
28234 void *argp1 = 0 ;
28235 int res1 = 0 ;
28236 bool temp2 = false ;
28237 bool temp3 = false ;
28238 void *argp4 = 0 ;
28239 int res4 = 0 ;
28240 PyObject * obj0 = 0 ;
28241 PyObject * obj1 = 0 ;
28242 PyObject * obj2 = 0 ;
28243 PyObject * obj3 = 0 ;
28244 char * kwnames[] = {
28245 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28246 };
28247
28248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28250 if (!SWIG_IsOK(res1)) {
28251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28252 }
28253 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28254 {
28255 arg2 = wxString_in_helper(obj1);
28256 if (arg2 == NULL) SWIG_fail;
28257 temp2 = true;
28258 }
28259 if (obj2) {
28260 {
28261 arg3 = wxString_in_helper(obj2);
28262 if (arg3 == NULL) SWIG_fail;
28263 temp3 = true;
28264 }
28265 }
28266 if (obj3) {
28267 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28268 if (!SWIG_IsOK(res4)) {
28269 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28270 }
28271 if (!argp4) {
28272 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28273 }
28274 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28275 }
28276 {
28277 PyThreadState* __tstate = wxPyBeginAllowThreads();
28278 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28279 wxPyEndAllowThreads(__tstate);
28280 if (PyErr_Occurred()) SWIG_fail;
28281 }
28282 resultobj = SWIG_From_int(static_cast< int >(result));
28283 {
28284 if (temp2)
28285 delete arg2;
28286 }
28287 {
28288 if (temp3)
28289 delete arg3;
28290 }
28291 return resultobj;
28292 fail:
28293 {
28294 if (temp2)
28295 delete arg2;
28296 }
28297 {
28298 if (temp3)
28299 delete arg3;
28300 }
28301 return NULL;
28302 }
28303
28304
28305 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28306 PyObject *resultobj = 0;
28307 wxDateTime *arg1 = (wxDateTime *) 0 ;
28308 wxString *arg2 = 0 ;
28309 int result;
28310 void *argp1 = 0 ;
28311 int res1 = 0 ;
28312 bool temp2 = false ;
28313 PyObject * obj0 = 0 ;
28314 PyObject * obj1 = 0 ;
28315 char * kwnames[] = {
28316 (char *) "self",(char *) "datetime", NULL
28317 };
28318
28319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28321 if (!SWIG_IsOK(res1)) {
28322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28323 }
28324 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28325 {
28326 arg2 = wxString_in_helper(obj1);
28327 if (arg2 == NULL) SWIG_fail;
28328 temp2 = true;
28329 }
28330 {
28331 PyThreadState* __tstate = wxPyBeginAllowThreads();
28332 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28333 wxPyEndAllowThreads(__tstate);
28334 if (PyErr_Occurred()) SWIG_fail;
28335 }
28336 resultobj = SWIG_From_int(static_cast< int >(result));
28337 {
28338 if (temp2)
28339 delete arg2;
28340 }
28341 return resultobj;
28342 fail:
28343 {
28344 if (temp2)
28345 delete arg2;
28346 }
28347 return NULL;
28348 }
28349
28350
28351 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28352 PyObject *resultobj = 0;
28353 wxDateTime *arg1 = (wxDateTime *) 0 ;
28354 wxString *arg2 = 0 ;
28355 int result;
28356 void *argp1 = 0 ;
28357 int res1 = 0 ;
28358 bool temp2 = false ;
28359 PyObject * obj0 = 0 ;
28360 PyObject * obj1 = 0 ;
28361 char * kwnames[] = {
28362 (char *) "self",(char *) "date", NULL
28363 };
28364
28365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28367 if (!SWIG_IsOK(res1)) {
28368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28369 }
28370 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28371 {
28372 arg2 = wxString_in_helper(obj1);
28373 if (arg2 == NULL) SWIG_fail;
28374 temp2 = true;
28375 }
28376 {
28377 PyThreadState* __tstate = wxPyBeginAllowThreads();
28378 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28379 wxPyEndAllowThreads(__tstate);
28380 if (PyErr_Occurred()) SWIG_fail;
28381 }
28382 resultobj = SWIG_From_int(static_cast< int >(result));
28383 {
28384 if (temp2)
28385 delete arg2;
28386 }
28387 return resultobj;
28388 fail:
28389 {
28390 if (temp2)
28391 delete arg2;
28392 }
28393 return NULL;
28394 }
28395
28396
28397 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28398 PyObject *resultobj = 0;
28399 wxDateTime *arg1 = (wxDateTime *) 0 ;
28400 wxString *arg2 = 0 ;
28401 int result;
28402 void *argp1 = 0 ;
28403 int res1 = 0 ;
28404 bool temp2 = false ;
28405 PyObject * obj0 = 0 ;
28406 PyObject * obj1 = 0 ;
28407 char * kwnames[] = {
28408 (char *) "self",(char *) "time", NULL
28409 };
28410
28411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28413 if (!SWIG_IsOK(res1)) {
28414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28415 }
28416 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28417 {
28418 arg2 = wxString_in_helper(obj1);
28419 if (arg2 == NULL) SWIG_fail;
28420 temp2 = true;
28421 }
28422 {
28423 PyThreadState* __tstate = wxPyBeginAllowThreads();
28424 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28425 wxPyEndAllowThreads(__tstate);
28426 if (PyErr_Occurred()) SWIG_fail;
28427 }
28428 resultobj = SWIG_From_int(static_cast< int >(result));
28429 {
28430 if (temp2)
28431 delete arg2;
28432 }
28433 return resultobj;
28434 fail:
28435 {
28436 if (temp2)
28437 delete arg2;
28438 }
28439 return NULL;
28440 }
28441
28442
28443 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28444 PyObject *resultobj = 0;
28445 wxDateTime *arg1 = (wxDateTime *) 0 ;
28446 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28447 wxString *arg2 = (wxString *) &arg2_defvalue ;
28448 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28449 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28450 wxString result;
28451 void *argp1 = 0 ;
28452 int res1 = 0 ;
28453 bool temp2 = false ;
28454 bool temp3 = false ;
28455 PyObject * obj0 = 0 ;
28456 PyObject * obj1 = 0 ;
28457 PyObject * obj2 = 0 ;
28458 char * kwnames[] = {
28459 (char *) "self",(char *) "format",(char *) "tz", NULL
28460 };
28461
28462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28464 if (!SWIG_IsOK(res1)) {
28465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28466 }
28467 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28468 if (obj1) {
28469 {
28470 arg2 = wxString_in_helper(obj1);
28471 if (arg2 == NULL) SWIG_fail;
28472 temp2 = true;
28473 }
28474 }
28475 if (obj2) {
28476 {
28477 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28478 temp3 = true;
28479 }
28480 }
28481 {
28482 PyThreadState* __tstate = wxPyBeginAllowThreads();
28483 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28484 wxPyEndAllowThreads(__tstate);
28485 if (PyErr_Occurred()) SWIG_fail;
28486 }
28487 {
28488 #if wxUSE_UNICODE
28489 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28490 #else
28491 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28492 #endif
28493 }
28494 {
28495 if (temp2)
28496 delete arg2;
28497 }
28498 {
28499 if (temp3) delete arg3;
28500 }
28501 return resultobj;
28502 fail:
28503 {
28504 if (temp2)
28505 delete arg2;
28506 }
28507 {
28508 if (temp3) delete arg3;
28509 }
28510 return NULL;
28511 }
28512
28513
28514 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28515 PyObject *resultobj = 0;
28516 wxDateTime *arg1 = (wxDateTime *) 0 ;
28517 wxString result;
28518 void *argp1 = 0 ;
28519 int res1 = 0 ;
28520 PyObject *swig_obj[1] ;
28521
28522 if (!args) SWIG_fail;
28523 swig_obj[0] = args;
28524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28525 if (!SWIG_IsOK(res1)) {
28526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28527 }
28528 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28529 {
28530 PyThreadState* __tstate = wxPyBeginAllowThreads();
28531 result = ((wxDateTime const *)arg1)->FormatDate();
28532 wxPyEndAllowThreads(__tstate);
28533 if (PyErr_Occurred()) SWIG_fail;
28534 }
28535 {
28536 #if wxUSE_UNICODE
28537 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28538 #else
28539 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28540 #endif
28541 }
28542 return resultobj;
28543 fail:
28544 return NULL;
28545 }
28546
28547
28548 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28549 PyObject *resultobj = 0;
28550 wxDateTime *arg1 = (wxDateTime *) 0 ;
28551 wxString result;
28552 void *argp1 = 0 ;
28553 int res1 = 0 ;
28554 PyObject *swig_obj[1] ;
28555
28556 if (!args) SWIG_fail;
28557 swig_obj[0] = args;
28558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28559 if (!SWIG_IsOK(res1)) {
28560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28561 }
28562 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28563 {
28564 PyThreadState* __tstate = wxPyBeginAllowThreads();
28565 result = ((wxDateTime const *)arg1)->FormatTime();
28566 wxPyEndAllowThreads(__tstate);
28567 if (PyErr_Occurred()) SWIG_fail;
28568 }
28569 {
28570 #if wxUSE_UNICODE
28571 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28572 #else
28573 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28574 #endif
28575 }
28576 return resultobj;
28577 fail:
28578 return NULL;
28579 }
28580
28581
28582 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28583 PyObject *resultobj = 0;
28584 wxDateTime *arg1 = (wxDateTime *) 0 ;
28585 wxString result;
28586 void *argp1 = 0 ;
28587 int res1 = 0 ;
28588 PyObject *swig_obj[1] ;
28589
28590 if (!args) SWIG_fail;
28591 swig_obj[0] = args;
28592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28593 if (!SWIG_IsOK(res1)) {
28594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28595 }
28596 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28597 {
28598 PyThreadState* __tstate = wxPyBeginAllowThreads();
28599 result = ((wxDateTime const *)arg1)->FormatISODate();
28600 wxPyEndAllowThreads(__tstate);
28601 if (PyErr_Occurred()) SWIG_fail;
28602 }
28603 {
28604 #if wxUSE_UNICODE
28605 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28606 #else
28607 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28608 #endif
28609 }
28610 return resultobj;
28611 fail:
28612 return NULL;
28613 }
28614
28615
28616 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28617 PyObject *resultobj = 0;
28618 wxDateTime *arg1 = (wxDateTime *) 0 ;
28619 wxString result;
28620 void *argp1 = 0 ;
28621 int res1 = 0 ;
28622 PyObject *swig_obj[1] ;
28623
28624 if (!args) SWIG_fail;
28625 swig_obj[0] = args;
28626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28627 if (!SWIG_IsOK(res1)) {
28628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28629 }
28630 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28631 {
28632 PyThreadState* __tstate = wxPyBeginAllowThreads();
28633 result = ((wxDateTime const *)arg1)->FormatISOTime();
28634 wxPyEndAllowThreads(__tstate);
28635 if (PyErr_Occurred()) SWIG_fail;
28636 }
28637 {
28638 #if wxUSE_UNICODE
28639 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28640 #else
28641 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28642 #endif
28643 }
28644 return resultobj;
28645 fail:
28646 return NULL;
28647 }
28648
28649
28650 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28651 PyObject *obj;
28652 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28653 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28654 return SWIG_Py_Void();
28655 }
28656
28657 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28658 return SWIG_Python_InitShadowInstance(args);
28659 }
28660
28661 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28662 PyObject *resultobj = 0;
28663 long arg1 ;
28664 wxTimeSpan result;
28665 long val1 ;
28666 int ecode1 = 0 ;
28667 PyObject * obj0 = 0 ;
28668 char * kwnames[] = {
28669 (char *) "ms", NULL
28670 };
28671
28672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28673 ecode1 = SWIG_AsVal_long(obj0, &val1);
28674 if (!SWIG_IsOK(ecode1)) {
28675 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28676 }
28677 arg1 = static_cast< long >(val1);
28678 {
28679 PyThreadState* __tstate = wxPyBeginAllowThreads();
28680 result = wxTimeSpan::Milliseconds(arg1);
28681 wxPyEndAllowThreads(__tstate);
28682 if (PyErr_Occurred()) SWIG_fail;
28683 }
28684 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28685 return resultobj;
28686 fail:
28687 return NULL;
28688 }
28689
28690
28691 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28692 PyObject *resultobj = 0;
28693 wxTimeSpan result;
28694
28695 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28696 {
28697 PyThreadState* __tstate = wxPyBeginAllowThreads();
28698 result = wxTimeSpan::Millisecond();
28699 wxPyEndAllowThreads(__tstate);
28700 if (PyErr_Occurred()) SWIG_fail;
28701 }
28702 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28703 return resultobj;
28704 fail:
28705 return NULL;
28706 }
28707
28708
28709 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28710 PyObject *resultobj = 0;
28711 long arg1 ;
28712 wxTimeSpan result;
28713 long val1 ;
28714 int ecode1 = 0 ;
28715 PyObject * obj0 = 0 ;
28716 char * kwnames[] = {
28717 (char *) "sec", NULL
28718 };
28719
28720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28721 ecode1 = SWIG_AsVal_long(obj0, &val1);
28722 if (!SWIG_IsOK(ecode1)) {
28723 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28724 }
28725 arg1 = static_cast< long >(val1);
28726 {
28727 PyThreadState* __tstate = wxPyBeginAllowThreads();
28728 result = wxTimeSpan::Seconds(arg1);
28729 wxPyEndAllowThreads(__tstate);
28730 if (PyErr_Occurred()) SWIG_fail;
28731 }
28732 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28733 return resultobj;
28734 fail:
28735 return NULL;
28736 }
28737
28738
28739 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28740 PyObject *resultobj = 0;
28741 wxTimeSpan result;
28742
28743 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28744 {
28745 PyThreadState* __tstate = wxPyBeginAllowThreads();
28746 result = wxTimeSpan::Second();
28747 wxPyEndAllowThreads(__tstate);
28748 if (PyErr_Occurred()) SWIG_fail;
28749 }
28750 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28751 return resultobj;
28752 fail:
28753 return NULL;
28754 }
28755
28756
28757 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28758 PyObject *resultobj = 0;
28759 long arg1 ;
28760 wxTimeSpan result;
28761 long val1 ;
28762 int ecode1 = 0 ;
28763 PyObject * obj0 = 0 ;
28764 char * kwnames[] = {
28765 (char *) "min", NULL
28766 };
28767
28768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28769 ecode1 = SWIG_AsVal_long(obj0, &val1);
28770 if (!SWIG_IsOK(ecode1)) {
28771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28772 }
28773 arg1 = static_cast< long >(val1);
28774 {
28775 PyThreadState* __tstate = wxPyBeginAllowThreads();
28776 result = wxTimeSpan::Minutes(arg1);
28777 wxPyEndAllowThreads(__tstate);
28778 if (PyErr_Occurred()) SWIG_fail;
28779 }
28780 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28781 return resultobj;
28782 fail:
28783 return NULL;
28784 }
28785
28786
28787 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28788 PyObject *resultobj = 0;
28789 wxTimeSpan result;
28790
28791 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28792 {
28793 PyThreadState* __tstate = wxPyBeginAllowThreads();
28794 result = wxTimeSpan::Minute();
28795 wxPyEndAllowThreads(__tstate);
28796 if (PyErr_Occurred()) SWIG_fail;
28797 }
28798 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28799 return resultobj;
28800 fail:
28801 return NULL;
28802 }
28803
28804
28805 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28806 PyObject *resultobj = 0;
28807 long arg1 ;
28808 wxTimeSpan result;
28809 long val1 ;
28810 int ecode1 = 0 ;
28811 PyObject * obj0 = 0 ;
28812 char * kwnames[] = {
28813 (char *) "hours", NULL
28814 };
28815
28816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28817 ecode1 = SWIG_AsVal_long(obj0, &val1);
28818 if (!SWIG_IsOK(ecode1)) {
28819 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28820 }
28821 arg1 = static_cast< long >(val1);
28822 {
28823 PyThreadState* __tstate = wxPyBeginAllowThreads();
28824 result = wxTimeSpan::Hours(arg1);
28825 wxPyEndAllowThreads(__tstate);
28826 if (PyErr_Occurred()) SWIG_fail;
28827 }
28828 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28829 return resultobj;
28830 fail:
28831 return NULL;
28832 }
28833
28834
28835 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28836 PyObject *resultobj = 0;
28837 wxTimeSpan result;
28838
28839 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28840 {
28841 PyThreadState* __tstate = wxPyBeginAllowThreads();
28842 result = wxTimeSpan::Hour();
28843 wxPyEndAllowThreads(__tstate);
28844 if (PyErr_Occurred()) SWIG_fail;
28845 }
28846 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28847 return resultobj;
28848 fail:
28849 return NULL;
28850 }
28851
28852
28853 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28854 PyObject *resultobj = 0;
28855 long arg1 ;
28856 wxTimeSpan result;
28857 long val1 ;
28858 int ecode1 = 0 ;
28859 PyObject * obj0 = 0 ;
28860 char * kwnames[] = {
28861 (char *) "days", NULL
28862 };
28863
28864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28865 ecode1 = SWIG_AsVal_long(obj0, &val1);
28866 if (!SWIG_IsOK(ecode1)) {
28867 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28868 }
28869 arg1 = static_cast< long >(val1);
28870 {
28871 PyThreadState* __tstate = wxPyBeginAllowThreads();
28872 result = wxTimeSpan::Days(arg1);
28873 wxPyEndAllowThreads(__tstate);
28874 if (PyErr_Occurred()) SWIG_fail;
28875 }
28876 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28877 return resultobj;
28878 fail:
28879 return NULL;
28880 }
28881
28882
28883 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28884 PyObject *resultobj = 0;
28885 wxTimeSpan result;
28886
28887 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28888 {
28889 PyThreadState* __tstate = wxPyBeginAllowThreads();
28890 result = wxTimeSpan::Day();
28891 wxPyEndAllowThreads(__tstate);
28892 if (PyErr_Occurred()) SWIG_fail;
28893 }
28894 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28895 return resultobj;
28896 fail:
28897 return NULL;
28898 }
28899
28900
28901 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28902 PyObject *resultobj = 0;
28903 long arg1 ;
28904 wxTimeSpan result;
28905 long val1 ;
28906 int ecode1 = 0 ;
28907 PyObject * obj0 = 0 ;
28908 char * kwnames[] = {
28909 (char *) "days", NULL
28910 };
28911
28912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28913 ecode1 = SWIG_AsVal_long(obj0, &val1);
28914 if (!SWIG_IsOK(ecode1)) {
28915 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28916 }
28917 arg1 = static_cast< long >(val1);
28918 {
28919 PyThreadState* __tstate = wxPyBeginAllowThreads();
28920 result = wxTimeSpan::Weeks(arg1);
28921 wxPyEndAllowThreads(__tstate);
28922 if (PyErr_Occurred()) SWIG_fail;
28923 }
28924 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28925 return resultobj;
28926 fail:
28927 return NULL;
28928 }
28929
28930
28931 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28932 PyObject *resultobj = 0;
28933 wxTimeSpan result;
28934
28935 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28936 {
28937 PyThreadState* __tstate = wxPyBeginAllowThreads();
28938 result = wxTimeSpan::Week();
28939 wxPyEndAllowThreads(__tstate);
28940 if (PyErr_Occurred()) SWIG_fail;
28941 }
28942 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28943 return resultobj;
28944 fail:
28945 return NULL;
28946 }
28947
28948
28949 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28950 PyObject *resultobj = 0;
28951 long arg1 = (long) 0 ;
28952 long arg2 = (long) 0 ;
28953 long arg3 = (long) 0 ;
28954 long arg4 = (long) 0 ;
28955 wxTimeSpan *result = 0 ;
28956 long val1 ;
28957 int ecode1 = 0 ;
28958 long val2 ;
28959 int ecode2 = 0 ;
28960 long val3 ;
28961 int ecode3 = 0 ;
28962 long val4 ;
28963 int ecode4 = 0 ;
28964 PyObject * obj0 = 0 ;
28965 PyObject * obj1 = 0 ;
28966 PyObject * obj2 = 0 ;
28967 PyObject * obj3 = 0 ;
28968 char * kwnames[] = {
28969 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28970 };
28971
28972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28973 if (obj0) {
28974 ecode1 = SWIG_AsVal_long(obj0, &val1);
28975 if (!SWIG_IsOK(ecode1)) {
28976 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28977 }
28978 arg1 = static_cast< long >(val1);
28979 }
28980 if (obj1) {
28981 ecode2 = SWIG_AsVal_long(obj1, &val2);
28982 if (!SWIG_IsOK(ecode2)) {
28983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28984 }
28985 arg2 = static_cast< long >(val2);
28986 }
28987 if (obj2) {
28988 ecode3 = SWIG_AsVal_long(obj2, &val3);
28989 if (!SWIG_IsOK(ecode3)) {
28990 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28991 }
28992 arg3 = static_cast< long >(val3);
28993 }
28994 if (obj3) {
28995 ecode4 = SWIG_AsVal_long(obj3, &val4);
28996 if (!SWIG_IsOK(ecode4)) {
28997 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28998 }
28999 arg4 = static_cast< long >(val4);
29000 }
29001 {
29002 PyThreadState* __tstate = wxPyBeginAllowThreads();
29003 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
29004 wxPyEndAllowThreads(__tstate);
29005 if (PyErr_Occurred()) SWIG_fail;
29006 }
29007 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
29008 return resultobj;
29009 fail:
29010 return NULL;
29011 }
29012
29013
29014 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29015 PyObject *resultobj = 0;
29016 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29017 void *argp1 = 0 ;
29018 int res1 = 0 ;
29019 PyObject *swig_obj[1] ;
29020
29021 if (!args) SWIG_fail;
29022 swig_obj[0] = args;
29023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29024 if (!SWIG_IsOK(res1)) {
29025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29026 }
29027 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29028 {
29029 PyThreadState* __tstate = wxPyBeginAllowThreads();
29030 delete arg1;
29031
29032 wxPyEndAllowThreads(__tstate);
29033 if (PyErr_Occurred()) SWIG_fail;
29034 }
29035 resultobj = SWIG_Py_Void();
29036 return resultobj;
29037 fail:
29038 return NULL;
29039 }
29040
29041
29042 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29043 PyObject *resultobj = 0;
29044 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29045 wxTimeSpan *arg2 = 0 ;
29046 wxTimeSpan *result = 0 ;
29047 void *argp1 = 0 ;
29048 int res1 = 0 ;
29049 void *argp2 = 0 ;
29050 int res2 = 0 ;
29051 PyObject * obj0 = 0 ;
29052 PyObject * obj1 = 0 ;
29053 char * kwnames[] = {
29054 (char *) "self",(char *) "diff", NULL
29055 };
29056
29057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29059 if (!SWIG_IsOK(res1)) {
29060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29061 }
29062 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29063 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29064 if (!SWIG_IsOK(res2)) {
29065 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29066 }
29067 if (!argp2) {
29068 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29069 }
29070 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29071 {
29072 PyThreadState* __tstate = wxPyBeginAllowThreads();
29073 {
29074 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
29075 result = (wxTimeSpan *) &_result_ref;
29076 }
29077 wxPyEndAllowThreads(__tstate);
29078 if (PyErr_Occurred()) SWIG_fail;
29079 }
29080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29081 return resultobj;
29082 fail:
29083 return NULL;
29084 }
29085
29086
29087 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29088 PyObject *resultobj = 0;
29089 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29090 wxTimeSpan *arg2 = 0 ;
29091 wxTimeSpan *result = 0 ;
29092 void *argp1 = 0 ;
29093 int res1 = 0 ;
29094 void *argp2 = 0 ;
29095 int res2 = 0 ;
29096 PyObject * obj0 = 0 ;
29097 PyObject * obj1 = 0 ;
29098 char * kwnames[] = {
29099 (char *) "self",(char *) "diff", NULL
29100 };
29101
29102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29104 if (!SWIG_IsOK(res1)) {
29105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29106 }
29107 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29108 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29109 if (!SWIG_IsOK(res2)) {
29110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29111 }
29112 if (!argp2) {
29113 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29114 }
29115 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29116 {
29117 PyThreadState* __tstate = wxPyBeginAllowThreads();
29118 {
29119 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29120 result = (wxTimeSpan *) &_result_ref;
29121 }
29122 wxPyEndAllowThreads(__tstate);
29123 if (PyErr_Occurred()) SWIG_fail;
29124 }
29125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29126 return resultobj;
29127 fail:
29128 return NULL;
29129 }
29130
29131
29132 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29133 PyObject *resultobj = 0;
29134 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29135 int arg2 ;
29136 wxTimeSpan *result = 0 ;
29137 void *argp1 = 0 ;
29138 int res1 = 0 ;
29139 int val2 ;
29140 int ecode2 = 0 ;
29141 PyObject * obj0 = 0 ;
29142 PyObject * obj1 = 0 ;
29143 char * kwnames[] = {
29144 (char *) "self",(char *) "n", NULL
29145 };
29146
29147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29149 if (!SWIG_IsOK(res1)) {
29150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29151 }
29152 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29153 ecode2 = SWIG_AsVal_int(obj1, &val2);
29154 if (!SWIG_IsOK(ecode2)) {
29155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29156 }
29157 arg2 = static_cast< int >(val2);
29158 {
29159 PyThreadState* __tstate = wxPyBeginAllowThreads();
29160 {
29161 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29162 result = (wxTimeSpan *) &_result_ref;
29163 }
29164 wxPyEndAllowThreads(__tstate);
29165 if (PyErr_Occurred()) SWIG_fail;
29166 }
29167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29168 return resultobj;
29169 fail:
29170 return NULL;
29171 }
29172
29173
29174 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29175 PyObject *resultobj = 0;
29176 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29177 wxTimeSpan *result = 0 ;
29178 void *argp1 = 0 ;
29179 int res1 = 0 ;
29180 PyObject *swig_obj[1] ;
29181
29182 if (!args) SWIG_fail;
29183 swig_obj[0] = args;
29184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29185 if (!SWIG_IsOK(res1)) {
29186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29187 }
29188 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29189 {
29190 PyThreadState* __tstate = wxPyBeginAllowThreads();
29191 {
29192 wxTimeSpan &_result_ref = (arg1)->Neg();
29193 result = (wxTimeSpan *) &_result_ref;
29194 }
29195 wxPyEndAllowThreads(__tstate);
29196 if (PyErr_Occurred()) SWIG_fail;
29197 }
29198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29199 return resultobj;
29200 fail:
29201 return NULL;
29202 }
29203
29204
29205 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29206 PyObject *resultobj = 0;
29207 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29208 wxTimeSpan result;
29209 void *argp1 = 0 ;
29210 int res1 = 0 ;
29211 PyObject *swig_obj[1] ;
29212
29213 if (!args) SWIG_fail;
29214 swig_obj[0] = args;
29215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29216 if (!SWIG_IsOK(res1)) {
29217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29218 }
29219 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29220 {
29221 PyThreadState* __tstate = wxPyBeginAllowThreads();
29222 result = ((wxTimeSpan const *)arg1)->Abs();
29223 wxPyEndAllowThreads(__tstate);
29224 if (PyErr_Occurred()) SWIG_fail;
29225 }
29226 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29227 return resultobj;
29228 fail:
29229 return NULL;
29230 }
29231
29232
29233 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29234 PyObject *resultobj = 0;
29235 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29236 wxTimeSpan *arg2 = 0 ;
29237 wxTimeSpan *result = 0 ;
29238 void *argp1 = 0 ;
29239 int res1 = 0 ;
29240 void *argp2 = 0 ;
29241 int res2 = 0 ;
29242 PyObject * obj0 = 0 ;
29243 PyObject * obj1 = 0 ;
29244 char * kwnames[] = {
29245 (char *) "self",(char *) "diff", NULL
29246 };
29247
29248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29250 if (!SWIG_IsOK(res1)) {
29251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29252 }
29253 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29254 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29255 if (!SWIG_IsOK(res2)) {
29256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29257 }
29258 if (!argp2) {
29259 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29260 }
29261 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29262 {
29263 PyThreadState* __tstate = wxPyBeginAllowThreads();
29264 {
29265 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29266 result = (wxTimeSpan *) &_result_ref;
29267 }
29268 wxPyEndAllowThreads(__tstate);
29269 if (PyErr_Occurred()) SWIG_fail;
29270 }
29271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29272 return resultobj;
29273 fail:
29274 return NULL;
29275 }
29276
29277
29278 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29279 PyObject *resultobj = 0;
29280 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29281 wxTimeSpan *arg2 = 0 ;
29282 wxTimeSpan *result = 0 ;
29283 void *argp1 = 0 ;
29284 int res1 = 0 ;
29285 void *argp2 = 0 ;
29286 int res2 = 0 ;
29287 PyObject * obj0 = 0 ;
29288 PyObject * obj1 = 0 ;
29289 char * kwnames[] = {
29290 (char *) "self",(char *) "diff", NULL
29291 };
29292
29293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29295 if (!SWIG_IsOK(res1)) {
29296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29297 }
29298 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29299 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29300 if (!SWIG_IsOK(res2)) {
29301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29302 }
29303 if (!argp2) {
29304 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29305 }
29306 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29307 {
29308 PyThreadState* __tstate = wxPyBeginAllowThreads();
29309 {
29310 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29311 result = (wxTimeSpan *) &_result_ref;
29312 }
29313 wxPyEndAllowThreads(__tstate);
29314 if (PyErr_Occurred()) SWIG_fail;
29315 }
29316 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29317 return resultobj;
29318 fail:
29319 return NULL;
29320 }
29321
29322
29323 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29324 PyObject *resultobj = 0;
29325 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29326 int arg2 ;
29327 wxTimeSpan *result = 0 ;
29328 void *argp1 = 0 ;
29329 int res1 = 0 ;
29330 int val2 ;
29331 int ecode2 = 0 ;
29332 PyObject * obj0 = 0 ;
29333 PyObject * obj1 = 0 ;
29334 char * kwnames[] = {
29335 (char *) "self",(char *) "n", NULL
29336 };
29337
29338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29340 if (!SWIG_IsOK(res1)) {
29341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29342 }
29343 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29344 ecode2 = SWIG_AsVal_int(obj1, &val2);
29345 if (!SWIG_IsOK(ecode2)) {
29346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29347 }
29348 arg2 = static_cast< int >(val2);
29349 {
29350 PyThreadState* __tstate = wxPyBeginAllowThreads();
29351 {
29352 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29353 result = (wxTimeSpan *) &_result_ref;
29354 }
29355 wxPyEndAllowThreads(__tstate);
29356 if (PyErr_Occurred()) SWIG_fail;
29357 }
29358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29359 return resultobj;
29360 fail:
29361 return NULL;
29362 }
29363
29364
29365 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29366 PyObject *resultobj = 0;
29367 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29368 wxTimeSpan *result = 0 ;
29369 void *argp1 = 0 ;
29370 int res1 = 0 ;
29371 PyObject *swig_obj[1] ;
29372
29373 if (!args) SWIG_fail;
29374 swig_obj[0] = args;
29375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29376 if (!SWIG_IsOK(res1)) {
29377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29378 }
29379 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29380 {
29381 PyThreadState* __tstate = wxPyBeginAllowThreads();
29382 {
29383 wxTimeSpan &_result_ref = (arg1)->operator -();
29384 result = (wxTimeSpan *) &_result_ref;
29385 }
29386 wxPyEndAllowThreads(__tstate);
29387 if (PyErr_Occurred()) SWIG_fail;
29388 }
29389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29390 return resultobj;
29391 fail:
29392 return NULL;
29393 }
29394
29395
29396 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29397 PyObject *resultobj = 0;
29398 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29399 wxTimeSpan *arg2 = 0 ;
29400 wxTimeSpan result;
29401 void *argp1 = 0 ;
29402 int res1 = 0 ;
29403 void *argp2 = 0 ;
29404 int res2 = 0 ;
29405 PyObject * obj0 = 0 ;
29406 PyObject * obj1 = 0 ;
29407 char * kwnames[] = {
29408 (char *) "self",(char *) "other", NULL
29409 };
29410
29411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29413 if (!SWIG_IsOK(res1)) {
29414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29415 }
29416 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29417 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29418 if (!SWIG_IsOK(res2)) {
29419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29420 }
29421 if (!argp2) {
29422 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29423 }
29424 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29425 {
29426 PyThreadState* __tstate = wxPyBeginAllowThreads();
29427 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29428 wxPyEndAllowThreads(__tstate);
29429 if (PyErr_Occurred()) SWIG_fail;
29430 }
29431 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29432 return resultobj;
29433 fail:
29434 return NULL;
29435 }
29436
29437
29438 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29439 PyObject *resultobj = 0;
29440 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29441 wxTimeSpan *arg2 = 0 ;
29442 wxTimeSpan result;
29443 void *argp1 = 0 ;
29444 int res1 = 0 ;
29445 void *argp2 = 0 ;
29446 int res2 = 0 ;
29447 PyObject * obj0 = 0 ;
29448 PyObject * obj1 = 0 ;
29449 char * kwnames[] = {
29450 (char *) "self",(char *) "other", NULL
29451 };
29452
29453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29455 if (!SWIG_IsOK(res1)) {
29456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29457 }
29458 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29459 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29460 if (!SWIG_IsOK(res2)) {
29461 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29462 }
29463 if (!argp2) {
29464 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29465 }
29466 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29467 {
29468 PyThreadState* __tstate = wxPyBeginAllowThreads();
29469 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29470 wxPyEndAllowThreads(__tstate);
29471 if (PyErr_Occurred()) SWIG_fail;
29472 }
29473 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29474 return resultobj;
29475 fail:
29476 return NULL;
29477 }
29478
29479
29480 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29481 PyObject *resultobj = 0;
29482 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29483 int arg2 ;
29484 wxTimeSpan result;
29485 void *argp1 = 0 ;
29486 int res1 = 0 ;
29487 int val2 ;
29488 int ecode2 = 0 ;
29489 PyObject * obj0 = 0 ;
29490 PyObject * obj1 = 0 ;
29491 char * kwnames[] = {
29492 (char *) "self",(char *) "n", NULL
29493 };
29494
29495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29497 if (!SWIG_IsOK(res1)) {
29498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29499 }
29500 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29501 ecode2 = SWIG_AsVal_int(obj1, &val2);
29502 if (!SWIG_IsOK(ecode2)) {
29503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29504 }
29505 arg2 = static_cast< int >(val2);
29506 {
29507 PyThreadState* __tstate = wxPyBeginAllowThreads();
29508 result = wxTimeSpan___mul__(arg1,arg2);
29509 wxPyEndAllowThreads(__tstate);
29510 if (PyErr_Occurred()) SWIG_fail;
29511 }
29512 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29513 return resultobj;
29514 fail:
29515 return NULL;
29516 }
29517
29518
29519 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29520 PyObject *resultobj = 0;
29521 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29522 int arg2 ;
29523 wxTimeSpan result;
29524 void *argp1 = 0 ;
29525 int res1 = 0 ;
29526 int val2 ;
29527 int ecode2 = 0 ;
29528 PyObject * obj0 = 0 ;
29529 PyObject * obj1 = 0 ;
29530 char * kwnames[] = {
29531 (char *) "self",(char *) "n", NULL
29532 };
29533
29534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29536 if (!SWIG_IsOK(res1)) {
29537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29538 }
29539 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29540 ecode2 = SWIG_AsVal_int(obj1, &val2);
29541 if (!SWIG_IsOK(ecode2)) {
29542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29543 }
29544 arg2 = static_cast< int >(val2);
29545 {
29546 PyThreadState* __tstate = wxPyBeginAllowThreads();
29547 result = wxTimeSpan___rmul__(arg1,arg2);
29548 wxPyEndAllowThreads(__tstate);
29549 if (PyErr_Occurred()) SWIG_fail;
29550 }
29551 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29552 return resultobj;
29553 fail:
29554 return NULL;
29555 }
29556
29557
29558 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29559 PyObject *resultobj = 0;
29560 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29561 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29562 bool result;
29563 void *argp1 = 0 ;
29564 int res1 = 0 ;
29565 void *argp2 = 0 ;
29566 int res2 = 0 ;
29567 PyObject * obj0 = 0 ;
29568 PyObject * obj1 = 0 ;
29569 char * kwnames[] = {
29570 (char *) "self",(char *) "other", NULL
29571 };
29572
29573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29575 if (!SWIG_IsOK(res1)) {
29576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29577 }
29578 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29579 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29580 if (!SWIG_IsOK(res2)) {
29581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29582 }
29583 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29584 {
29585 PyThreadState* __tstate = wxPyBeginAllowThreads();
29586 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29587 wxPyEndAllowThreads(__tstate);
29588 if (PyErr_Occurred()) SWIG_fail;
29589 }
29590 {
29591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29592 }
29593 return resultobj;
29594 fail:
29595 return NULL;
29596 }
29597
29598
29599 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29600 PyObject *resultobj = 0;
29601 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29602 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29603 bool result;
29604 void *argp1 = 0 ;
29605 int res1 = 0 ;
29606 void *argp2 = 0 ;
29607 int res2 = 0 ;
29608 PyObject * obj0 = 0 ;
29609 PyObject * obj1 = 0 ;
29610 char * kwnames[] = {
29611 (char *) "self",(char *) "other", NULL
29612 };
29613
29614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29616 if (!SWIG_IsOK(res1)) {
29617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29618 }
29619 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29620 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29621 if (!SWIG_IsOK(res2)) {
29622 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29623 }
29624 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29625 {
29626 PyThreadState* __tstate = wxPyBeginAllowThreads();
29627 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29628 wxPyEndAllowThreads(__tstate);
29629 if (PyErr_Occurred()) SWIG_fail;
29630 }
29631 {
29632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29633 }
29634 return resultobj;
29635 fail:
29636 return NULL;
29637 }
29638
29639
29640 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29641 PyObject *resultobj = 0;
29642 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29643 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29644 bool result;
29645 void *argp1 = 0 ;
29646 int res1 = 0 ;
29647 void *argp2 = 0 ;
29648 int res2 = 0 ;
29649 PyObject * obj0 = 0 ;
29650 PyObject * obj1 = 0 ;
29651 char * kwnames[] = {
29652 (char *) "self",(char *) "other", NULL
29653 };
29654
29655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29657 if (!SWIG_IsOK(res1)) {
29658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29659 }
29660 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29661 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29662 if (!SWIG_IsOK(res2)) {
29663 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29664 }
29665 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29666 {
29667 PyThreadState* __tstate = wxPyBeginAllowThreads();
29668 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29669 wxPyEndAllowThreads(__tstate);
29670 if (PyErr_Occurred()) SWIG_fail;
29671 }
29672 {
29673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29674 }
29675 return resultobj;
29676 fail:
29677 return NULL;
29678 }
29679
29680
29681 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29682 PyObject *resultobj = 0;
29683 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29684 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29685 bool result;
29686 void *argp1 = 0 ;
29687 int res1 = 0 ;
29688 void *argp2 = 0 ;
29689 int res2 = 0 ;
29690 PyObject * obj0 = 0 ;
29691 PyObject * obj1 = 0 ;
29692 char * kwnames[] = {
29693 (char *) "self",(char *) "other", NULL
29694 };
29695
29696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29698 if (!SWIG_IsOK(res1)) {
29699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29700 }
29701 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29702 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29703 if (!SWIG_IsOK(res2)) {
29704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29705 }
29706 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29707 {
29708 PyThreadState* __tstate = wxPyBeginAllowThreads();
29709 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29710 wxPyEndAllowThreads(__tstate);
29711 if (PyErr_Occurred()) SWIG_fail;
29712 }
29713 {
29714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29715 }
29716 return resultobj;
29717 fail:
29718 return NULL;
29719 }
29720
29721
29722 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29723 PyObject *resultobj = 0;
29724 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29725 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29726 bool result;
29727 void *argp1 = 0 ;
29728 int res1 = 0 ;
29729 void *argp2 = 0 ;
29730 int res2 = 0 ;
29731 PyObject * obj0 = 0 ;
29732 PyObject * obj1 = 0 ;
29733 char * kwnames[] = {
29734 (char *) "self",(char *) "other", NULL
29735 };
29736
29737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29739 if (!SWIG_IsOK(res1)) {
29740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29741 }
29742 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29743 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29744 if (!SWIG_IsOK(res2)) {
29745 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29746 }
29747 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29748 {
29749 PyThreadState* __tstate = wxPyBeginAllowThreads();
29750 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29751 wxPyEndAllowThreads(__tstate);
29752 if (PyErr_Occurred()) SWIG_fail;
29753 }
29754 {
29755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29756 }
29757 return resultobj;
29758 fail:
29759 return NULL;
29760 }
29761
29762
29763 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29764 PyObject *resultobj = 0;
29765 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29766 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29767 bool result;
29768 void *argp1 = 0 ;
29769 int res1 = 0 ;
29770 void *argp2 = 0 ;
29771 int res2 = 0 ;
29772 PyObject * obj0 = 0 ;
29773 PyObject * obj1 = 0 ;
29774 char * kwnames[] = {
29775 (char *) "self",(char *) "other", NULL
29776 };
29777
29778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29780 if (!SWIG_IsOK(res1)) {
29781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29782 }
29783 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29784 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29785 if (!SWIG_IsOK(res2)) {
29786 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29787 }
29788 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29789 {
29790 PyThreadState* __tstate = wxPyBeginAllowThreads();
29791 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29792 wxPyEndAllowThreads(__tstate);
29793 if (PyErr_Occurred()) SWIG_fail;
29794 }
29795 {
29796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29797 }
29798 return resultobj;
29799 fail:
29800 return NULL;
29801 }
29802
29803
29804 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29805 PyObject *resultobj = 0;
29806 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29807 bool result;
29808 void *argp1 = 0 ;
29809 int res1 = 0 ;
29810 PyObject *swig_obj[1] ;
29811
29812 if (!args) SWIG_fail;
29813 swig_obj[0] = args;
29814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29815 if (!SWIG_IsOK(res1)) {
29816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29817 }
29818 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29819 {
29820 PyThreadState* __tstate = wxPyBeginAllowThreads();
29821 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29822 wxPyEndAllowThreads(__tstate);
29823 if (PyErr_Occurred()) SWIG_fail;
29824 }
29825 {
29826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29827 }
29828 return resultobj;
29829 fail:
29830 return NULL;
29831 }
29832
29833
29834 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29835 PyObject *resultobj = 0;
29836 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29837 bool result;
29838 void *argp1 = 0 ;
29839 int res1 = 0 ;
29840 PyObject *swig_obj[1] ;
29841
29842 if (!args) SWIG_fail;
29843 swig_obj[0] = args;
29844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29845 if (!SWIG_IsOK(res1)) {
29846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29847 }
29848 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29849 {
29850 PyThreadState* __tstate = wxPyBeginAllowThreads();
29851 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29852 wxPyEndAllowThreads(__tstate);
29853 if (PyErr_Occurred()) SWIG_fail;
29854 }
29855 {
29856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29857 }
29858 return resultobj;
29859 fail:
29860 return NULL;
29861 }
29862
29863
29864 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29865 PyObject *resultobj = 0;
29866 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29867 bool result;
29868 void *argp1 = 0 ;
29869 int res1 = 0 ;
29870 PyObject *swig_obj[1] ;
29871
29872 if (!args) SWIG_fail;
29873 swig_obj[0] = args;
29874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29875 if (!SWIG_IsOK(res1)) {
29876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29877 }
29878 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29879 {
29880 PyThreadState* __tstate = wxPyBeginAllowThreads();
29881 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29882 wxPyEndAllowThreads(__tstate);
29883 if (PyErr_Occurred()) SWIG_fail;
29884 }
29885 {
29886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29887 }
29888 return resultobj;
29889 fail:
29890 return NULL;
29891 }
29892
29893
29894 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29895 PyObject *resultobj = 0;
29896 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29897 wxTimeSpan *arg2 = 0 ;
29898 bool result;
29899 void *argp1 = 0 ;
29900 int res1 = 0 ;
29901 void *argp2 = 0 ;
29902 int res2 = 0 ;
29903 PyObject * obj0 = 0 ;
29904 PyObject * obj1 = 0 ;
29905 char * kwnames[] = {
29906 (char *) "self",(char *) "ts", NULL
29907 };
29908
29909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29911 if (!SWIG_IsOK(res1)) {
29912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29913 }
29914 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29915 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29916 if (!SWIG_IsOK(res2)) {
29917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29918 }
29919 if (!argp2) {
29920 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29921 }
29922 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29923 {
29924 PyThreadState* __tstate = wxPyBeginAllowThreads();
29925 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29926 wxPyEndAllowThreads(__tstate);
29927 if (PyErr_Occurred()) SWIG_fail;
29928 }
29929 {
29930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29931 }
29932 return resultobj;
29933 fail:
29934 return NULL;
29935 }
29936
29937
29938 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29939 PyObject *resultobj = 0;
29940 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29941 wxTimeSpan *arg2 = 0 ;
29942 bool result;
29943 void *argp1 = 0 ;
29944 int res1 = 0 ;
29945 void *argp2 = 0 ;
29946 int res2 = 0 ;
29947 PyObject * obj0 = 0 ;
29948 PyObject * obj1 = 0 ;
29949 char * kwnames[] = {
29950 (char *) "self",(char *) "ts", NULL
29951 };
29952
29953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29955 if (!SWIG_IsOK(res1)) {
29956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29957 }
29958 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29959 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29960 if (!SWIG_IsOK(res2)) {
29961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29962 }
29963 if (!argp2) {
29964 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29965 }
29966 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29967 {
29968 PyThreadState* __tstate = wxPyBeginAllowThreads();
29969 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29970 wxPyEndAllowThreads(__tstate);
29971 if (PyErr_Occurred()) SWIG_fail;
29972 }
29973 {
29974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29975 }
29976 return resultobj;
29977 fail:
29978 return NULL;
29979 }
29980
29981
29982 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29983 PyObject *resultobj = 0;
29984 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29985 wxTimeSpan *arg2 = 0 ;
29986 bool result;
29987 void *argp1 = 0 ;
29988 int res1 = 0 ;
29989 void *argp2 = 0 ;
29990 int res2 = 0 ;
29991 PyObject * obj0 = 0 ;
29992 PyObject * obj1 = 0 ;
29993 char * kwnames[] = {
29994 (char *) "self",(char *) "t", NULL
29995 };
29996
29997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29999 if (!SWIG_IsOK(res1)) {
30000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30001 }
30002 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30003 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
30004 if (!SWIG_IsOK(res2)) {
30005 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30006 }
30007 if (!argp2) {
30008 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30009 }
30010 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
30011 {
30012 PyThreadState* __tstate = wxPyBeginAllowThreads();
30013 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
30014 wxPyEndAllowThreads(__tstate);
30015 if (PyErr_Occurred()) SWIG_fail;
30016 }
30017 {
30018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30019 }
30020 return resultobj;
30021 fail:
30022 return NULL;
30023 }
30024
30025
30026 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30027 PyObject *resultobj = 0;
30028 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30029 int result;
30030 void *argp1 = 0 ;
30031 int res1 = 0 ;
30032 PyObject *swig_obj[1] ;
30033
30034 if (!args) SWIG_fail;
30035 swig_obj[0] = args;
30036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30037 if (!SWIG_IsOK(res1)) {
30038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30039 }
30040 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30041 {
30042 PyThreadState* __tstate = wxPyBeginAllowThreads();
30043 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
30044 wxPyEndAllowThreads(__tstate);
30045 if (PyErr_Occurred()) SWIG_fail;
30046 }
30047 resultobj = SWIG_From_int(static_cast< int >(result));
30048 return resultobj;
30049 fail:
30050 return NULL;
30051 }
30052
30053
30054 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30055 PyObject *resultobj = 0;
30056 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30057 int result;
30058 void *argp1 = 0 ;
30059 int res1 = 0 ;
30060 PyObject *swig_obj[1] ;
30061
30062 if (!args) SWIG_fail;
30063 swig_obj[0] = args;
30064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30065 if (!SWIG_IsOK(res1)) {
30066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30067 }
30068 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30069 {
30070 PyThreadState* __tstate = wxPyBeginAllowThreads();
30071 result = (int)((wxTimeSpan const *)arg1)->GetDays();
30072 wxPyEndAllowThreads(__tstate);
30073 if (PyErr_Occurred()) SWIG_fail;
30074 }
30075 resultobj = SWIG_From_int(static_cast< int >(result));
30076 return resultobj;
30077 fail:
30078 return NULL;
30079 }
30080
30081
30082 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30083 PyObject *resultobj = 0;
30084 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30085 int result;
30086 void *argp1 = 0 ;
30087 int res1 = 0 ;
30088 PyObject *swig_obj[1] ;
30089
30090 if (!args) SWIG_fail;
30091 swig_obj[0] = args;
30092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30093 if (!SWIG_IsOK(res1)) {
30094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30095 }
30096 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30097 {
30098 PyThreadState* __tstate = wxPyBeginAllowThreads();
30099 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30100 wxPyEndAllowThreads(__tstate);
30101 if (PyErr_Occurred()) SWIG_fail;
30102 }
30103 resultobj = SWIG_From_int(static_cast< int >(result));
30104 return resultobj;
30105 fail:
30106 return NULL;
30107 }
30108
30109
30110 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30111 PyObject *resultobj = 0;
30112 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30113 int result;
30114 void *argp1 = 0 ;
30115 int res1 = 0 ;
30116 PyObject *swig_obj[1] ;
30117
30118 if (!args) SWIG_fail;
30119 swig_obj[0] = args;
30120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30121 if (!SWIG_IsOK(res1)) {
30122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30123 }
30124 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30125 {
30126 PyThreadState* __tstate = wxPyBeginAllowThreads();
30127 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30128 wxPyEndAllowThreads(__tstate);
30129 if (PyErr_Occurred()) SWIG_fail;
30130 }
30131 resultobj = SWIG_From_int(static_cast< int >(result));
30132 return resultobj;
30133 fail:
30134 return NULL;
30135 }
30136
30137
30138 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30139 PyObject *resultobj = 0;
30140 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30141 wxLongLong result;
30142 void *argp1 = 0 ;
30143 int res1 = 0 ;
30144 PyObject *swig_obj[1] ;
30145
30146 if (!args) SWIG_fail;
30147 swig_obj[0] = args;
30148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30149 if (!SWIG_IsOK(res1)) {
30150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30151 }
30152 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30153 {
30154 PyThreadState* __tstate = wxPyBeginAllowThreads();
30155 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30156 wxPyEndAllowThreads(__tstate);
30157 if (PyErr_Occurred()) SWIG_fail;
30158 }
30159 {
30160 PyObject *hi, *lo, *shifter, *shifted;
30161 hi = PyLong_FromLong( (&result)->GetHi() );
30162 lo = PyLong_FromLong( (&result)->GetLo() );
30163 shifter = PyLong_FromLong(32);
30164 shifted = PyNumber_Lshift(hi, shifter);
30165 resultobj = PyNumber_Or(shifted, lo);
30166 Py_DECREF(hi);
30167 Py_DECREF(lo);
30168 Py_DECREF(shifter);
30169 Py_DECREF(shifted);
30170 }
30171 return resultobj;
30172 fail:
30173 return NULL;
30174 }
30175
30176
30177 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30178 PyObject *resultobj = 0;
30179 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30180 wxLongLong result;
30181 void *argp1 = 0 ;
30182 int res1 = 0 ;
30183 PyObject *swig_obj[1] ;
30184
30185 if (!args) SWIG_fail;
30186 swig_obj[0] = args;
30187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30188 if (!SWIG_IsOK(res1)) {
30189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30190 }
30191 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30192 {
30193 PyThreadState* __tstate = wxPyBeginAllowThreads();
30194 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30195 wxPyEndAllowThreads(__tstate);
30196 if (PyErr_Occurred()) SWIG_fail;
30197 }
30198 {
30199 PyObject *hi, *lo, *shifter, *shifted;
30200 hi = PyLong_FromLong( (&result)->GetHi() );
30201 lo = PyLong_FromLong( (&result)->GetLo() );
30202 shifter = PyLong_FromLong(32);
30203 shifted = PyNumber_Lshift(hi, shifter);
30204 resultobj = PyNumber_Or(shifted, lo);
30205 Py_DECREF(hi);
30206 Py_DECREF(lo);
30207 Py_DECREF(shifter);
30208 Py_DECREF(shifted);
30209 }
30210 return resultobj;
30211 fail:
30212 return NULL;
30213 }
30214
30215
30216 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30217 PyObject *resultobj = 0;
30218 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30219 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30220 wxString *arg2 = (wxString *) &arg2_defvalue ;
30221 wxString result;
30222 void *argp1 = 0 ;
30223 int res1 = 0 ;
30224 bool temp2 = false ;
30225 PyObject * obj0 = 0 ;
30226 PyObject * obj1 = 0 ;
30227 char * kwnames[] = {
30228 (char *) "self",(char *) "format", NULL
30229 };
30230
30231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30233 if (!SWIG_IsOK(res1)) {
30234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30235 }
30236 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30237 if (obj1) {
30238 {
30239 arg2 = wxString_in_helper(obj1);
30240 if (arg2 == NULL) SWIG_fail;
30241 temp2 = true;
30242 }
30243 }
30244 {
30245 PyThreadState* __tstate = wxPyBeginAllowThreads();
30246 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30247 wxPyEndAllowThreads(__tstate);
30248 if (PyErr_Occurred()) SWIG_fail;
30249 }
30250 {
30251 #if wxUSE_UNICODE
30252 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30253 #else
30254 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30255 #endif
30256 }
30257 {
30258 if (temp2)
30259 delete arg2;
30260 }
30261 return resultobj;
30262 fail:
30263 {
30264 if (temp2)
30265 delete arg2;
30266 }
30267 return NULL;
30268 }
30269
30270
30271 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30272 PyObject *obj;
30273 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30274 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30275 return SWIG_Py_Void();
30276 }
30277
30278 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30279 return SWIG_Python_InitShadowInstance(args);
30280 }
30281
30282 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30283 PyObject *resultobj = 0;
30284 int arg1 = (int) 0 ;
30285 int arg2 = (int) 0 ;
30286 int arg3 = (int) 0 ;
30287 int arg4 = (int) 0 ;
30288 wxDateSpan *result = 0 ;
30289 int val1 ;
30290 int ecode1 = 0 ;
30291 int val2 ;
30292 int ecode2 = 0 ;
30293 int val3 ;
30294 int ecode3 = 0 ;
30295 int val4 ;
30296 int ecode4 = 0 ;
30297 PyObject * obj0 = 0 ;
30298 PyObject * obj1 = 0 ;
30299 PyObject * obj2 = 0 ;
30300 PyObject * obj3 = 0 ;
30301 char * kwnames[] = {
30302 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30303 };
30304
30305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30306 if (obj0) {
30307 ecode1 = SWIG_AsVal_int(obj0, &val1);
30308 if (!SWIG_IsOK(ecode1)) {
30309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30310 }
30311 arg1 = static_cast< int >(val1);
30312 }
30313 if (obj1) {
30314 ecode2 = SWIG_AsVal_int(obj1, &val2);
30315 if (!SWIG_IsOK(ecode2)) {
30316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30317 }
30318 arg2 = static_cast< int >(val2);
30319 }
30320 if (obj2) {
30321 ecode3 = SWIG_AsVal_int(obj2, &val3);
30322 if (!SWIG_IsOK(ecode3)) {
30323 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30324 }
30325 arg3 = static_cast< int >(val3);
30326 }
30327 if (obj3) {
30328 ecode4 = SWIG_AsVal_int(obj3, &val4);
30329 if (!SWIG_IsOK(ecode4)) {
30330 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30331 }
30332 arg4 = static_cast< int >(val4);
30333 }
30334 {
30335 PyThreadState* __tstate = wxPyBeginAllowThreads();
30336 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30337 wxPyEndAllowThreads(__tstate);
30338 if (PyErr_Occurred()) SWIG_fail;
30339 }
30340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30341 return resultobj;
30342 fail:
30343 return NULL;
30344 }
30345
30346
30347 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30348 PyObject *resultobj = 0;
30349 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30350 void *argp1 = 0 ;
30351 int res1 = 0 ;
30352 PyObject *swig_obj[1] ;
30353
30354 if (!args) SWIG_fail;
30355 swig_obj[0] = args;
30356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30357 if (!SWIG_IsOK(res1)) {
30358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30359 }
30360 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30361 {
30362 PyThreadState* __tstate = wxPyBeginAllowThreads();
30363 delete arg1;
30364
30365 wxPyEndAllowThreads(__tstate);
30366 if (PyErr_Occurred()) SWIG_fail;
30367 }
30368 resultobj = SWIG_Py_Void();
30369 return resultobj;
30370 fail:
30371 return NULL;
30372 }
30373
30374
30375 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30376 PyObject *resultobj = 0;
30377 int arg1 ;
30378 wxDateSpan result;
30379 int val1 ;
30380 int ecode1 = 0 ;
30381 PyObject * obj0 = 0 ;
30382 char * kwnames[] = {
30383 (char *) "days", NULL
30384 };
30385
30386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30387 ecode1 = SWIG_AsVal_int(obj0, &val1);
30388 if (!SWIG_IsOK(ecode1)) {
30389 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30390 }
30391 arg1 = static_cast< int >(val1);
30392 {
30393 PyThreadState* __tstate = wxPyBeginAllowThreads();
30394 result = wxDateSpan::Days(arg1);
30395 wxPyEndAllowThreads(__tstate);
30396 if (PyErr_Occurred()) SWIG_fail;
30397 }
30398 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30399 return resultobj;
30400 fail:
30401 return NULL;
30402 }
30403
30404
30405 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30406 PyObject *resultobj = 0;
30407 wxDateSpan result;
30408
30409 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30410 {
30411 PyThreadState* __tstate = wxPyBeginAllowThreads();
30412 result = wxDateSpan::Day();
30413 wxPyEndAllowThreads(__tstate);
30414 if (PyErr_Occurred()) SWIG_fail;
30415 }
30416 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30417 return resultobj;
30418 fail:
30419 return NULL;
30420 }
30421
30422
30423 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30424 PyObject *resultobj = 0;
30425 int arg1 ;
30426 wxDateSpan result;
30427 int val1 ;
30428 int ecode1 = 0 ;
30429 PyObject * obj0 = 0 ;
30430 char * kwnames[] = {
30431 (char *) "weeks", NULL
30432 };
30433
30434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30435 ecode1 = SWIG_AsVal_int(obj0, &val1);
30436 if (!SWIG_IsOK(ecode1)) {
30437 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30438 }
30439 arg1 = static_cast< int >(val1);
30440 {
30441 PyThreadState* __tstate = wxPyBeginAllowThreads();
30442 result = wxDateSpan::Weeks(arg1);
30443 wxPyEndAllowThreads(__tstate);
30444 if (PyErr_Occurred()) SWIG_fail;
30445 }
30446 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30447 return resultobj;
30448 fail:
30449 return NULL;
30450 }
30451
30452
30453 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30454 PyObject *resultobj = 0;
30455 wxDateSpan result;
30456
30457 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30458 {
30459 PyThreadState* __tstate = wxPyBeginAllowThreads();
30460 result = wxDateSpan::Week();
30461 wxPyEndAllowThreads(__tstate);
30462 if (PyErr_Occurred()) SWIG_fail;
30463 }
30464 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30465 return resultobj;
30466 fail:
30467 return NULL;
30468 }
30469
30470
30471 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30472 PyObject *resultobj = 0;
30473 int arg1 ;
30474 wxDateSpan result;
30475 int val1 ;
30476 int ecode1 = 0 ;
30477 PyObject * obj0 = 0 ;
30478 char * kwnames[] = {
30479 (char *) "mon", NULL
30480 };
30481
30482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30483 ecode1 = SWIG_AsVal_int(obj0, &val1);
30484 if (!SWIG_IsOK(ecode1)) {
30485 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30486 }
30487 arg1 = static_cast< int >(val1);
30488 {
30489 PyThreadState* __tstate = wxPyBeginAllowThreads();
30490 result = wxDateSpan::Months(arg1);
30491 wxPyEndAllowThreads(__tstate);
30492 if (PyErr_Occurred()) SWIG_fail;
30493 }
30494 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30495 return resultobj;
30496 fail:
30497 return NULL;
30498 }
30499
30500
30501 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30502 PyObject *resultobj = 0;
30503 wxDateSpan result;
30504
30505 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30506 {
30507 PyThreadState* __tstate = wxPyBeginAllowThreads();
30508 result = wxDateSpan::Month();
30509 wxPyEndAllowThreads(__tstate);
30510 if (PyErr_Occurred()) SWIG_fail;
30511 }
30512 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30513 return resultobj;
30514 fail:
30515 return NULL;
30516 }
30517
30518
30519 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30520 PyObject *resultobj = 0;
30521 int arg1 ;
30522 wxDateSpan result;
30523 int val1 ;
30524 int ecode1 = 0 ;
30525 PyObject * obj0 = 0 ;
30526 char * kwnames[] = {
30527 (char *) "years", NULL
30528 };
30529
30530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30531 ecode1 = SWIG_AsVal_int(obj0, &val1);
30532 if (!SWIG_IsOK(ecode1)) {
30533 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30534 }
30535 arg1 = static_cast< int >(val1);
30536 {
30537 PyThreadState* __tstate = wxPyBeginAllowThreads();
30538 result = wxDateSpan::Years(arg1);
30539 wxPyEndAllowThreads(__tstate);
30540 if (PyErr_Occurred()) SWIG_fail;
30541 }
30542 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30543 return resultobj;
30544 fail:
30545 return NULL;
30546 }
30547
30548
30549 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30550 PyObject *resultobj = 0;
30551 wxDateSpan result;
30552
30553 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30554 {
30555 PyThreadState* __tstate = wxPyBeginAllowThreads();
30556 result = wxDateSpan::Year();
30557 wxPyEndAllowThreads(__tstate);
30558 if (PyErr_Occurred()) SWIG_fail;
30559 }
30560 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30561 return resultobj;
30562 fail:
30563 return NULL;
30564 }
30565
30566
30567 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30568 PyObject *resultobj = 0;
30569 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30570 int arg2 ;
30571 wxDateSpan *result = 0 ;
30572 void *argp1 = 0 ;
30573 int res1 = 0 ;
30574 int val2 ;
30575 int ecode2 = 0 ;
30576 PyObject * obj0 = 0 ;
30577 PyObject * obj1 = 0 ;
30578 char * kwnames[] = {
30579 (char *) "self",(char *) "n", NULL
30580 };
30581
30582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30584 if (!SWIG_IsOK(res1)) {
30585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30586 }
30587 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30588 ecode2 = SWIG_AsVal_int(obj1, &val2);
30589 if (!SWIG_IsOK(ecode2)) {
30590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30591 }
30592 arg2 = static_cast< int >(val2);
30593 {
30594 PyThreadState* __tstate = wxPyBeginAllowThreads();
30595 {
30596 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30597 result = (wxDateSpan *) &_result_ref;
30598 }
30599 wxPyEndAllowThreads(__tstate);
30600 if (PyErr_Occurred()) SWIG_fail;
30601 }
30602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30603 return resultobj;
30604 fail:
30605 return NULL;
30606 }
30607
30608
30609 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30610 PyObject *resultobj = 0;
30611 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30612 int arg2 ;
30613 wxDateSpan *result = 0 ;
30614 void *argp1 = 0 ;
30615 int res1 = 0 ;
30616 int val2 ;
30617 int ecode2 = 0 ;
30618 PyObject * obj0 = 0 ;
30619 PyObject * obj1 = 0 ;
30620 char * kwnames[] = {
30621 (char *) "self",(char *) "n", NULL
30622 };
30623
30624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30626 if (!SWIG_IsOK(res1)) {
30627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30628 }
30629 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30630 ecode2 = SWIG_AsVal_int(obj1, &val2);
30631 if (!SWIG_IsOK(ecode2)) {
30632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30633 }
30634 arg2 = static_cast< int >(val2);
30635 {
30636 PyThreadState* __tstate = wxPyBeginAllowThreads();
30637 {
30638 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30639 result = (wxDateSpan *) &_result_ref;
30640 }
30641 wxPyEndAllowThreads(__tstate);
30642 if (PyErr_Occurred()) SWIG_fail;
30643 }
30644 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30645 return resultobj;
30646 fail:
30647 return NULL;
30648 }
30649
30650
30651 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30652 PyObject *resultobj = 0;
30653 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30654 int arg2 ;
30655 wxDateSpan *result = 0 ;
30656 void *argp1 = 0 ;
30657 int res1 = 0 ;
30658 int val2 ;
30659 int ecode2 = 0 ;
30660 PyObject * obj0 = 0 ;
30661 PyObject * obj1 = 0 ;
30662 char * kwnames[] = {
30663 (char *) "self",(char *) "n", NULL
30664 };
30665
30666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30668 if (!SWIG_IsOK(res1)) {
30669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30670 }
30671 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30672 ecode2 = SWIG_AsVal_int(obj1, &val2);
30673 if (!SWIG_IsOK(ecode2)) {
30674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30675 }
30676 arg2 = static_cast< int >(val2);
30677 {
30678 PyThreadState* __tstate = wxPyBeginAllowThreads();
30679 {
30680 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30681 result = (wxDateSpan *) &_result_ref;
30682 }
30683 wxPyEndAllowThreads(__tstate);
30684 if (PyErr_Occurred()) SWIG_fail;
30685 }
30686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30687 return resultobj;
30688 fail:
30689 return NULL;
30690 }
30691
30692
30693 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30694 PyObject *resultobj = 0;
30695 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30696 int arg2 ;
30697 wxDateSpan *result = 0 ;
30698 void *argp1 = 0 ;
30699 int res1 = 0 ;
30700 int val2 ;
30701 int ecode2 = 0 ;
30702 PyObject * obj0 = 0 ;
30703 PyObject * obj1 = 0 ;
30704 char * kwnames[] = {
30705 (char *) "self",(char *) "n", NULL
30706 };
30707
30708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30710 if (!SWIG_IsOK(res1)) {
30711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30712 }
30713 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30714 ecode2 = SWIG_AsVal_int(obj1, &val2);
30715 if (!SWIG_IsOK(ecode2)) {
30716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30717 }
30718 arg2 = static_cast< int >(val2);
30719 {
30720 PyThreadState* __tstate = wxPyBeginAllowThreads();
30721 {
30722 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30723 result = (wxDateSpan *) &_result_ref;
30724 }
30725 wxPyEndAllowThreads(__tstate);
30726 if (PyErr_Occurred()) SWIG_fail;
30727 }
30728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30729 return resultobj;
30730 fail:
30731 return NULL;
30732 }
30733
30734
30735 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30736 PyObject *resultobj = 0;
30737 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30738 int result;
30739 void *argp1 = 0 ;
30740 int res1 = 0 ;
30741 PyObject *swig_obj[1] ;
30742
30743 if (!args) SWIG_fail;
30744 swig_obj[0] = args;
30745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30746 if (!SWIG_IsOK(res1)) {
30747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30748 }
30749 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30750 {
30751 PyThreadState* __tstate = wxPyBeginAllowThreads();
30752 result = (int)((wxDateSpan const *)arg1)->GetYears();
30753 wxPyEndAllowThreads(__tstate);
30754 if (PyErr_Occurred()) SWIG_fail;
30755 }
30756 resultobj = SWIG_From_int(static_cast< int >(result));
30757 return resultobj;
30758 fail:
30759 return NULL;
30760 }
30761
30762
30763 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30764 PyObject *resultobj = 0;
30765 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30766 int result;
30767 void *argp1 = 0 ;
30768 int res1 = 0 ;
30769 PyObject *swig_obj[1] ;
30770
30771 if (!args) SWIG_fail;
30772 swig_obj[0] = args;
30773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30774 if (!SWIG_IsOK(res1)) {
30775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30776 }
30777 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30778 {
30779 PyThreadState* __tstate = wxPyBeginAllowThreads();
30780 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30781 wxPyEndAllowThreads(__tstate);
30782 if (PyErr_Occurred()) SWIG_fail;
30783 }
30784 resultobj = SWIG_From_int(static_cast< int >(result));
30785 return resultobj;
30786 fail:
30787 return NULL;
30788 }
30789
30790
30791 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30792 PyObject *resultobj = 0;
30793 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30794 int result;
30795 void *argp1 = 0 ;
30796 int res1 = 0 ;
30797 PyObject *swig_obj[1] ;
30798
30799 if (!args) SWIG_fail;
30800 swig_obj[0] = args;
30801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30802 if (!SWIG_IsOK(res1)) {
30803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30804 }
30805 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30806 {
30807 PyThreadState* __tstate = wxPyBeginAllowThreads();
30808 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30809 wxPyEndAllowThreads(__tstate);
30810 if (PyErr_Occurred()) SWIG_fail;
30811 }
30812 resultobj = SWIG_From_int(static_cast< int >(result));
30813 return resultobj;
30814 fail:
30815 return NULL;
30816 }
30817
30818
30819 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30820 PyObject *resultobj = 0;
30821 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30822 int result;
30823 void *argp1 = 0 ;
30824 int res1 = 0 ;
30825 PyObject *swig_obj[1] ;
30826
30827 if (!args) SWIG_fail;
30828 swig_obj[0] = args;
30829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30830 if (!SWIG_IsOK(res1)) {
30831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30832 }
30833 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30834 {
30835 PyThreadState* __tstate = wxPyBeginAllowThreads();
30836 result = (int)((wxDateSpan const *)arg1)->GetDays();
30837 wxPyEndAllowThreads(__tstate);
30838 if (PyErr_Occurred()) SWIG_fail;
30839 }
30840 resultobj = SWIG_From_int(static_cast< int >(result));
30841 return resultobj;
30842 fail:
30843 return NULL;
30844 }
30845
30846
30847 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30848 PyObject *resultobj = 0;
30849 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30850 int result;
30851 void *argp1 = 0 ;
30852 int res1 = 0 ;
30853 PyObject *swig_obj[1] ;
30854
30855 if (!args) SWIG_fail;
30856 swig_obj[0] = args;
30857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30858 if (!SWIG_IsOK(res1)) {
30859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30860 }
30861 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30862 {
30863 PyThreadState* __tstate = wxPyBeginAllowThreads();
30864 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30865 wxPyEndAllowThreads(__tstate);
30866 if (PyErr_Occurred()) SWIG_fail;
30867 }
30868 resultobj = SWIG_From_int(static_cast< int >(result));
30869 return resultobj;
30870 fail:
30871 return NULL;
30872 }
30873
30874
30875 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30876 PyObject *resultobj = 0;
30877 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30878 wxDateSpan *arg2 = 0 ;
30879 wxDateSpan *result = 0 ;
30880 void *argp1 = 0 ;
30881 int res1 = 0 ;
30882 void *argp2 = 0 ;
30883 int res2 = 0 ;
30884 PyObject * obj0 = 0 ;
30885 PyObject * obj1 = 0 ;
30886 char * kwnames[] = {
30887 (char *) "self",(char *) "other", NULL
30888 };
30889
30890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30892 if (!SWIG_IsOK(res1)) {
30893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30894 }
30895 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30896 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30897 if (!SWIG_IsOK(res2)) {
30898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30899 }
30900 if (!argp2) {
30901 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30902 }
30903 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30904 {
30905 PyThreadState* __tstate = wxPyBeginAllowThreads();
30906 {
30907 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30908 result = (wxDateSpan *) &_result_ref;
30909 }
30910 wxPyEndAllowThreads(__tstate);
30911 if (PyErr_Occurred()) SWIG_fail;
30912 }
30913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30914 return resultobj;
30915 fail:
30916 return NULL;
30917 }
30918
30919
30920 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30921 PyObject *resultobj = 0;
30922 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30923 wxDateSpan *arg2 = 0 ;
30924 wxDateSpan *result = 0 ;
30925 void *argp1 = 0 ;
30926 int res1 = 0 ;
30927 void *argp2 = 0 ;
30928 int res2 = 0 ;
30929 PyObject * obj0 = 0 ;
30930 PyObject * obj1 = 0 ;
30931 char * kwnames[] = {
30932 (char *) "self",(char *) "other", NULL
30933 };
30934
30935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30937 if (!SWIG_IsOK(res1)) {
30938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30939 }
30940 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30941 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30942 if (!SWIG_IsOK(res2)) {
30943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30944 }
30945 if (!argp2) {
30946 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30947 }
30948 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30949 {
30950 PyThreadState* __tstate = wxPyBeginAllowThreads();
30951 {
30952 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30953 result = (wxDateSpan *) &_result_ref;
30954 }
30955 wxPyEndAllowThreads(__tstate);
30956 if (PyErr_Occurred()) SWIG_fail;
30957 }
30958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30959 return resultobj;
30960 fail:
30961 return NULL;
30962 }
30963
30964
30965 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30966 PyObject *resultobj = 0;
30967 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30968 wxDateSpan *result = 0 ;
30969 void *argp1 = 0 ;
30970 int res1 = 0 ;
30971 PyObject *swig_obj[1] ;
30972
30973 if (!args) SWIG_fail;
30974 swig_obj[0] = args;
30975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30976 if (!SWIG_IsOK(res1)) {
30977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30978 }
30979 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30980 {
30981 PyThreadState* __tstate = wxPyBeginAllowThreads();
30982 {
30983 wxDateSpan &_result_ref = (arg1)->Neg();
30984 result = (wxDateSpan *) &_result_ref;
30985 }
30986 wxPyEndAllowThreads(__tstate);
30987 if (PyErr_Occurred()) SWIG_fail;
30988 }
30989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30990 return resultobj;
30991 fail:
30992 return NULL;
30993 }
30994
30995
30996 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30997 PyObject *resultobj = 0;
30998 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30999 int arg2 ;
31000 wxDateSpan *result = 0 ;
31001 void *argp1 = 0 ;
31002 int res1 = 0 ;
31003 int val2 ;
31004 int ecode2 = 0 ;
31005 PyObject * obj0 = 0 ;
31006 PyObject * obj1 = 0 ;
31007 char * kwnames[] = {
31008 (char *) "self",(char *) "factor", NULL
31009 };
31010
31011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
31012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31013 if (!SWIG_IsOK(res1)) {
31014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31015 }
31016 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31017 ecode2 = SWIG_AsVal_int(obj1, &val2);
31018 if (!SWIG_IsOK(ecode2)) {
31019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
31020 }
31021 arg2 = static_cast< int >(val2);
31022 {
31023 PyThreadState* __tstate = wxPyBeginAllowThreads();
31024 {
31025 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
31026 result = (wxDateSpan *) &_result_ref;
31027 }
31028 wxPyEndAllowThreads(__tstate);
31029 if (PyErr_Occurred()) SWIG_fail;
31030 }
31031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31032 return resultobj;
31033 fail:
31034 return NULL;
31035 }
31036
31037
31038 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31039 PyObject *resultobj = 0;
31040 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31041 wxDateSpan *arg2 = 0 ;
31042 wxDateSpan *result = 0 ;
31043 void *argp1 = 0 ;
31044 int res1 = 0 ;
31045 void *argp2 = 0 ;
31046 int res2 = 0 ;
31047 PyObject * obj0 = 0 ;
31048 PyObject * obj1 = 0 ;
31049 char * kwnames[] = {
31050 (char *) "self",(char *) "other", NULL
31051 };
31052
31053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
31054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31055 if (!SWIG_IsOK(res1)) {
31056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31057 }
31058 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31059 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31060 if (!SWIG_IsOK(res2)) {
31061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31062 }
31063 if (!argp2) {
31064 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31065 }
31066 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31067 {
31068 PyThreadState* __tstate = wxPyBeginAllowThreads();
31069 {
31070 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
31071 result = (wxDateSpan *) &_result_ref;
31072 }
31073 wxPyEndAllowThreads(__tstate);
31074 if (PyErr_Occurred()) SWIG_fail;
31075 }
31076 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31077 return resultobj;
31078 fail:
31079 return NULL;
31080 }
31081
31082
31083 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31084 PyObject *resultobj = 0;
31085 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31086 wxDateSpan *arg2 = 0 ;
31087 wxDateSpan *result = 0 ;
31088 void *argp1 = 0 ;
31089 int res1 = 0 ;
31090 void *argp2 = 0 ;
31091 int res2 = 0 ;
31092 PyObject * obj0 = 0 ;
31093 PyObject * obj1 = 0 ;
31094 char * kwnames[] = {
31095 (char *) "self",(char *) "other", NULL
31096 };
31097
31098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31100 if (!SWIG_IsOK(res1)) {
31101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31102 }
31103 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31104 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31105 if (!SWIG_IsOK(res2)) {
31106 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31107 }
31108 if (!argp2) {
31109 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31110 }
31111 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31112 {
31113 PyThreadState* __tstate = wxPyBeginAllowThreads();
31114 {
31115 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31116 result = (wxDateSpan *) &_result_ref;
31117 }
31118 wxPyEndAllowThreads(__tstate);
31119 if (PyErr_Occurred()) SWIG_fail;
31120 }
31121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31122 return resultobj;
31123 fail:
31124 return NULL;
31125 }
31126
31127
31128 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31129 PyObject *resultobj = 0;
31130 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31131 wxDateSpan *result = 0 ;
31132 void *argp1 = 0 ;
31133 int res1 = 0 ;
31134 PyObject *swig_obj[1] ;
31135
31136 if (!args) SWIG_fail;
31137 swig_obj[0] = args;
31138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31139 if (!SWIG_IsOK(res1)) {
31140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31141 }
31142 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31143 {
31144 PyThreadState* __tstate = wxPyBeginAllowThreads();
31145 {
31146 wxDateSpan &_result_ref = (arg1)->operator -();
31147 result = (wxDateSpan *) &_result_ref;
31148 }
31149 wxPyEndAllowThreads(__tstate);
31150 if (PyErr_Occurred()) SWIG_fail;
31151 }
31152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31153 return resultobj;
31154 fail:
31155 return NULL;
31156 }
31157
31158
31159 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31160 PyObject *resultobj = 0;
31161 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31162 int arg2 ;
31163 wxDateSpan *result = 0 ;
31164 void *argp1 = 0 ;
31165 int res1 = 0 ;
31166 int val2 ;
31167 int ecode2 = 0 ;
31168 PyObject * obj0 = 0 ;
31169 PyObject * obj1 = 0 ;
31170 char * kwnames[] = {
31171 (char *) "self",(char *) "factor", NULL
31172 };
31173
31174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31176 if (!SWIG_IsOK(res1)) {
31177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31178 }
31179 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31180 ecode2 = SWIG_AsVal_int(obj1, &val2);
31181 if (!SWIG_IsOK(ecode2)) {
31182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31183 }
31184 arg2 = static_cast< int >(val2);
31185 {
31186 PyThreadState* __tstate = wxPyBeginAllowThreads();
31187 {
31188 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31189 result = (wxDateSpan *) &_result_ref;
31190 }
31191 wxPyEndAllowThreads(__tstate);
31192 if (PyErr_Occurred()) SWIG_fail;
31193 }
31194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31195 return resultobj;
31196 fail:
31197 return NULL;
31198 }
31199
31200
31201 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31202 PyObject *resultobj = 0;
31203 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31204 wxDateSpan *arg2 = 0 ;
31205 wxDateSpan result;
31206 void *argp1 = 0 ;
31207 int res1 = 0 ;
31208 void *argp2 = 0 ;
31209 int res2 = 0 ;
31210 PyObject * obj0 = 0 ;
31211 PyObject * obj1 = 0 ;
31212 char * kwnames[] = {
31213 (char *) "self",(char *) "other", NULL
31214 };
31215
31216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31218 if (!SWIG_IsOK(res1)) {
31219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31220 }
31221 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31222 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31223 if (!SWIG_IsOK(res2)) {
31224 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31225 }
31226 if (!argp2) {
31227 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31228 }
31229 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31230 {
31231 PyThreadState* __tstate = wxPyBeginAllowThreads();
31232 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31233 wxPyEndAllowThreads(__tstate);
31234 if (PyErr_Occurred()) SWIG_fail;
31235 }
31236 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31237 return resultobj;
31238 fail:
31239 return NULL;
31240 }
31241
31242
31243 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31244 PyObject *resultobj = 0;
31245 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31246 wxDateSpan *arg2 = 0 ;
31247 wxDateSpan result;
31248 void *argp1 = 0 ;
31249 int res1 = 0 ;
31250 void *argp2 = 0 ;
31251 int res2 = 0 ;
31252 PyObject * obj0 = 0 ;
31253 PyObject * obj1 = 0 ;
31254 char * kwnames[] = {
31255 (char *) "self",(char *) "other", NULL
31256 };
31257
31258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31260 if (!SWIG_IsOK(res1)) {
31261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31262 }
31263 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31264 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31265 if (!SWIG_IsOK(res2)) {
31266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31267 }
31268 if (!argp2) {
31269 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31270 }
31271 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31272 {
31273 PyThreadState* __tstate = wxPyBeginAllowThreads();
31274 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31275 wxPyEndAllowThreads(__tstate);
31276 if (PyErr_Occurred()) SWIG_fail;
31277 }
31278 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31279 return resultobj;
31280 fail:
31281 return NULL;
31282 }
31283
31284
31285 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31286 PyObject *resultobj = 0;
31287 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31288 int arg2 ;
31289 wxDateSpan result;
31290 void *argp1 = 0 ;
31291 int res1 = 0 ;
31292 int val2 ;
31293 int ecode2 = 0 ;
31294 PyObject * obj0 = 0 ;
31295 PyObject * obj1 = 0 ;
31296 char * kwnames[] = {
31297 (char *) "self",(char *) "n", NULL
31298 };
31299
31300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31302 if (!SWIG_IsOK(res1)) {
31303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31304 }
31305 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31306 ecode2 = SWIG_AsVal_int(obj1, &val2);
31307 if (!SWIG_IsOK(ecode2)) {
31308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31309 }
31310 arg2 = static_cast< int >(val2);
31311 {
31312 PyThreadState* __tstate = wxPyBeginAllowThreads();
31313 result = wxDateSpan___mul__(arg1,arg2);
31314 wxPyEndAllowThreads(__tstate);
31315 if (PyErr_Occurred()) SWIG_fail;
31316 }
31317 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31318 return resultobj;
31319 fail:
31320 return NULL;
31321 }
31322
31323
31324 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31325 PyObject *resultobj = 0;
31326 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31327 int arg2 ;
31328 wxDateSpan result;
31329 void *argp1 = 0 ;
31330 int res1 = 0 ;
31331 int val2 ;
31332 int ecode2 = 0 ;
31333 PyObject * obj0 = 0 ;
31334 PyObject * obj1 = 0 ;
31335 char * kwnames[] = {
31336 (char *) "self",(char *) "n", NULL
31337 };
31338
31339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31341 if (!SWIG_IsOK(res1)) {
31342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31343 }
31344 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31345 ecode2 = SWIG_AsVal_int(obj1, &val2);
31346 if (!SWIG_IsOK(ecode2)) {
31347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31348 }
31349 arg2 = static_cast< int >(val2);
31350 {
31351 PyThreadState* __tstate = wxPyBeginAllowThreads();
31352 result = wxDateSpan___rmul__(arg1,arg2);
31353 wxPyEndAllowThreads(__tstate);
31354 if (PyErr_Occurred()) SWIG_fail;
31355 }
31356 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31357 return resultobj;
31358 fail:
31359 return NULL;
31360 }
31361
31362
31363 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31364 PyObject *resultobj = 0;
31365 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31366 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31367 bool result;
31368 void *argp1 = 0 ;
31369 int res1 = 0 ;
31370 void *argp2 = 0 ;
31371 int res2 = 0 ;
31372 PyObject * obj0 = 0 ;
31373 PyObject * obj1 = 0 ;
31374 char * kwnames[] = {
31375 (char *) "self",(char *) "other", NULL
31376 };
31377
31378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31380 if (!SWIG_IsOK(res1)) {
31381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31382 }
31383 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31384 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31385 if (!SWIG_IsOK(res2)) {
31386 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31387 }
31388 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31389 {
31390 PyThreadState* __tstate = wxPyBeginAllowThreads();
31391 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31392 wxPyEndAllowThreads(__tstate);
31393 if (PyErr_Occurred()) SWIG_fail;
31394 }
31395 {
31396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31397 }
31398 return resultobj;
31399 fail:
31400 return NULL;
31401 }
31402
31403
31404 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31405 PyObject *resultobj = 0;
31406 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31407 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31408 bool result;
31409 void *argp1 = 0 ;
31410 int res1 = 0 ;
31411 void *argp2 = 0 ;
31412 int res2 = 0 ;
31413 PyObject * obj0 = 0 ;
31414 PyObject * obj1 = 0 ;
31415 char * kwnames[] = {
31416 (char *) "self",(char *) "other", NULL
31417 };
31418
31419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31421 if (!SWIG_IsOK(res1)) {
31422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31423 }
31424 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31425 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31426 if (!SWIG_IsOK(res2)) {
31427 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31428 }
31429 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31430 {
31431 PyThreadState* __tstate = wxPyBeginAllowThreads();
31432 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31433 wxPyEndAllowThreads(__tstate);
31434 if (PyErr_Occurred()) SWIG_fail;
31435 }
31436 {
31437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31438 }
31439 return resultobj;
31440 fail:
31441 return NULL;
31442 }
31443
31444
31445 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31446 PyObject *obj;
31447 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31448 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31449 return SWIG_Py_Void();
31450 }
31451
31452 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31453 return SWIG_Python_InitShadowInstance(args);
31454 }
31455
31456 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31457 PyObject *resultobj = 0;
31458 long result;
31459
31460 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31461 {
31462 PyThreadState* __tstate = wxPyBeginAllowThreads();
31463 result = (long)wxGetLocalTime();
31464 wxPyEndAllowThreads(__tstate);
31465 if (PyErr_Occurred()) SWIG_fail;
31466 }
31467 resultobj = SWIG_From_long(static_cast< long >(result));
31468 return resultobj;
31469 fail:
31470 return NULL;
31471 }
31472
31473
31474 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31475 PyObject *resultobj = 0;
31476 long result;
31477
31478 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31479 {
31480 PyThreadState* __tstate = wxPyBeginAllowThreads();
31481 result = (long)wxGetUTCTime();
31482 wxPyEndAllowThreads(__tstate);
31483 if (PyErr_Occurred()) SWIG_fail;
31484 }
31485 resultobj = SWIG_From_long(static_cast< long >(result));
31486 return resultobj;
31487 fail:
31488 return NULL;
31489 }
31490
31491
31492 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31493 PyObject *resultobj = 0;
31494 long result;
31495
31496 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31497 {
31498 PyThreadState* __tstate = wxPyBeginAllowThreads();
31499 result = (long)wxGetCurrentTime();
31500 wxPyEndAllowThreads(__tstate);
31501 if (PyErr_Occurred()) SWIG_fail;
31502 }
31503 resultobj = SWIG_From_long(static_cast< long >(result));
31504 return resultobj;
31505 fail:
31506 return NULL;
31507 }
31508
31509
31510 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31511 PyObject *resultobj = 0;
31512 wxLongLong result;
31513
31514 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31515 {
31516 PyThreadState* __tstate = wxPyBeginAllowThreads();
31517 result = wxGetLocalTimeMillis();
31518 wxPyEndAllowThreads(__tstate);
31519 if (PyErr_Occurred()) SWIG_fail;
31520 }
31521 {
31522 PyObject *hi, *lo, *shifter, *shifted;
31523 hi = PyLong_FromLong( (&result)->GetHi() );
31524 lo = PyLong_FromLong( (&result)->GetLo() );
31525 shifter = PyLong_FromLong(32);
31526 shifted = PyNumber_Lshift(hi, shifter);
31527 resultobj = PyNumber_Or(shifted, lo);
31528 Py_DECREF(hi);
31529 Py_DECREF(lo);
31530 Py_DECREF(shifter);
31531 Py_DECREF(shifted);
31532 }
31533 return resultobj;
31534 fail:
31535 return NULL;
31536 }
31537
31538
31539 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31540 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31541 return 1;
31542 }
31543
31544
31545 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31546 PyObject *pyobj = 0;
31547
31548 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31549 return pyobj;
31550 }
31551
31552
31553 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31554 PyObject *resultobj = 0;
31555 wxDataFormatId arg1 ;
31556 wxDataFormat *result = 0 ;
31557 int val1 ;
31558 int ecode1 = 0 ;
31559 PyObject * obj0 = 0 ;
31560 char * kwnames[] = {
31561 (char *) "type", NULL
31562 };
31563
31564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31565 ecode1 = SWIG_AsVal_int(obj0, &val1);
31566 if (!SWIG_IsOK(ecode1)) {
31567 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31568 }
31569 arg1 = static_cast< wxDataFormatId >(val1);
31570 {
31571 PyThreadState* __tstate = wxPyBeginAllowThreads();
31572 result = (wxDataFormat *)new wxDataFormat(arg1);
31573 wxPyEndAllowThreads(__tstate);
31574 if (PyErr_Occurred()) SWIG_fail;
31575 }
31576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31577 return resultobj;
31578 fail:
31579 return NULL;
31580 }
31581
31582
31583 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31584 PyObject *resultobj = 0;
31585 wxString *arg1 = 0 ;
31586 wxDataFormat *result = 0 ;
31587 bool temp1 = false ;
31588 PyObject * obj0 = 0 ;
31589 char * kwnames[] = {
31590 (char *) "format", NULL
31591 };
31592
31593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31594 {
31595 arg1 = wxString_in_helper(obj0);
31596 if (arg1 == NULL) SWIG_fail;
31597 temp1 = true;
31598 }
31599 {
31600 PyThreadState* __tstate = wxPyBeginAllowThreads();
31601 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31602 wxPyEndAllowThreads(__tstate);
31603 if (PyErr_Occurred()) SWIG_fail;
31604 }
31605 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31606 {
31607 if (temp1)
31608 delete arg1;
31609 }
31610 return resultobj;
31611 fail:
31612 {
31613 if (temp1)
31614 delete arg1;
31615 }
31616 return NULL;
31617 }
31618
31619
31620 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31621 PyObject *resultobj = 0;
31622 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31623 void *argp1 = 0 ;
31624 int res1 = 0 ;
31625 PyObject *swig_obj[1] ;
31626
31627 if (!args) SWIG_fail;
31628 swig_obj[0] = args;
31629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31630 if (!SWIG_IsOK(res1)) {
31631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31632 }
31633 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31634 {
31635 PyThreadState* __tstate = wxPyBeginAllowThreads();
31636 delete arg1;
31637
31638 wxPyEndAllowThreads(__tstate);
31639 if (PyErr_Occurred()) SWIG_fail;
31640 }
31641 resultobj = SWIG_Py_Void();
31642 return resultobj;
31643 fail:
31644 return NULL;
31645 }
31646
31647
31648 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31649 PyObject *resultobj = 0;
31650 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31651 wxDataFormatId arg2 ;
31652 bool result;
31653 void *argp1 = 0 ;
31654 int res1 = 0 ;
31655 int val2 ;
31656 int ecode2 = 0 ;
31657
31658 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31660 if (!SWIG_IsOK(res1)) {
31661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31662 }
31663 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31664 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31665 if (!SWIG_IsOK(ecode2)) {
31666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31667 }
31668 arg2 = static_cast< wxDataFormatId >(val2);
31669 {
31670 PyThreadState* __tstate = wxPyBeginAllowThreads();
31671 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31672 wxPyEndAllowThreads(__tstate);
31673 if (PyErr_Occurred()) SWIG_fail;
31674 }
31675 {
31676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31677 }
31678 return resultobj;
31679 fail:
31680 return NULL;
31681 }
31682
31683
31684 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31685 PyObject *resultobj = 0;
31686 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31687 wxDataFormatId arg2 ;
31688 bool result;
31689 void *argp1 = 0 ;
31690 int res1 = 0 ;
31691 int val2 ;
31692 int ecode2 = 0 ;
31693
31694 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31696 if (!SWIG_IsOK(res1)) {
31697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31698 }
31699 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31700 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31701 if (!SWIG_IsOK(ecode2)) {
31702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31703 }
31704 arg2 = static_cast< wxDataFormatId >(val2);
31705 {
31706 PyThreadState* __tstate = wxPyBeginAllowThreads();
31707 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31708 wxPyEndAllowThreads(__tstate);
31709 if (PyErr_Occurred()) SWIG_fail;
31710 }
31711 {
31712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31713 }
31714 return resultobj;
31715 fail:
31716 return NULL;
31717 }
31718
31719
31720 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31721 PyObject *resultobj = 0;
31722 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31723 wxDataFormat *arg2 = 0 ;
31724 bool result;
31725 void *argp1 = 0 ;
31726 int res1 = 0 ;
31727 void *argp2 = 0 ;
31728 int res2 = 0 ;
31729
31730 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31732 if (!SWIG_IsOK(res1)) {
31733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31734 }
31735 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31736 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31737 if (!SWIG_IsOK(res2)) {
31738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31739 }
31740 if (!argp2) {
31741 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31742 }
31743 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31744 {
31745 PyThreadState* __tstate = wxPyBeginAllowThreads();
31746 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31747 wxPyEndAllowThreads(__tstate);
31748 if (PyErr_Occurred()) SWIG_fail;
31749 }
31750 {
31751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31752 }
31753 return resultobj;
31754 fail:
31755 return NULL;
31756 }
31757
31758
31759 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31760 int argc;
31761 PyObject *argv[3];
31762
31763 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31764 --argc;
31765 if (argc == 2) {
31766 int _v = 0;
31767 {
31768 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31769 _v = SWIG_CheckState(res);
31770 }
31771 if (!_v) goto check_1;
31772 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31773 }
31774 check_1:
31775
31776 if (argc == 2) {
31777 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31778 }
31779
31780 fail:
31781 Py_INCREF(Py_NotImplemented);
31782 return Py_NotImplemented;
31783 }
31784
31785
31786 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31787 PyObject *resultobj = 0;
31788 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31789 wxDataFormat *arg2 = 0 ;
31790 bool result;
31791 void *argp1 = 0 ;
31792 int res1 = 0 ;
31793 void *argp2 = 0 ;
31794 int res2 = 0 ;
31795
31796 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31798 if (!SWIG_IsOK(res1)) {
31799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31800 }
31801 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31802 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31803 if (!SWIG_IsOK(res2)) {
31804 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31805 }
31806 if (!argp2) {
31807 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31808 }
31809 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31810 {
31811 PyThreadState* __tstate = wxPyBeginAllowThreads();
31812 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31813 wxPyEndAllowThreads(__tstate);
31814 if (PyErr_Occurred()) SWIG_fail;
31815 }
31816 {
31817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31818 }
31819 return resultobj;
31820 fail:
31821 return NULL;
31822 }
31823
31824
31825 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31826 int argc;
31827 PyObject *argv[3];
31828
31829 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31830 --argc;
31831 if (argc == 2) {
31832 int _v = 0;
31833 {
31834 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31835 _v = SWIG_CheckState(res);
31836 }
31837 if (!_v) goto check_1;
31838 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31839 }
31840 check_1:
31841
31842 if (argc == 2) {
31843 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31844 }
31845
31846 fail:
31847 Py_INCREF(Py_NotImplemented);
31848 return Py_NotImplemented;
31849 }
31850
31851
31852 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31853 PyObject *resultobj = 0;
31854 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31855 wxDataFormatId arg2 ;
31856 void *argp1 = 0 ;
31857 int res1 = 0 ;
31858 int val2 ;
31859 int ecode2 = 0 ;
31860 PyObject * obj0 = 0 ;
31861 PyObject * obj1 = 0 ;
31862 char * kwnames[] = {
31863 (char *) "self",(char *) "format", NULL
31864 };
31865
31866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31868 if (!SWIG_IsOK(res1)) {
31869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31870 }
31871 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31872 ecode2 = SWIG_AsVal_int(obj1, &val2);
31873 if (!SWIG_IsOK(ecode2)) {
31874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31875 }
31876 arg2 = static_cast< wxDataFormatId >(val2);
31877 {
31878 PyThreadState* __tstate = wxPyBeginAllowThreads();
31879 (arg1)->SetType(arg2);
31880 wxPyEndAllowThreads(__tstate);
31881 if (PyErr_Occurred()) SWIG_fail;
31882 }
31883 resultobj = SWIG_Py_Void();
31884 return resultobj;
31885 fail:
31886 return NULL;
31887 }
31888
31889
31890 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31891 PyObject *resultobj = 0;
31892 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31893 wxDataFormatId result;
31894 void *argp1 = 0 ;
31895 int res1 = 0 ;
31896 PyObject *swig_obj[1] ;
31897
31898 if (!args) SWIG_fail;
31899 swig_obj[0] = args;
31900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31901 if (!SWIG_IsOK(res1)) {
31902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31903 }
31904 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31905 {
31906 PyThreadState* __tstate = wxPyBeginAllowThreads();
31907 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31908 wxPyEndAllowThreads(__tstate);
31909 if (PyErr_Occurred()) SWIG_fail;
31910 }
31911 resultobj = SWIG_From_int(static_cast< int >(result));
31912 return resultobj;
31913 fail:
31914 return NULL;
31915 }
31916
31917
31918 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31919 PyObject *resultobj = 0;
31920 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31921 wxString result;
31922 void *argp1 = 0 ;
31923 int res1 = 0 ;
31924 PyObject *swig_obj[1] ;
31925
31926 if (!args) SWIG_fail;
31927 swig_obj[0] = args;
31928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31929 if (!SWIG_IsOK(res1)) {
31930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31931 }
31932 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31933 {
31934 PyThreadState* __tstate = wxPyBeginAllowThreads();
31935 result = ((wxDataFormat const *)arg1)->GetId();
31936 wxPyEndAllowThreads(__tstate);
31937 if (PyErr_Occurred()) SWIG_fail;
31938 }
31939 {
31940 #if wxUSE_UNICODE
31941 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31942 #else
31943 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31944 #endif
31945 }
31946 return resultobj;
31947 fail:
31948 return NULL;
31949 }
31950
31951
31952 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31953 PyObject *resultobj = 0;
31954 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31955 wxString *arg2 = 0 ;
31956 void *argp1 = 0 ;
31957 int res1 = 0 ;
31958 bool temp2 = false ;
31959 PyObject * obj0 = 0 ;
31960 PyObject * obj1 = 0 ;
31961 char * kwnames[] = {
31962 (char *) "self",(char *) "format", NULL
31963 };
31964
31965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31967 if (!SWIG_IsOK(res1)) {
31968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31969 }
31970 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31971 {
31972 arg2 = wxString_in_helper(obj1);
31973 if (arg2 == NULL) SWIG_fail;
31974 temp2 = true;
31975 }
31976 {
31977 PyThreadState* __tstate = wxPyBeginAllowThreads();
31978 (arg1)->SetId((wxString const &)*arg2);
31979 wxPyEndAllowThreads(__tstate);
31980 if (PyErr_Occurred()) SWIG_fail;
31981 }
31982 resultobj = SWIG_Py_Void();
31983 {
31984 if (temp2)
31985 delete arg2;
31986 }
31987 return resultobj;
31988 fail:
31989 {
31990 if (temp2)
31991 delete arg2;
31992 }
31993 return NULL;
31994 }
31995
31996
31997 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31998 PyObject *obj;
31999 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32000 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
32001 return SWIG_Py_Void();
32002 }
32003
32004 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32005 return SWIG_Python_InitShadowInstance(args);
32006 }
32007
32008 SWIGINTERN int FormatInvalid_set(PyObject *) {
32009 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
32010 return 1;
32011 }
32012
32013
32014 SWIGINTERN PyObject *FormatInvalid_get(void) {
32015 PyObject *pyobj = 0;
32016
32017 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
32018 return pyobj;
32019 }
32020
32021
32022 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32023 PyObject *resultobj = 0;
32024 wxDataObject *arg1 = (wxDataObject *) 0 ;
32025 void *argp1 = 0 ;
32026 int res1 = 0 ;
32027 PyObject *swig_obj[1] ;
32028
32029 if (!args) SWIG_fail;
32030 swig_obj[0] = args;
32031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32032 if (!SWIG_IsOK(res1)) {
32033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
32034 }
32035 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32036 {
32037 PyThreadState* __tstate = wxPyBeginAllowThreads();
32038 delete arg1;
32039
32040 wxPyEndAllowThreads(__tstate);
32041 if (PyErr_Occurred()) SWIG_fail;
32042 }
32043 resultobj = SWIG_Py_Void();
32044 return resultobj;
32045 fail:
32046 return NULL;
32047 }
32048
32049
32050 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32051 PyObject *resultobj = 0;
32052 wxDataObject *arg1 = (wxDataObject *) 0 ;
32053 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32054 SwigValueWrapper<wxDataFormat > result;
32055 void *argp1 = 0 ;
32056 int res1 = 0 ;
32057 int val2 ;
32058 int ecode2 = 0 ;
32059 PyObject * obj0 = 0 ;
32060 PyObject * obj1 = 0 ;
32061 char * kwnames[] = {
32062 (char *) "self",(char *) "dir", NULL
32063 };
32064
32065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32067 if (!SWIG_IsOK(res1)) {
32068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32069 }
32070 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32071 if (obj1) {
32072 ecode2 = SWIG_AsVal_int(obj1, &val2);
32073 if (!SWIG_IsOK(ecode2)) {
32074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32075 }
32076 arg2 = static_cast< wxDataObject::Direction >(val2);
32077 }
32078 {
32079 PyThreadState* __tstate = wxPyBeginAllowThreads();
32080 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
32081 wxPyEndAllowThreads(__tstate);
32082 if (PyErr_Occurred()) SWIG_fail;
32083 }
32084 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32085 return resultobj;
32086 fail:
32087 return NULL;
32088 }
32089
32090
32091 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32092 PyObject *resultobj = 0;
32093 wxDataObject *arg1 = (wxDataObject *) 0 ;
32094 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32095 size_t result;
32096 void *argp1 = 0 ;
32097 int res1 = 0 ;
32098 int val2 ;
32099 int ecode2 = 0 ;
32100 PyObject * obj0 = 0 ;
32101 PyObject * obj1 = 0 ;
32102 char * kwnames[] = {
32103 (char *) "self",(char *) "dir", NULL
32104 };
32105
32106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32108 if (!SWIG_IsOK(res1)) {
32109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32110 }
32111 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32112 if (obj1) {
32113 ecode2 = SWIG_AsVal_int(obj1, &val2);
32114 if (!SWIG_IsOK(ecode2)) {
32115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32116 }
32117 arg2 = static_cast< wxDataObject::Direction >(val2);
32118 }
32119 {
32120 PyThreadState* __tstate = wxPyBeginAllowThreads();
32121 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32122 wxPyEndAllowThreads(__tstate);
32123 if (PyErr_Occurred()) SWIG_fail;
32124 }
32125 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32126 return resultobj;
32127 fail:
32128 return NULL;
32129 }
32130
32131
32132 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32133 PyObject *resultobj = 0;
32134 wxDataObject *arg1 = (wxDataObject *) 0 ;
32135 wxDataFormat *arg2 = 0 ;
32136 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32137 bool result;
32138 void *argp1 = 0 ;
32139 int res1 = 0 ;
32140 void *argp2 = 0 ;
32141 int res2 = 0 ;
32142 int val3 ;
32143 int ecode3 = 0 ;
32144 PyObject * obj0 = 0 ;
32145 PyObject * obj1 = 0 ;
32146 PyObject * obj2 = 0 ;
32147 char * kwnames[] = {
32148 (char *) "self",(char *) "format",(char *) "dir", NULL
32149 };
32150
32151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32153 if (!SWIG_IsOK(res1)) {
32154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32155 }
32156 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32157 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32158 if (!SWIG_IsOK(res2)) {
32159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32160 }
32161 if (!argp2) {
32162 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32163 }
32164 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32165 if (obj2) {
32166 ecode3 = SWIG_AsVal_int(obj2, &val3);
32167 if (!SWIG_IsOK(ecode3)) {
32168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32169 }
32170 arg3 = static_cast< wxDataObject::Direction >(val3);
32171 }
32172 {
32173 PyThreadState* __tstate = wxPyBeginAllowThreads();
32174 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32175 wxPyEndAllowThreads(__tstate);
32176 if (PyErr_Occurred()) SWIG_fail;
32177 }
32178 {
32179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32180 }
32181 return resultobj;
32182 fail:
32183 return NULL;
32184 }
32185
32186
32187 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32188 PyObject *resultobj = 0;
32189 wxDataObject *arg1 = (wxDataObject *) 0 ;
32190 wxDataFormat *arg2 = 0 ;
32191 size_t result;
32192 void *argp1 = 0 ;
32193 int res1 = 0 ;
32194 void *argp2 = 0 ;
32195 int res2 = 0 ;
32196 PyObject * obj0 = 0 ;
32197 PyObject * obj1 = 0 ;
32198 char * kwnames[] = {
32199 (char *) "self",(char *) "format", NULL
32200 };
32201
32202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32204 if (!SWIG_IsOK(res1)) {
32205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32206 }
32207 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32208 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32209 if (!SWIG_IsOK(res2)) {
32210 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32211 }
32212 if (!argp2) {
32213 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32214 }
32215 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32216 {
32217 PyThreadState* __tstate = wxPyBeginAllowThreads();
32218 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32219 wxPyEndAllowThreads(__tstate);
32220 if (PyErr_Occurred()) SWIG_fail;
32221 }
32222 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32223 return resultobj;
32224 fail:
32225 return NULL;
32226 }
32227
32228
32229 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32230 PyObject *resultobj = 0;
32231 wxDataObject *arg1 = (wxDataObject *) 0 ;
32232 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32233 PyObject *result = 0 ;
32234 void *argp1 = 0 ;
32235 int res1 = 0 ;
32236 int val2 ;
32237 int ecode2 = 0 ;
32238 PyObject * obj0 = 0 ;
32239 PyObject * obj1 = 0 ;
32240 char * kwnames[] = {
32241 (char *) "self",(char *) "dir", NULL
32242 };
32243
32244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32246 if (!SWIG_IsOK(res1)) {
32247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32248 }
32249 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32250 if (obj1) {
32251 ecode2 = SWIG_AsVal_int(obj1, &val2);
32252 if (!SWIG_IsOK(ecode2)) {
32253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32254 }
32255 arg2 = static_cast< wxDataObject::Direction >(val2);
32256 }
32257 {
32258 PyThreadState* __tstate = wxPyBeginAllowThreads();
32259 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32260 wxPyEndAllowThreads(__tstate);
32261 if (PyErr_Occurred()) SWIG_fail;
32262 }
32263 resultobj = result;
32264 return resultobj;
32265 fail:
32266 return NULL;
32267 }
32268
32269
32270 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32271 PyObject *resultobj = 0;
32272 wxDataObject *arg1 = (wxDataObject *) 0 ;
32273 wxDataFormat *arg2 = 0 ;
32274 PyObject *result = 0 ;
32275 void *argp1 = 0 ;
32276 int res1 = 0 ;
32277 void *argp2 = 0 ;
32278 int res2 = 0 ;
32279 PyObject * obj0 = 0 ;
32280 PyObject * obj1 = 0 ;
32281 char * kwnames[] = {
32282 (char *) "self",(char *) "format", NULL
32283 };
32284
32285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32287 if (!SWIG_IsOK(res1)) {
32288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32289 }
32290 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32291 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32292 if (!SWIG_IsOK(res2)) {
32293 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32294 }
32295 if (!argp2) {
32296 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32297 }
32298 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32299 {
32300 PyThreadState* __tstate = wxPyBeginAllowThreads();
32301 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32302 wxPyEndAllowThreads(__tstate);
32303 if (PyErr_Occurred()) SWIG_fail;
32304 }
32305 resultobj = result;
32306 return resultobj;
32307 fail:
32308 return NULL;
32309 }
32310
32311
32312 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32313 PyObject *resultobj = 0;
32314 wxDataObject *arg1 = (wxDataObject *) 0 ;
32315 wxDataFormat *arg2 = 0 ;
32316 PyObject *arg3 = (PyObject *) 0 ;
32317 bool result;
32318 void *argp1 = 0 ;
32319 int res1 = 0 ;
32320 void *argp2 = 0 ;
32321 int res2 = 0 ;
32322 PyObject * obj0 = 0 ;
32323 PyObject * obj1 = 0 ;
32324 PyObject * obj2 = 0 ;
32325 char * kwnames[] = {
32326 (char *) "self",(char *) "format",(char *) "data", NULL
32327 };
32328
32329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32331 if (!SWIG_IsOK(res1)) {
32332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32333 }
32334 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32335 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32336 if (!SWIG_IsOK(res2)) {
32337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32338 }
32339 if (!argp2) {
32340 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32341 }
32342 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32343 arg3 = obj2;
32344 {
32345 PyThreadState* __tstate = wxPyBeginAllowThreads();
32346 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32347 wxPyEndAllowThreads(__tstate);
32348 if (PyErr_Occurred()) SWIG_fail;
32349 }
32350 {
32351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32352 }
32353 return resultobj;
32354 fail:
32355 return NULL;
32356 }
32357
32358
32359 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32360 PyObject *obj;
32361 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32362 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32363 return SWIG_Py_Void();
32364 }
32365
32366 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32367 PyObject *resultobj = 0;
32368 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32369 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32370 wxDataObjectSimple *result = 0 ;
32371 void *argp1 = 0 ;
32372 int res1 = 0 ;
32373 PyObject * obj0 = 0 ;
32374 char * kwnames[] = {
32375 (char *) "format", NULL
32376 };
32377
32378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32379 if (obj0) {
32380 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32381 if (!SWIG_IsOK(res1)) {
32382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32383 }
32384 if (!argp1) {
32385 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32386 }
32387 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32388 }
32389 {
32390 PyThreadState* __tstate = wxPyBeginAllowThreads();
32391 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32392 wxPyEndAllowThreads(__tstate);
32393 if (PyErr_Occurred()) SWIG_fail;
32394 }
32395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32396 return resultobj;
32397 fail:
32398 return NULL;
32399 }
32400
32401
32402 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32403 PyObject *resultobj = 0;
32404 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32405 wxDataFormat *result = 0 ;
32406 void *argp1 = 0 ;
32407 int res1 = 0 ;
32408 PyObject *swig_obj[1] ;
32409
32410 if (!args) SWIG_fail;
32411 swig_obj[0] = args;
32412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32413 if (!SWIG_IsOK(res1)) {
32414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32415 }
32416 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32417 {
32418 PyThreadState* __tstate = wxPyBeginAllowThreads();
32419 {
32420 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32421 result = (wxDataFormat *) &_result_ref;
32422 }
32423 wxPyEndAllowThreads(__tstate);
32424 if (PyErr_Occurred()) SWIG_fail;
32425 }
32426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32427 return resultobj;
32428 fail:
32429 return NULL;
32430 }
32431
32432
32433 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32434 PyObject *resultobj = 0;
32435 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32436 wxDataFormat *arg2 = 0 ;
32437 void *argp1 = 0 ;
32438 int res1 = 0 ;
32439 void *argp2 = 0 ;
32440 int res2 = 0 ;
32441 PyObject * obj0 = 0 ;
32442 PyObject * obj1 = 0 ;
32443 char * kwnames[] = {
32444 (char *) "self",(char *) "format", NULL
32445 };
32446
32447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32449 if (!SWIG_IsOK(res1)) {
32450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32451 }
32452 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32453 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32454 if (!SWIG_IsOK(res2)) {
32455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32456 }
32457 if (!argp2) {
32458 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32459 }
32460 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32461 {
32462 PyThreadState* __tstate = wxPyBeginAllowThreads();
32463 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32464 wxPyEndAllowThreads(__tstate);
32465 if (PyErr_Occurred()) SWIG_fail;
32466 }
32467 resultobj = SWIG_Py_Void();
32468 return resultobj;
32469 fail:
32470 return NULL;
32471 }
32472
32473
32474 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32475 PyObject *resultobj = 0;
32476 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32477 size_t result;
32478 void *argp1 = 0 ;
32479 int res1 = 0 ;
32480 PyObject *swig_obj[1] ;
32481
32482 if (!args) SWIG_fail;
32483 swig_obj[0] = args;
32484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32485 if (!SWIG_IsOK(res1)) {
32486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32487 }
32488 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32489 {
32490 PyThreadState* __tstate = wxPyBeginAllowThreads();
32491 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32492 wxPyEndAllowThreads(__tstate);
32493 if (PyErr_Occurred()) SWIG_fail;
32494 }
32495 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32496 return resultobj;
32497 fail:
32498 return NULL;
32499 }
32500
32501
32502 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32503 PyObject *resultobj = 0;
32504 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32505 PyObject *result = 0 ;
32506 void *argp1 = 0 ;
32507 int res1 = 0 ;
32508 PyObject *swig_obj[1] ;
32509
32510 if (!args) SWIG_fail;
32511 swig_obj[0] = args;
32512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32513 if (!SWIG_IsOK(res1)) {
32514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32515 }
32516 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32517 {
32518 PyThreadState* __tstate = wxPyBeginAllowThreads();
32519 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32520 wxPyEndAllowThreads(__tstate);
32521 if (PyErr_Occurred()) SWIG_fail;
32522 }
32523 resultobj = result;
32524 return resultobj;
32525 fail:
32526 return NULL;
32527 }
32528
32529
32530 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32531 PyObject *resultobj = 0;
32532 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32533 PyObject *arg2 = (PyObject *) 0 ;
32534 bool result;
32535 void *argp1 = 0 ;
32536 int res1 = 0 ;
32537 PyObject * obj0 = 0 ;
32538 PyObject * obj1 = 0 ;
32539 char * kwnames[] = {
32540 (char *) "self",(char *) "data", NULL
32541 };
32542
32543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32545 if (!SWIG_IsOK(res1)) {
32546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32547 }
32548 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32549 arg2 = obj1;
32550 {
32551 PyThreadState* __tstate = wxPyBeginAllowThreads();
32552 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32553 wxPyEndAllowThreads(__tstate);
32554 if (PyErr_Occurred()) SWIG_fail;
32555 }
32556 {
32557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32558 }
32559 return resultobj;
32560 fail:
32561 return NULL;
32562 }
32563
32564
32565 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32566 PyObject *obj;
32567 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32568 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32569 return SWIG_Py_Void();
32570 }
32571
32572 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32573 return SWIG_Python_InitShadowInstance(args);
32574 }
32575
32576 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32577 PyObject *resultobj = 0;
32578 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32579 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32580 wxPyDataObjectSimple *result = 0 ;
32581 void *argp1 = 0 ;
32582 int res1 = 0 ;
32583 PyObject * obj0 = 0 ;
32584 char * kwnames[] = {
32585 (char *) "format", NULL
32586 };
32587
32588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32589 if (obj0) {
32590 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32591 if (!SWIG_IsOK(res1)) {
32592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32593 }
32594 if (!argp1) {
32595 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32596 }
32597 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32598 }
32599 {
32600 PyThreadState* __tstate = wxPyBeginAllowThreads();
32601 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32602 wxPyEndAllowThreads(__tstate);
32603 if (PyErr_Occurred()) SWIG_fail;
32604 }
32605 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32606 return resultobj;
32607 fail:
32608 return NULL;
32609 }
32610
32611
32612 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32613 PyObject *resultobj = 0;
32614 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32615 PyObject *arg2 = (PyObject *) 0 ;
32616 PyObject *arg3 = (PyObject *) 0 ;
32617 void *argp1 = 0 ;
32618 int res1 = 0 ;
32619 PyObject * obj0 = 0 ;
32620 PyObject * obj1 = 0 ;
32621 PyObject * obj2 = 0 ;
32622 char * kwnames[] = {
32623 (char *) "self",(char *) "self",(char *) "_class", NULL
32624 };
32625
32626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32628 if (!SWIG_IsOK(res1)) {
32629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32630 }
32631 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32632 arg2 = obj1;
32633 arg3 = obj2;
32634 {
32635 PyThreadState* __tstate = wxPyBeginAllowThreads();
32636 (arg1)->_setCallbackInfo(arg2,arg3);
32637 wxPyEndAllowThreads(__tstate);
32638 if (PyErr_Occurred()) SWIG_fail;
32639 }
32640 resultobj = SWIG_Py_Void();
32641 return resultobj;
32642 fail:
32643 return NULL;
32644 }
32645
32646
32647 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32648 PyObject *obj;
32649 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32650 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32651 return SWIG_Py_Void();
32652 }
32653
32654 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32655 return SWIG_Python_InitShadowInstance(args);
32656 }
32657
32658 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32659 PyObject *resultobj = 0;
32660 wxDataObjectComposite *result = 0 ;
32661
32662 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32663 {
32664 PyThreadState* __tstate = wxPyBeginAllowThreads();
32665 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32666 wxPyEndAllowThreads(__tstate);
32667 if (PyErr_Occurred()) SWIG_fail;
32668 }
32669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32670 return resultobj;
32671 fail:
32672 return NULL;
32673 }
32674
32675
32676 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32677 PyObject *resultobj = 0;
32678 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32679 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32680 bool arg3 = (bool) false ;
32681 void *argp1 = 0 ;
32682 int res1 = 0 ;
32683 int res2 = 0 ;
32684 bool val3 ;
32685 int ecode3 = 0 ;
32686 PyObject * obj0 = 0 ;
32687 PyObject * obj1 = 0 ;
32688 PyObject * obj2 = 0 ;
32689 char * kwnames[] = {
32690 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32691 };
32692
32693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32695 if (!SWIG_IsOK(res1)) {
32696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32697 }
32698 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32699 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32700 if (!SWIG_IsOK(res2)) {
32701 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32702 }
32703 if (obj2) {
32704 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32705 if (!SWIG_IsOK(ecode3)) {
32706 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32707 }
32708 arg3 = static_cast< bool >(val3);
32709 }
32710 {
32711 PyThreadState* __tstate = wxPyBeginAllowThreads();
32712 (arg1)->Add(arg2,arg3);
32713 wxPyEndAllowThreads(__tstate);
32714 if (PyErr_Occurred()) SWIG_fail;
32715 }
32716 resultobj = SWIG_Py_Void();
32717 return resultobj;
32718 fail:
32719 return NULL;
32720 }
32721
32722
32723 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32724 PyObject *resultobj = 0;
32725 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32726 SwigValueWrapper<wxDataFormat > result;
32727 void *argp1 = 0 ;
32728 int res1 = 0 ;
32729 PyObject *swig_obj[1] ;
32730
32731 if (!args) SWIG_fail;
32732 swig_obj[0] = args;
32733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32734 if (!SWIG_IsOK(res1)) {
32735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32736 }
32737 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32738 {
32739 PyThreadState* __tstate = wxPyBeginAllowThreads();
32740 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32741 wxPyEndAllowThreads(__tstate);
32742 if (PyErr_Occurred()) SWIG_fail;
32743 }
32744 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32745 return resultobj;
32746 fail:
32747 return NULL;
32748 }
32749
32750
32751 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32752 PyObject *obj;
32753 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32754 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32755 return SWIG_Py_Void();
32756 }
32757
32758 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32759 return SWIG_Python_InitShadowInstance(args);
32760 }
32761
32762 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32763 PyObject *resultobj = 0;
32764 wxString const &arg1_defvalue = wxPyEmptyString ;
32765 wxString *arg1 = (wxString *) &arg1_defvalue ;
32766 wxTextDataObject *result = 0 ;
32767 bool temp1 = false ;
32768 PyObject * obj0 = 0 ;
32769 char * kwnames[] = {
32770 (char *) "text", NULL
32771 };
32772
32773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32774 if (obj0) {
32775 {
32776 arg1 = wxString_in_helper(obj0);
32777 if (arg1 == NULL) SWIG_fail;
32778 temp1 = true;
32779 }
32780 }
32781 {
32782 PyThreadState* __tstate = wxPyBeginAllowThreads();
32783 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32784 wxPyEndAllowThreads(__tstate);
32785 if (PyErr_Occurred()) SWIG_fail;
32786 }
32787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32788 {
32789 if (temp1)
32790 delete arg1;
32791 }
32792 return resultobj;
32793 fail:
32794 {
32795 if (temp1)
32796 delete arg1;
32797 }
32798 return NULL;
32799 }
32800
32801
32802 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32803 PyObject *resultobj = 0;
32804 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32805 size_t result;
32806 void *argp1 = 0 ;
32807 int res1 = 0 ;
32808 PyObject *swig_obj[1] ;
32809
32810 if (!args) SWIG_fail;
32811 swig_obj[0] = args;
32812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32813 if (!SWIG_IsOK(res1)) {
32814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32815 }
32816 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32817 {
32818 PyThreadState* __tstate = wxPyBeginAllowThreads();
32819 result = (size_t)(arg1)->GetTextLength();
32820 wxPyEndAllowThreads(__tstate);
32821 if (PyErr_Occurred()) SWIG_fail;
32822 }
32823 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32824 return resultobj;
32825 fail:
32826 return NULL;
32827 }
32828
32829
32830 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32831 PyObject *resultobj = 0;
32832 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32833 wxString result;
32834 void *argp1 = 0 ;
32835 int res1 = 0 ;
32836 PyObject *swig_obj[1] ;
32837
32838 if (!args) SWIG_fail;
32839 swig_obj[0] = args;
32840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32841 if (!SWIG_IsOK(res1)) {
32842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32843 }
32844 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32845 {
32846 PyThreadState* __tstate = wxPyBeginAllowThreads();
32847 result = (arg1)->GetText();
32848 wxPyEndAllowThreads(__tstate);
32849 if (PyErr_Occurred()) SWIG_fail;
32850 }
32851 {
32852 #if wxUSE_UNICODE
32853 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32854 #else
32855 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32856 #endif
32857 }
32858 return resultobj;
32859 fail:
32860 return NULL;
32861 }
32862
32863
32864 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32865 PyObject *resultobj = 0;
32866 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32867 wxString *arg2 = 0 ;
32868 void *argp1 = 0 ;
32869 int res1 = 0 ;
32870 bool temp2 = false ;
32871 PyObject * obj0 = 0 ;
32872 PyObject * obj1 = 0 ;
32873 char * kwnames[] = {
32874 (char *) "self",(char *) "text", NULL
32875 };
32876
32877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32879 if (!SWIG_IsOK(res1)) {
32880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32881 }
32882 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32883 {
32884 arg2 = wxString_in_helper(obj1);
32885 if (arg2 == NULL) SWIG_fail;
32886 temp2 = true;
32887 }
32888 {
32889 PyThreadState* __tstate = wxPyBeginAllowThreads();
32890 (arg1)->SetText((wxString const &)*arg2);
32891 wxPyEndAllowThreads(__tstate);
32892 if (PyErr_Occurred()) SWIG_fail;
32893 }
32894 resultobj = SWIG_Py_Void();
32895 {
32896 if (temp2)
32897 delete arg2;
32898 }
32899 return resultobj;
32900 fail:
32901 {
32902 if (temp2)
32903 delete arg2;
32904 }
32905 return NULL;
32906 }
32907
32908
32909 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32910 PyObject *obj;
32911 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32912 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32913 return SWIG_Py_Void();
32914 }
32915
32916 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32917 return SWIG_Python_InitShadowInstance(args);
32918 }
32919
32920 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32921 PyObject *resultobj = 0;
32922 wxString const &arg1_defvalue = wxPyEmptyString ;
32923 wxString *arg1 = (wxString *) &arg1_defvalue ;
32924 wxPyTextDataObject *result = 0 ;
32925 bool temp1 = false ;
32926 PyObject * obj0 = 0 ;
32927 char * kwnames[] = {
32928 (char *) "text", NULL
32929 };
32930
32931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32932 if (obj0) {
32933 {
32934 arg1 = wxString_in_helper(obj0);
32935 if (arg1 == NULL) SWIG_fail;
32936 temp1 = true;
32937 }
32938 }
32939 {
32940 PyThreadState* __tstate = wxPyBeginAllowThreads();
32941 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32942 wxPyEndAllowThreads(__tstate);
32943 if (PyErr_Occurred()) SWIG_fail;
32944 }
32945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32946 {
32947 if (temp1)
32948 delete arg1;
32949 }
32950 return resultobj;
32951 fail:
32952 {
32953 if (temp1)
32954 delete arg1;
32955 }
32956 return NULL;
32957 }
32958
32959
32960 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32961 PyObject *resultobj = 0;
32962 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32963 PyObject *arg2 = (PyObject *) 0 ;
32964 PyObject *arg3 = (PyObject *) 0 ;
32965 void *argp1 = 0 ;
32966 int res1 = 0 ;
32967 PyObject * obj0 = 0 ;
32968 PyObject * obj1 = 0 ;
32969 PyObject * obj2 = 0 ;
32970 char * kwnames[] = {
32971 (char *) "self",(char *) "self",(char *) "_class", NULL
32972 };
32973
32974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32976 if (!SWIG_IsOK(res1)) {
32977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32978 }
32979 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32980 arg2 = obj1;
32981 arg3 = obj2;
32982 {
32983 PyThreadState* __tstate = wxPyBeginAllowThreads();
32984 (arg1)->_setCallbackInfo(arg2,arg3);
32985 wxPyEndAllowThreads(__tstate);
32986 if (PyErr_Occurred()) SWIG_fail;
32987 }
32988 resultobj = SWIG_Py_Void();
32989 return resultobj;
32990 fail:
32991 return NULL;
32992 }
32993
32994
32995 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32996 PyObject *obj;
32997 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32998 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32999 return SWIG_Py_Void();
33000 }
33001
33002 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33003 return SWIG_Python_InitShadowInstance(args);
33004 }
33005
33006 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33007 PyObject *resultobj = 0;
33008 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33009 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33010 wxBitmapDataObject *result = 0 ;
33011 void *argp1 = 0 ;
33012 int res1 = 0 ;
33013 PyObject * obj0 = 0 ;
33014 char * kwnames[] = {
33015 (char *) "bitmap", NULL
33016 };
33017
33018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
33019 if (obj0) {
33020 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33021 if (!SWIG_IsOK(res1)) {
33022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33023 }
33024 if (!argp1) {
33025 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33026 }
33027 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33028 }
33029 {
33030 PyThreadState* __tstate = wxPyBeginAllowThreads();
33031 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
33032 wxPyEndAllowThreads(__tstate);
33033 if (PyErr_Occurred()) SWIG_fail;
33034 }
33035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
33036 return resultobj;
33037 fail:
33038 return NULL;
33039 }
33040
33041
33042 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33043 PyObject *resultobj = 0;
33044 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33045 wxBitmap result;
33046 void *argp1 = 0 ;
33047 int res1 = 0 ;
33048 PyObject *swig_obj[1] ;
33049
33050 if (!args) SWIG_fail;
33051 swig_obj[0] = args;
33052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33053 if (!SWIG_IsOK(res1)) {
33054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
33055 }
33056 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33057 {
33058 PyThreadState* __tstate = wxPyBeginAllowThreads();
33059 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
33060 wxPyEndAllowThreads(__tstate);
33061 if (PyErr_Occurred()) SWIG_fail;
33062 }
33063 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
33064 return resultobj;
33065 fail:
33066 return NULL;
33067 }
33068
33069
33070 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33071 PyObject *resultobj = 0;
33072 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33073 wxBitmap *arg2 = 0 ;
33074 void *argp1 = 0 ;
33075 int res1 = 0 ;
33076 void *argp2 = 0 ;
33077 int res2 = 0 ;
33078 PyObject * obj0 = 0 ;
33079 PyObject * obj1 = 0 ;
33080 char * kwnames[] = {
33081 (char *) "self",(char *) "bitmap", NULL
33082 };
33083
33084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
33085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33086 if (!SWIG_IsOK(res1)) {
33087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
33088 }
33089 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33090 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
33091 if (!SWIG_IsOK(res2)) {
33092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33093 }
33094 if (!argp2) {
33095 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33096 }
33097 arg2 = reinterpret_cast< wxBitmap * >(argp2);
33098 {
33099 PyThreadState* __tstate = wxPyBeginAllowThreads();
33100 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33101 wxPyEndAllowThreads(__tstate);
33102 if (PyErr_Occurred()) SWIG_fail;
33103 }
33104 resultobj = SWIG_Py_Void();
33105 return resultobj;
33106 fail:
33107 return NULL;
33108 }
33109
33110
33111 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33112 PyObject *obj;
33113 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33114 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33115 return SWIG_Py_Void();
33116 }
33117
33118 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33119 return SWIG_Python_InitShadowInstance(args);
33120 }
33121
33122 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33123 PyObject *resultobj = 0;
33124 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33125 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33126 wxPyBitmapDataObject *result = 0 ;
33127 void *argp1 = 0 ;
33128 int res1 = 0 ;
33129 PyObject * obj0 = 0 ;
33130 char * kwnames[] = {
33131 (char *) "bitmap", NULL
33132 };
33133
33134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33135 if (obj0) {
33136 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33137 if (!SWIG_IsOK(res1)) {
33138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33139 }
33140 if (!argp1) {
33141 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33142 }
33143 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33144 }
33145 {
33146 PyThreadState* __tstate = wxPyBeginAllowThreads();
33147 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33148 wxPyEndAllowThreads(__tstate);
33149 if (PyErr_Occurred()) SWIG_fail;
33150 }
33151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33152 return resultobj;
33153 fail:
33154 return NULL;
33155 }
33156
33157
33158 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33159 PyObject *resultobj = 0;
33160 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33161 PyObject *arg2 = (PyObject *) 0 ;
33162 PyObject *arg3 = (PyObject *) 0 ;
33163 void *argp1 = 0 ;
33164 int res1 = 0 ;
33165 PyObject * obj0 = 0 ;
33166 PyObject * obj1 = 0 ;
33167 PyObject * obj2 = 0 ;
33168 char * kwnames[] = {
33169 (char *) "self",(char *) "self",(char *) "_class", NULL
33170 };
33171
33172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33174 if (!SWIG_IsOK(res1)) {
33175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33176 }
33177 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33178 arg2 = obj1;
33179 arg3 = obj2;
33180 {
33181 PyThreadState* __tstate = wxPyBeginAllowThreads();
33182 (arg1)->_setCallbackInfo(arg2,arg3);
33183 wxPyEndAllowThreads(__tstate);
33184 if (PyErr_Occurred()) SWIG_fail;
33185 }
33186 resultobj = SWIG_Py_Void();
33187 return resultobj;
33188 fail:
33189 return NULL;
33190 }
33191
33192
33193 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33194 PyObject *obj;
33195 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33196 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33197 return SWIG_Py_Void();
33198 }
33199
33200 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33201 return SWIG_Python_InitShadowInstance(args);
33202 }
33203
33204 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33205 PyObject *resultobj = 0;
33206 wxFileDataObject *result = 0 ;
33207
33208 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33209 {
33210 PyThreadState* __tstate = wxPyBeginAllowThreads();
33211 result = (wxFileDataObject *)new wxFileDataObject();
33212 wxPyEndAllowThreads(__tstate);
33213 if (PyErr_Occurred()) SWIG_fail;
33214 }
33215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33216 return resultobj;
33217 fail:
33218 return NULL;
33219 }
33220
33221
33222 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33223 PyObject *resultobj = 0;
33224 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33225 wxArrayString *result = 0 ;
33226 void *argp1 = 0 ;
33227 int res1 = 0 ;
33228 PyObject *swig_obj[1] ;
33229
33230 if (!args) SWIG_fail;
33231 swig_obj[0] = args;
33232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33233 if (!SWIG_IsOK(res1)) {
33234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33235 }
33236 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33237 {
33238 PyThreadState* __tstate = wxPyBeginAllowThreads();
33239 {
33240 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33241 result = (wxArrayString *) &_result_ref;
33242 }
33243 wxPyEndAllowThreads(__tstate);
33244 if (PyErr_Occurred()) SWIG_fail;
33245 }
33246 {
33247 resultobj = wxArrayString2PyList_helper(*result);
33248 }
33249 return resultobj;
33250 fail:
33251 return NULL;
33252 }
33253
33254
33255 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33256 PyObject *resultobj = 0;
33257 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33258 wxString *arg2 = 0 ;
33259 void *argp1 = 0 ;
33260 int res1 = 0 ;
33261 bool temp2 = false ;
33262 PyObject * obj0 = 0 ;
33263 PyObject * obj1 = 0 ;
33264 char * kwnames[] = {
33265 (char *) "self",(char *) "filename", NULL
33266 };
33267
33268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33270 if (!SWIG_IsOK(res1)) {
33271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33272 }
33273 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33274 {
33275 arg2 = wxString_in_helper(obj1);
33276 if (arg2 == NULL) SWIG_fail;
33277 temp2 = true;
33278 }
33279 {
33280 PyThreadState* __tstate = wxPyBeginAllowThreads();
33281 (arg1)->AddFile((wxString const &)*arg2);
33282 wxPyEndAllowThreads(__tstate);
33283 if (PyErr_Occurred()) SWIG_fail;
33284 }
33285 resultobj = SWIG_Py_Void();
33286 {
33287 if (temp2)
33288 delete arg2;
33289 }
33290 return resultobj;
33291 fail:
33292 {
33293 if (temp2)
33294 delete arg2;
33295 }
33296 return NULL;
33297 }
33298
33299
33300 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33301 PyObject *obj;
33302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33303 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33304 return SWIG_Py_Void();
33305 }
33306
33307 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33308 return SWIG_Python_InitShadowInstance(args);
33309 }
33310
33311 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33312 PyObject *resultobj = 0;
33313 wxDataFormat *arg1 = 0 ;
33314 wxCustomDataObject *result = 0 ;
33315 void *argp1 = 0 ;
33316 int res1 = 0 ;
33317
33318 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33320 if (!SWIG_IsOK(res1)) {
33321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33322 }
33323 if (!argp1) {
33324 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33325 }
33326 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33327 {
33328 PyThreadState* __tstate = wxPyBeginAllowThreads();
33329 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33330 wxPyEndAllowThreads(__tstate);
33331 if (PyErr_Occurred()) SWIG_fail;
33332 }
33333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33334 return resultobj;
33335 fail:
33336 return NULL;
33337 }
33338
33339
33340 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33341 PyObject *resultobj = 0;
33342 wxString *arg1 = 0 ;
33343 wxCustomDataObject *result = 0 ;
33344 bool temp1 = false ;
33345
33346 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33347 {
33348 arg1 = wxString_in_helper(swig_obj[0]);
33349 if (arg1 == NULL) SWIG_fail;
33350 temp1 = true;
33351 }
33352 {
33353 PyThreadState* __tstate = wxPyBeginAllowThreads();
33354 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33355 wxPyEndAllowThreads(__tstate);
33356 if (PyErr_Occurred()) SWIG_fail;
33357 }
33358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33359 {
33360 if (temp1)
33361 delete arg1;
33362 }
33363 return resultobj;
33364 fail:
33365 {
33366 if (temp1)
33367 delete arg1;
33368 }
33369 return NULL;
33370 }
33371
33372
33373 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33374 PyObject *resultobj = 0;
33375 wxCustomDataObject *result = 0 ;
33376
33377 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33378 {
33379 PyThreadState* __tstate = wxPyBeginAllowThreads();
33380 result = (wxCustomDataObject *)new wxCustomDataObject();
33381 wxPyEndAllowThreads(__tstate);
33382 if (PyErr_Occurred()) SWIG_fail;
33383 }
33384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33385 return resultobj;
33386 fail:
33387 return NULL;
33388 }
33389
33390
33391 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33392 int argc;
33393 PyObject *argv[2];
33394
33395 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33396 --argc;
33397 if (argc == 0) {
33398 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33399 }
33400 if (argc == 1) {
33401 int _v = 0;
33402 {
33403 {
33404 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33405 }
33406 }
33407 if (!_v) goto check_2;
33408 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33409 }
33410 check_2:
33411
33412 if (argc == 1) {
33413 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33414 }
33415
33416 fail:
33417 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33418 return NULL;
33419 }
33420
33421
33422 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33423 PyObject *resultobj = 0;
33424 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33425 PyObject *arg2 = (PyObject *) 0 ;
33426 bool result;
33427 void *argp1 = 0 ;
33428 int res1 = 0 ;
33429 PyObject * obj0 = 0 ;
33430 PyObject * obj1 = 0 ;
33431 char * kwnames[] = {
33432 (char *) "self",(char *) "data", NULL
33433 };
33434
33435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33437 if (!SWIG_IsOK(res1)) {
33438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33439 }
33440 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33441 arg2 = obj1;
33442 {
33443 PyThreadState* __tstate = wxPyBeginAllowThreads();
33444 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33445 wxPyEndAllowThreads(__tstate);
33446 if (PyErr_Occurred()) SWIG_fail;
33447 }
33448 {
33449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33450 }
33451 return resultobj;
33452 fail:
33453 return NULL;
33454 }
33455
33456
33457 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33458 PyObject *resultobj = 0;
33459 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33460 size_t result;
33461 void *argp1 = 0 ;
33462 int res1 = 0 ;
33463 PyObject *swig_obj[1] ;
33464
33465 if (!args) SWIG_fail;
33466 swig_obj[0] = args;
33467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33468 if (!SWIG_IsOK(res1)) {
33469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33470 }
33471 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33472 {
33473 PyThreadState* __tstate = wxPyBeginAllowThreads();
33474 result = (size_t)(arg1)->GetSize();
33475 wxPyEndAllowThreads(__tstate);
33476 if (PyErr_Occurred()) SWIG_fail;
33477 }
33478 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33479 return resultobj;
33480 fail:
33481 return NULL;
33482 }
33483
33484
33485 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33486 PyObject *resultobj = 0;
33487 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33488 PyObject *result = 0 ;
33489 void *argp1 = 0 ;
33490 int res1 = 0 ;
33491 PyObject *swig_obj[1] ;
33492
33493 if (!args) SWIG_fail;
33494 swig_obj[0] = args;
33495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33496 if (!SWIG_IsOK(res1)) {
33497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33498 }
33499 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33500 {
33501 PyThreadState* __tstate = wxPyBeginAllowThreads();
33502 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33503 wxPyEndAllowThreads(__tstate);
33504 if (PyErr_Occurred()) SWIG_fail;
33505 }
33506 resultobj = result;
33507 return resultobj;
33508 fail:
33509 return NULL;
33510 }
33511
33512
33513 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33514 PyObject *obj;
33515 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33516 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33517 return SWIG_Py_Void();
33518 }
33519
33520 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33521 return SWIG_Python_InitShadowInstance(args);
33522 }
33523
33524 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33525 PyObject *resultobj = 0;
33526 wxString const &arg1_defvalue = wxPyEmptyString ;
33527 wxString *arg1 = (wxString *) &arg1_defvalue ;
33528 wxURLDataObject *result = 0 ;
33529 bool temp1 = false ;
33530 PyObject * obj0 = 0 ;
33531 char * kwnames[] = {
33532 (char *) "url", NULL
33533 };
33534
33535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33536 if (obj0) {
33537 {
33538 arg1 = wxString_in_helper(obj0);
33539 if (arg1 == NULL) SWIG_fail;
33540 temp1 = true;
33541 }
33542 }
33543 {
33544 PyThreadState* __tstate = wxPyBeginAllowThreads();
33545 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33546 wxPyEndAllowThreads(__tstate);
33547 if (PyErr_Occurred()) SWIG_fail;
33548 }
33549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33550 {
33551 if (temp1)
33552 delete arg1;
33553 }
33554 return resultobj;
33555 fail:
33556 {
33557 if (temp1)
33558 delete arg1;
33559 }
33560 return NULL;
33561 }
33562
33563
33564 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33565 PyObject *resultobj = 0;
33566 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33567 wxString result;
33568 void *argp1 = 0 ;
33569 int res1 = 0 ;
33570 PyObject *swig_obj[1] ;
33571
33572 if (!args) SWIG_fail;
33573 swig_obj[0] = args;
33574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33575 if (!SWIG_IsOK(res1)) {
33576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33577 }
33578 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33579 {
33580 PyThreadState* __tstate = wxPyBeginAllowThreads();
33581 result = (arg1)->GetURL();
33582 wxPyEndAllowThreads(__tstate);
33583 if (PyErr_Occurred()) SWIG_fail;
33584 }
33585 {
33586 #if wxUSE_UNICODE
33587 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33588 #else
33589 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33590 #endif
33591 }
33592 return resultobj;
33593 fail:
33594 return NULL;
33595 }
33596
33597
33598 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33599 PyObject *resultobj = 0;
33600 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33601 wxString *arg2 = 0 ;
33602 void *argp1 = 0 ;
33603 int res1 = 0 ;
33604 bool temp2 = false ;
33605 PyObject * obj0 = 0 ;
33606 PyObject * obj1 = 0 ;
33607 char * kwnames[] = {
33608 (char *) "self",(char *) "url", NULL
33609 };
33610
33611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33613 if (!SWIG_IsOK(res1)) {
33614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33615 }
33616 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33617 {
33618 arg2 = wxString_in_helper(obj1);
33619 if (arg2 == NULL) SWIG_fail;
33620 temp2 = true;
33621 }
33622 {
33623 PyThreadState* __tstate = wxPyBeginAllowThreads();
33624 (arg1)->SetURL((wxString const &)*arg2);
33625 wxPyEndAllowThreads(__tstate);
33626 if (PyErr_Occurred()) SWIG_fail;
33627 }
33628 resultobj = SWIG_Py_Void();
33629 {
33630 if (temp2)
33631 delete arg2;
33632 }
33633 return resultobj;
33634 fail:
33635 {
33636 if (temp2)
33637 delete arg2;
33638 }
33639 return NULL;
33640 }
33641
33642
33643 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33644 PyObject *obj;
33645 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33646 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33647 return SWIG_Py_Void();
33648 }
33649
33650 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33651 return SWIG_Python_InitShadowInstance(args);
33652 }
33653
33654 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33655 PyObject *resultobj = 0;
33656 wxMetafileDataObject *result = 0 ;
33657
33658 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33659 {
33660 PyThreadState* __tstate = wxPyBeginAllowThreads();
33661 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33662 wxPyEndAllowThreads(__tstate);
33663 if (PyErr_Occurred()) SWIG_fail;
33664 }
33665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33666 return resultobj;
33667 fail:
33668 return NULL;
33669 }
33670
33671
33672 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33673 PyObject *resultobj = 0;
33674 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33675 wxMetafile *arg2 = 0 ;
33676 void *argp1 = 0 ;
33677 int res1 = 0 ;
33678 void *argp2 = 0 ;
33679 int res2 = 0 ;
33680 PyObject * obj0 = 0 ;
33681 PyObject * obj1 = 0 ;
33682 char * kwnames[] = {
33683 (char *) "self",(char *) "metafile", NULL
33684 };
33685
33686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
33687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33688 if (!SWIG_IsOK(res1)) {
33689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
33690 }
33691 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33692 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
33693 if (!SWIG_IsOK(res2)) {
33694 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33695 }
33696 if (!argp2) {
33697 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33698 }
33699 arg2 = reinterpret_cast< wxMetafile * >(argp2);
33700 {
33701 PyThreadState* __tstate = wxPyBeginAllowThreads();
33702 (arg1)->SetMetafile((wxMetafile const &)*arg2);
33703 wxPyEndAllowThreads(__tstate);
33704 if (PyErr_Occurred()) SWIG_fail;
33705 }
33706 resultobj = SWIG_Py_Void();
33707 return resultobj;
33708 fail:
33709 return NULL;
33710 }
33711
33712
33713 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33714 PyObject *resultobj = 0;
33715 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33716 wxMetafile result;
33717 void *argp1 = 0 ;
33718 int res1 = 0 ;
33719 PyObject *swig_obj[1] ;
33720
33721 if (!args) SWIG_fail;
33722 swig_obj[0] = args;
33723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33724 if (!SWIG_IsOK(res1)) {
33725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
33726 }
33727 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33728 {
33729 PyThreadState* __tstate = wxPyBeginAllowThreads();
33730 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
33731 wxPyEndAllowThreads(__tstate);
33732 if (PyErr_Occurred()) SWIG_fail;
33733 }
33734 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
33735 return resultobj;
33736 fail:
33737 return NULL;
33738 }
33739
33740
33741 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33742 PyObject *obj;
33743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33744 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33745 return SWIG_Py_Void();
33746 }
33747
33748 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33749 return SWIG_Python_InitShadowInstance(args);
33750 }
33751
33752 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33753 PyObject *resultobj = 0;
33754 wxDragResult arg1 ;
33755 bool result;
33756 int val1 ;
33757 int ecode1 = 0 ;
33758 PyObject * obj0 = 0 ;
33759 char * kwnames[] = {
33760 (char *) "res", NULL
33761 };
33762
33763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33764 ecode1 = SWIG_AsVal_int(obj0, &val1);
33765 if (!SWIG_IsOK(ecode1)) {
33766 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33767 }
33768 arg1 = static_cast< wxDragResult >(val1);
33769 {
33770 PyThreadState* __tstate = wxPyBeginAllowThreads();
33771 result = (bool)wxIsDragResultOk(arg1);
33772 wxPyEndAllowThreads(__tstate);
33773 if (PyErr_Occurred()) SWIG_fail;
33774 }
33775 {
33776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33777 }
33778 return resultobj;
33779 fail:
33780 return NULL;
33781 }
33782
33783
33784 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33785 PyObject *resultobj = 0;
33786 wxWindow *arg1 = (wxWindow *) 0 ;
33787 wxCursor const &arg2_defvalue = wxNullCursor ;
33788 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
33789 wxCursor const &arg3_defvalue = wxNullCursor ;
33790 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
33791 wxCursor const &arg4_defvalue = wxNullCursor ;
33792 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
33793 wxPyDropSource *result = 0 ;
33794 void *argp1 = 0 ;
33795 int res1 = 0 ;
33796 void *argp2 = 0 ;
33797 int res2 = 0 ;
33798 void *argp3 = 0 ;
33799 int res3 = 0 ;
33800 void *argp4 = 0 ;
33801 int res4 = 0 ;
33802 PyObject * obj0 = 0 ;
33803 PyObject * obj1 = 0 ;
33804 PyObject * obj2 = 0 ;
33805 PyObject * obj3 = 0 ;
33806 char * kwnames[] = {
33807 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33808 };
33809
33810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33812 if (!SWIG_IsOK(res1)) {
33813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33814 }
33815 arg1 = reinterpret_cast< wxWindow * >(argp1);
33816 if (obj1) {
33817 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
33818 if (!SWIG_IsOK(res2)) {
33819 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33820 }
33821 if (!argp2) {
33822 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33823 }
33824 arg2 = reinterpret_cast< wxCursor * >(argp2);
33825 }
33826 if (obj2) {
33827 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33828 if (!SWIG_IsOK(res3)) {
33829 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33830 }
33831 if (!argp3) {
33832 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33833 }
33834 arg3 = reinterpret_cast< wxCursor * >(argp3);
33835 }
33836 if (obj3) {
33837 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
33838 if (!SWIG_IsOK(res4)) {
33839 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33840 }
33841 if (!argp4) {
33842 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33843 }
33844 arg4 = reinterpret_cast< wxCursor * >(argp4);
33845 }
33846 {
33847 PyThreadState* __tstate = wxPyBeginAllowThreads();
33848 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
33849 wxPyEndAllowThreads(__tstate);
33850 if (PyErr_Occurred()) SWIG_fail;
33851 }
33852 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33853 return resultobj;
33854 fail:
33855 return NULL;
33856 }
33857
33858
33859 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33860 PyObject *resultobj = 0;
33861 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33862 PyObject *arg2 = (PyObject *) 0 ;
33863 PyObject *arg3 = (PyObject *) 0 ;
33864 int arg4 = (int) 0 ;
33865 void *argp1 = 0 ;
33866 int res1 = 0 ;
33867 int val4 ;
33868 int ecode4 = 0 ;
33869 PyObject * obj0 = 0 ;
33870 PyObject * obj1 = 0 ;
33871 PyObject * obj2 = 0 ;
33872 PyObject * obj3 = 0 ;
33873 char * kwnames[] = {
33874 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33875 };
33876
33877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33879 if (!SWIG_IsOK(res1)) {
33880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33881 }
33882 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33883 arg2 = obj1;
33884 arg3 = obj2;
33885 if (obj3) {
33886 ecode4 = SWIG_AsVal_int(obj3, &val4);
33887 if (!SWIG_IsOK(ecode4)) {
33888 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33889 }
33890 arg4 = static_cast< int >(val4);
33891 }
33892 {
33893 PyThreadState* __tstate = wxPyBeginAllowThreads();
33894 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33895 wxPyEndAllowThreads(__tstate);
33896 if (PyErr_Occurred()) SWIG_fail;
33897 }
33898 resultobj = SWIG_Py_Void();
33899 return resultobj;
33900 fail:
33901 return NULL;
33902 }
33903
33904
33905 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33906 PyObject *resultobj = 0;
33907 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33908 void *argp1 = 0 ;
33909 int res1 = 0 ;
33910 PyObject *swig_obj[1] ;
33911
33912 if (!args) SWIG_fail;
33913 swig_obj[0] = args;
33914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33915 if (!SWIG_IsOK(res1)) {
33916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33917 }
33918 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33919 {
33920 PyThreadState* __tstate = wxPyBeginAllowThreads();
33921 delete arg1;
33922
33923 wxPyEndAllowThreads(__tstate);
33924 if (PyErr_Occurred()) SWIG_fail;
33925 }
33926 resultobj = SWIG_Py_Void();
33927 return resultobj;
33928 fail:
33929 return NULL;
33930 }
33931
33932
33933 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33934 PyObject *resultobj = 0;
33935 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33936 wxDataObject *arg2 = 0 ;
33937 void *argp1 = 0 ;
33938 int res1 = 0 ;
33939 void *argp2 = 0 ;
33940 int res2 = 0 ;
33941 PyObject * obj0 = 0 ;
33942 PyObject * obj1 = 0 ;
33943 char * kwnames[] = {
33944 (char *) "self",(char *) "data", NULL
33945 };
33946
33947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33949 if (!SWIG_IsOK(res1)) {
33950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33951 }
33952 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33953 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33954 if (!SWIG_IsOK(res2)) {
33955 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33956 }
33957 if (!argp2) {
33958 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33959 }
33960 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33961 {
33962 PyThreadState* __tstate = wxPyBeginAllowThreads();
33963 (arg1)->SetData(*arg2);
33964 wxPyEndAllowThreads(__tstate);
33965 if (PyErr_Occurred()) SWIG_fail;
33966 }
33967 resultobj = SWIG_Py_Void();
33968 return resultobj;
33969 fail:
33970 return NULL;
33971 }
33972
33973
33974 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33975 PyObject *resultobj = 0;
33976 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33977 wxDataObject *result = 0 ;
33978 void *argp1 = 0 ;
33979 int res1 = 0 ;
33980 PyObject *swig_obj[1] ;
33981
33982 if (!args) SWIG_fail;
33983 swig_obj[0] = args;
33984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33985 if (!SWIG_IsOK(res1)) {
33986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33987 }
33988 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33989 {
33990 PyThreadState* __tstate = wxPyBeginAllowThreads();
33991 result = (wxDataObject *)(arg1)->GetDataObject();
33992 wxPyEndAllowThreads(__tstate);
33993 if (PyErr_Occurred()) SWIG_fail;
33994 }
33995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33996 return resultobj;
33997 fail:
33998 return NULL;
33999 }
34000
34001
34002 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34003 PyObject *resultobj = 0;
34004 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34005 wxDragResult arg2 ;
34006 wxCursor *arg3 = 0 ;
34007 void *argp1 = 0 ;
34008 int res1 = 0 ;
34009 int val2 ;
34010 int ecode2 = 0 ;
34011 void *argp3 = 0 ;
34012 int res3 = 0 ;
34013 PyObject * obj0 = 0 ;
34014 PyObject * obj1 = 0 ;
34015 PyObject * obj2 = 0 ;
34016 char * kwnames[] = {
34017 (char *) "self",(char *) "res",(char *) "cursor", NULL
34018 };
34019
34020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34022 if (!SWIG_IsOK(res1)) {
34023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34024 }
34025 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34026 ecode2 = SWIG_AsVal_int(obj1, &val2);
34027 if (!SWIG_IsOK(ecode2)) {
34028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
34029 }
34030 arg2 = static_cast< wxDragResult >(val2);
34031 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
34032 if (!SWIG_IsOK(res3)) {
34033 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34034 }
34035 if (!argp3) {
34036 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34037 }
34038 arg3 = reinterpret_cast< wxCursor * >(argp3);
34039 {
34040 PyThreadState* __tstate = wxPyBeginAllowThreads();
34041 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
34042 wxPyEndAllowThreads(__tstate);
34043 if (PyErr_Occurred()) SWIG_fail;
34044 }
34045 resultobj = SWIG_Py_Void();
34046 return resultobj;
34047 fail:
34048 return NULL;
34049 }
34050
34051
34052 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34053 PyObject *resultobj = 0;
34054 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34055 int arg2 = (int) wxDrag_CopyOnly ;
34056 wxDragResult result;
34057 void *argp1 = 0 ;
34058 int res1 = 0 ;
34059 int val2 ;
34060 int ecode2 = 0 ;
34061 PyObject * obj0 = 0 ;
34062 PyObject * obj1 = 0 ;
34063 char * kwnames[] = {
34064 (char *) "self",(char *) "flags", NULL
34065 };
34066
34067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
34068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34069 if (!SWIG_IsOK(res1)) {
34070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34071 }
34072 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34073 if (obj1) {
34074 ecode2 = SWIG_AsVal_int(obj1, &val2);
34075 if (!SWIG_IsOK(ecode2)) {
34076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
34077 }
34078 arg2 = static_cast< int >(val2);
34079 }
34080 {
34081 PyThreadState* __tstate = wxPyBeginAllowThreads();
34082 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
34083 wxPyEndAllowThreads(__tstate);
34084 if (PyErr_Occurred()) SWIG_fail;
34085 }
34086 resultobj = SWIG_From_int(static_cast< int >(result));
34087 return resultobj;
34088 fail:
34089 return NULL;
34090 }
34091
34092
34093 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34094 PyObject *resultobj = 0;
34095 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34096 wxDragResult arg2 ;
34097 bool result;
34098 void *argp1 = 0 ;
34099 int res1 = 0 ;
34100 int val2 ;
34101 int ecode2 = 0 ;
34102 PyObject * obj0 = 0 ;
34103 PyObject * obj1 = 0 ;
34104 char * kwnames[] = {
34105 (char *) "self",(char *) "effect", NULL
34106 };
34107
34108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34110 if (!SWIG_IsOK(res1)) {
34111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34112 }
34113 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34114 ecode2 = SWIG_AsVal_int(obj1, &val2);
34115 if (!SWIG_IsOK(ecode2)) {
34116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34117 }
34118 arg2 = static_cast< wxDragResult >(val2);
34119 {
34120 PyThreadState* __tstate = wxPyBeginAllowThreads();
34121 result = (bool)(arg1)->GiveFeedback(arg2);
34122 wxPyEndAllowThreads(__tstate);
34123 if (PyErr_Occurred()) SWIG_fail;
34124 }
34125 {
34126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34127 }
34128 return resultobj;
34129 fail:
34130 return NULL;
34131 }
34132
34133
34134 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34135 PyObject *obj;
34136 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34137 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34138 return SWIG_Py_Void();
34139 }
34140
34141 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34142 return SWIG_Python_InitShadowInstance(args);
34143 }
34144
34145 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34146 PyObject *resultobj = 0;
34147 wxDataObject *arg1 = (wxDataObject *) NULL ;
34148 wxPyDropTarget *result = 0 ;
34149 int res1 = 0 ;
34150 PyObject * obj0 = 0 ;
34151 char * kwnames[] = {
34152 (char *) "dataObject", NULL
34153 };
34154
34155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34156 if (obj0) {
34157 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34158 if (!SWIG_IsOK(res1)) {
34159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34160 }
34161 }
34162 {
34163 PyThreadState* __tstate = wxPyBeginAllowThreads();
34164 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34165 wxPyEndAllowThreads(__tstate);
34166 if (PyErr_Occurred()) SWIG_fail;
34167 }
34168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34169 return resultobj;
34170 fail:
34171 return NULL;
34172 }
34173
34174
34175 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34176 PyObject *resultobj = 0;
34177 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34178 PyObject *arg2 = (PyObject *) 0 ;
34179 PyObject *arg3 = (PyObject *) 0 ;
34180 void *argp1 = 0 ;
34181 int res1 = 0 ;
34182 PyObject * obj0 = 0 ;
34183 PyObject * obj1 = 0 ;
34184 PyObject * obj2 = 0 ;
34185 char * kwnames[] = {
34186 (char *) "self",(char *) "self",(char *) "_class", NULL
34187 };
34188
34189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34191 if (!SWIG_IsOK(res1)) {
34192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34193 }
34194 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34195 arg2 = obj1;
34196 arg3 = obj2;
34197 {
34198 PyThreadState* __tstate = wxPyBeginAllowThreads();
34199 (arg1)->_setCallbackInfo(arg2,arg3);
34200 wxPyEndAllowThreads(__tstate);
34201 if (PyErr_Occurred()) SWIG_fail;
34202 }
34203 resultobj = SWIG_Py_Void();
34204 return resultobj;
34205 fail:
34206 return NULL;
34207 }
34208
34209
34210 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34211 PyObject *resultobj = 0;
34212 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34213 void *argp1 = 0 ;
34214 int res1 = 0 ;
34215 PyObject *swig_obj[1] ;
34216
34217 if (!args) SWIG_fail;
34218 swig_obj[0] = args;
34219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34220 if (!SWIG_IsOK(res1)) {
34221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34222 }
34223 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34224 {
34225 PyThreadState* __tstate = wxPyBeginAllowThreads();
34226 delete arg1;
34227
34228 wxPyEndAllowThreads(__tstate);
34229 if (PyErr_Occurred()) SWIG_fail;
34230 }
34231 resultobj = SWIG_Py_Void();
34232 return resultobj;
34233 fail:
34234 return NULL;
34235 }
34236
34237
34238 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34239 PyObject *resultobj = 0;
34240 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34241 wxDataObject *result = 0 ;
34242 void *argp1 = 0 ;
34243 int res1 = 0 ;
34244 PyObject *swig_obj[1] ;
34245
34246 if (!args) SWIG_fail;
34247 swig_obj[0] = args;
34248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34249 if (!SWIG_IsOK(res1)) {
34250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34251 }
34252 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34253 {
34254 PyThreadState* __tstate = wxPyBeginAllowThreads();
34255 result = (wxDataObject *)(arg1)->GetDataObject();
34256 wxPyEndAllowThreads(__tstate);
34257 if (PyErr_Occurred()) SWIG_fail;
34258 }
34259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34260 return resultobj;
34261 fail:
34262 return NULL;
34263 }
34264
34265
34266 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34267 PyObject *resultobj = 0;
34268 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34269 wxDataObject *arg2 = (wxDataObject *) 0 ;
34270 void *argp1 = 0 ;
34271 int res1 = 0 ;
34272 int res2 = 0 ;
34273 PyObject * obj0 = 0 ;
34274 PyObject * obj1 = 0 ;
34275 char * kwnames[] = {
34276 (char *) "self",(char *) "dataObject", NULL
34277 };
34278
34279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34281 if (!SWIG_IsOK(res1)) {
34282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34283 }
34284 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34285 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34286 if (!SWIG_IsOK(res2)) {
34287 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34288 }
34289 {
34290 PyThreadState* __tstate = wxPyBeginAllowThreads();
34291 (arg1)->SetDataObject(arg2);
34292 wxPyEndAllowThreads(__tstate);
34293 if (PyErr_Occurred()) SWIG_fail;
34294 }
34295 resultobj = SWIG_Py_Void();
34296 return resultobj;
34297 fail:
34298 return NULL;
34299 }
34300
34301
34302 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34303 PyObject *resultobj = 0;
34304 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34305 int arg2 ;
34306 int arg3 ;
34307 wxDragResult arg4 ;
34308 wxDragResult result;
34309 void *argp1 = 0 ;
34310 int res1 = 0 ;
34311 int val2 ;
34312 int ecode2 = 0 ;
34313 int val3 ;
34314 int ecode3 = 0 ;
34315 int val4 ;
34316 int ecode4 = 0 ;
34317 PyObject * obj0 = 0 ;
34318 PyObject * obj1 = 0 ;
34319 PyObject * obj2 = 0 ;
34320 PyObject * obj3 = 0 ;
34321 char * kwnames[] = {
34322 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34323 };
34324
34325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34327 if (!SWIG_IsOK(res1)) {
34328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34329 }
34330 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34331 ecode2 = SWIG_AsVal_int(obj1, &val2);
34332 if (!SWIG_IsOK(ecode2)) {
34333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34334 }
34335 arg2 = static_cast< int >(val2);
34336 ecode3 = SWIG_AsVal_int(obj2, &val3);
34337 if (!SWIG_IsOK(ecode3)) {
34338 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34339 }
34340 arg3 = static_cast< int >(val3);
34341 ecode4 = SWIG_AsVal_int(obj3, &val4);
34342 if (!SWIG_IsOK(ecode4)) {
34343 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34344 }
34345 arg4 = static_cast< wxDragResult >(val4);
34346 {
34347 PyThreadState* __tstate = wxPyBeginAllowThreads();
34348 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34349 wxPyEndAllowThreads(__tstate);
34350 if (PyErr_Occurred()) SWIG_fail;
34351 }
34352 resultobj = SWIG_From_int(static_cast< int >(result));
34353 return resultobj;
34354 fail:
34355 return NULL;
34356 }
34357
34358
34359 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34360 PyObject *resultobj = 0;
34361 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34362 int arg2 ;
34363 int arg3 ;
34364 wxDragResult arg4 ;
34365 wxDragResult result;
34366 void *argp1 = 0 ;
34367 int res1 = 0 ;
34368 int val2 ;
34369 int ecode2 = 0 ;
34370 int val3 ;
34371 int ecode3 = 0 ;
34372 int val4 ;
34373 int ecode4 = 0 ;
34374 PyObject * obj0 = 0 ;
34375 PyObject * obj1 = 0 ;
34376 PyObject * obj2 = 0 ;
34377 PyObject * obj3 = 0 ;
34378 char * kwnames[] = {
34379 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34380 };
34381
34382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34384 if (!SWIG_IsOK(res1)) {
34385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34386 }
34387 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34388 ecode2 = SWIG_AsVal_int(obj1, &val2);
34389 if (!SWIG_IsOK(ecode2)) {
34390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34391 }
34392 arg2 = static_cast< int >(val2);
34393 ecode3 = SWIG_AsVal_int(obj2, &val3);
34394 if (!SWIG_IsOK(ecode3)) {
34395 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34396 }
34397 arg3 = static_cast< int >(val3);
34398 ecode4 = SWIG_AsVal_int(obj3, &val4);
34399 if (!SWIG_IsOK(ecode4)) {
34400 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34401 }
34402 arg4 = static_cast< wxDragResult >(val4);
34403 {
34404 PyThreadState* __tstate = wxPyBeginAllowThreads();
34405 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34406 wxPyEndAllowThreads(__tstate);
34407 if (PyErr_Occurred()) SWIG_fail;
34408 }
34409 resultobj = SWIG_From_int(static_cast< int >(result));
34410 return resultobj;
34411 fail:
34412 return NULL;
34413 }
34414
34415
34416 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34417 PyObject *resultobj = 0;
34418 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34419 void *argp1 = 0 ;
34420 int res1 = 0 ;
34421 PyObject *swig_obj[1] ;
34422
34423 if (!args) SWIG_fail;
34424 swig_obj[0] = args;
34425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34426 if (!SWIG_IsOK(res1)) {
34427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34428 }
34429 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34430 {
34431 PyThreadState* __tstate = wxPyBeginAllowThreads();
34432 (arg1)->OnLeave();
34433 wxPyEndAllowThreads(__tstate);
34434 if (PyErr_Occurred()) SWIG_fail;
34435 }
34436 resultobj = SWIG_Py_Void();
34437 return resultobj;
34438 fail:
34439 return NULL;
34440 }
34441
34442
34443 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34444 PyObject *resultobj = 0;
34445 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34446 int arg2 ;
34447 int arg3 ;
34448 bool result;
34449 void *argp1 = 0 ;
34450 int res1 = 0 ;
34451 int val2 ;
34452 int ecode2 = 0 ;
34453 int val3 ;
34454 int ecode3 = 0 ;
34455 PyObject * obj0 = 0 ;
34456 PyObject * obj1 = 0 ;
34457 PyObject * obj2 = 0 ;
34458 char * kwnames[] = {
34459 (char *) "self",(char *) "x",(char *) "y", NULL
34460 };
34461
34462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34464 if (!SWIG_IsOK(res1)) {
34465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34466 }
34467 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34468 ecode2 = SWIG_AsVal_int(obj1, &val2);
34469 if (!SWIG_IsOK(ecode2)) {
34470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34471 }
34472 arg2 = static_cast< int >(val2);
34473 ecode3 = SWIG_AsVal_int(obj2, &val3);
34474 if (!SWIG_IsOK(ecode3)) {
34475 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34476 }
34477 arg3 = static_cast< int >(val3);
34478 {
34479 PyThreadState* __tstate = wxPyBeginAllowThreads();
34480 result = (bool)(arg1)->OnDrop(arg2,arg3);
34481 wxPyEndAllowThreads(__tstate);
34482 if (PyErr_Occurred()) SWIG_fail;
34483 }
34484 {
34485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34486 }
34487 return resultobj;
34488 fail:
34489 return NULL;
34490 }
34491
34492
34493 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34494 PyObject *resultobj = 0;
34495 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34496 bool result;
34497 void *argp1 = 0 ;
34498 int res1 = 0 ;
34499 PyObject *swig_obj[1] ;
34500
34501 if (!args) SWIG_fail;
34502 swig_obj[0] = args;
34503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34504 if (!SWIG_IsOK(res1)) {
34505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34506 }
34507 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34508 {
34509 PyThreadState* __tstate = wxPyBeginAllowThreads();
34510 result = (bool)(arg1)->GetData();
34511 wxPyEndAllowThreads(__tstate);
34512 if (PyErr_Occurred()) SWIG_fail;
34513 }
34514 {
34515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34516 }
34517 return resultobj;
34518 fail:
34519 return NULL;
34520 }
34521
34522
34523 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34524 PyObject *resultobj = 0;
34525 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34526 wxDragResult arg2 ;
34527 void *argp1 = 0 ;
34528 int res1 = 0 ;
34529 int val2 ;
34530 int ecode2 = 0 ;
34531 PyObject * obj0 = 0 ;
34532 PyObject * obj1 = 0 ;
34533 char * kwnames[] = {
34534 (char *) "self",(char *) "action", NULL
34535 };
34536
34537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34539 if (!SWIG_IsOK(res1)) {
34540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34541 }
34542 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34543 ecode2 = SWIG_AsVal_int(obj1, &val2);
34544 if (!SWIG_IsOK(ecode2)) {
34545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34546 }
34547 arg2 = static_cast< wxDragResult >(val2);
34548 {
34549 PyThreadState* __tstate = wxPyBeginAllowThreads();
34550 (arg1)->SetDefaultAction(arg2);
34551 wxPyEndAllowThreads(__tstate);
34552 if (PyErr_Occurred()) SWIG_fail;
34553 }
34554 resultobj = SWIG_Py_Void();
34555 return resultobj;
34556 fail:
34557 return NULL;
34558 }
34559
34560
34561 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34562 PyObject *resultobj = 0;
34563 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34564 wxDragResult result;
34565 void *argp1 = 0 ;
34566 int res1 = 0 ;
34567 PyObject *swig_obj[1] ;
34568
34569 if (!args) SWIG_fail;
34570 swig_obj[0] = args;
34571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34572 if (!SWIG_IsOK(res1)) {
34573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34574 }
34575 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34576 {
34577 PyThreadState* __tstate = wxPyBeginAllowThreads();
34578 result = (wxDragResult)(arg1)->GetDefaultAction();
34579 wxPyEndAllowThreads(__tstate);
34580 if (PyErr_Occurred()) SWIG_fail;
34581 }
34582 resultobj = SWIG_From_int(static_cast< int >(result));
34583 return resultobj;
34584 fail:
34585 return NULL;
34586 }
34587
34588
34589 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34590 PyObject *obj;
34591 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34592 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34593 return SWIG_Py_Void();
34594 }
34595
34596 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34597 return SWIG_Python_InitShadowInstance(args);
34598 }
34599
34600 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34601 PyObject *resultobj = 0;
34602 wxPyTextDropTarget *result = 0 ;
34603
34604 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34605 {
34606 PyThreadState* __tstate = wxPyBeginAllowThreads();
34607 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34608 wxPyEndAllowThreads(__tstate);
34609 if (PyErr_Occurred()) SWIG_fail;
34610 }
34611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34612 return resultobj;
34613 fail:
34614 return NULL;
34615 }
34616
34617
34618 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34619 PyObject *resultobj = 0;
34620 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34621 PyObject *arg2 = (PyObject *) 0 ;
34622 PyObject *arg3 = (PyObject *) 0 ;
34623 void *argp1 = 0 ;
34624 int res1 = 0 ;
34625 PyObject * obj0 = 0 ;
34626 PyObject * obj1 = 0 ;
34627 PyObject * obj2 = 0 ;
34628 char * kwnames[] = {
34629 (char *) "self",(char *) "self",(char *) "_class", NULL
34630 };
34631
34632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34634 if (!SWIG_IsOK(res1)) {
34635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34636 }
34637 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34638 arg2 = obj1;
34639 arg3 = obj2;
34640 {
34641 PyThreadState* __tstate = wxPyBeginAllowThreads();
34642 (arg1)->_setCallbackInfo(arg2,arg3);
34643 wxPyEndAllowThreads(__tstate);
34644 if (PyErr_Occurred()) SWIG_fail;
34645 }
34646 resultobj = SWIG_Py_Void();
34647 return resultobj;
34648 fail:
34649 return NULL;
34650 }
34651
34652
34653 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34654 PyObject *resultobj = 0;
34655 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34656 int arg2 ;
34657 int arg3 ;
34658 wxString *arg4 = 0 ;
34659 bool result;
34660 void *argp1 = 0 ;
34661 int res1 = 0 ;
34662 int val2 ;
34663 int ecode2 = 0 ;
34664 int val3 ;
34665 int ecode3 = 0 ;
34666 bool temp4 = false ;
34667 PyObject * obj0 = 0 ;
34668 PyObject * obj1 = 0 ;
34669 PyObject * obj2 = 0 ;
34670 PyObject * obj3 = 0 ;
34671 char * kwnames[] = {
34672 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34673 };
34674
34675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34677 if (!SWIG_IsOK(res1)) {
34678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34679 }
34680 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34681 ecode2 = SWIG_AsVal_int(obj1, &val2);
34682 if (!SWIG_IsOK(ecode2)) {
34683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34684 }
34685 arg2 = static_cast< int >(val2);
34686 ecode3 = SWIG_AsVal_int(obj2, &val3);
34687 if (!SWIG_IsOK(ecode3)) {
34688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34689 }
34690 arg3 = static_cast< int >(val3);
34691 {
34692 arg4 = wxString_in_helper(obj3);
34693 if (arg4 == NULL) SWIG_fail;
34694 temp4 = true;
34695 }
34696 {
34697 PyThreadState* __tstate = wxPyBeginAllowThreads();
34698 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34699 wxPyEndAllowThreads(__tstate);
34700 if (PyErr_Occurred()) SWIG_fail;
34701 }
34702 {
34703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34704 }
34705 {
34706 if (temp4)
34707 delete arg4;
34708 }
34709 return resultobj;
34710 fail:
34711 {
34712 if (temp4)
34713 delete arg4;
34714 }
34715 return NULL;
34716 }
34717
34718
34719 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34720 PyObject *resultobj = 0;
34721 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34722 int arg2 ;
34723 int arg3 ;
34724 wxDragResult arg4 ;
34725 wxDragResult result;
34726 void *argp1 = 0 ;
34727 int res1 = 0 ;
34728 int val2 ;
34729 int ecode2 = 0 ;
34730 int val3 ;
34731 int ecode3 = 0 ;
34732 int val4 ;
34733 int ecode4 = 0 ;
34734 PyObject * obj0 = 0 ;
34735 PyObject * obj1 = 0 ;
34736 PyObject * obj2 = 0 ;
34737 PyObject * obj3 = 0 ;
34738 char * kwnames[] = {
34739 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34740 };
34741
34742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34744 if (!SWIG_IsOK(res1)) {
34745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34746 }
34747 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34748 ecode2 = SWIG_AsVal_int(obj1, &val2);
34749 if (!SWIG_IsOK(ecode2)) {
34750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34751 }
34752 arg2 = static_cast< int >(val2);
34753 ecode3 = SWIG_AsVal_int(obj2, &val3);
34754 if (!SWIG_IsOK(ecode3)) {
34755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34756 }
34757 arg3 = static_cast< int >(val3);
34758 ecode4 = SWIG_AsVal_int(obj3, &val4);
34759 if (!SWIG_IsOK(ecode4)) {
34760 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34761 }
34762 arg4 = static_cast< wxDragResult >(val4);
34763 {
34764 PyThreadState* __tstate = wxPyBeginAllowThreads();
34765 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34766 wxPyEndAllowThreads(__tstate);
34767 if (PyErr_Occurred()) SWIG_fail;
34768 }
34769 resultobj = SWIG_From_int(static_cast< int >(result));
34770 return resultobj;
34771 fail:
34772 return NULL;
34773 }
34774
34775
34776 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34777 PyObject *resultobj = 0;
34778 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34779 int arg2 ;
34780 int arg3 ;
34781 wxDragResult arg4 ;
34782 wxDragResult result;
34783 void *argp1 = 0 ;
34784 int res1 = 0 ;
34785 int val2 ;
34786 int ecode2 = 0 ;
34787 int val3 ;
34788 int ecode3 = 0 ;
34789 int val4 ;
34790 int ecode4 = 0 ;
34791 PyObject * obj0 = 0 ;
34792 PyObject * obj1 = 0 ;
34793 PyObject * obj2 = 0 ;
34794 PyObject * obj3 = 0 ;
34795 char * kwnames[] = {
34796 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34797 };
34798
34799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34801 if (!SWIG_IsOK(res1)) {
34802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34803 }
34804 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34805 ecode2 = SWIG_AsVal_int(obj1, &val2);
34806 if (!SWIG_IsOK(ecode2)) {
34807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34808 }
34809 arg2 = static_cast< int >(val2);
34810 ecode3 = SWIG_AsVal_int(obj2, &val3);
34811 if (!SWIG_IsOK(ecode3)) {
34812 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34813 }
34814 arg3 = static_cast< int >(val3);
34815 ecode4 = SWIG_AsVal_int(obj3, &val4);
34816 if (!SWIG_IsOK(ecode4)) {
34817 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34818 }
34819 arg4 = static_cast< wxDragResult >(val4);
34820 {
34821 PyThreadState* __tstate = wxPyBeginAllowThreads();
34822 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34823 wxPyEndAllowThreads(__tstate);
34824 if (PyErr_Occurred()) SWIG_fail;
34825 }
34826 resultobj = SWIG_From_int(static_cast< int >(result));
34827 return resultobj;
34828 fail:
34829 return NULL;
34830 }
34831
34832
34833 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34834 PyObject *resultobj = 0;
34835 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34836 void *argp1 = 0 ;
34837 int res1 = 0 ;
34838 PyObject *swig_obj[1] ;
34839
34840 if (!args) SWIG_fail;
34841 swig_obj[0] = args;
34842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34843 if (!SWIG_IsOK(res1)) {
34844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34845 }
34846 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34847 {
34848 PyThreadState* __tstate = wxPyBeginAllowThreads();
34849 (arg1)->OnLeave();
34850 wxPyEndAllowThreads(__tstate);
34851 if (PyErr_Occurred()) SWIG_fail;
34852 }
34853 resultobj = SWIG_Py_Void();
34854 return resultobj;
34855 fail:
34856 return NULL;
34857 }
34858
34859
34860 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34861 PyObject *resultobj = 0;
34862 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34863 int arg2 ;
34864 int arg3 ;
34865 bool result;
34866 void *argp1 = 0 ;
34867 int res1 = 0 ;
34868 int val2 ;
34869 int ecode2 = 0 ;
34870 int val3 ;
34871 int ecode3 = 0 ;
34872 PyObject * obj0 = 0 ;
34873 PyObject * obj1 = 0 ;
34874 PyObject * obj2 = 0 ;
34875 char * kwnames[] = {
34876 (char *) "self",(char *) "x",(char *) "y", NULL
34877 };
34878
34879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34881 if (!SWIG_IsOK(res1)) {
34882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34883 }
34884 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34885 ecode2 = SWIG_AsVal_int(obj1, &val2);
34886 if (!SWIG_IsOK(ecode2)) {
34887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34888 }
34889 arg2 = static_cast< int >(val2);
34890 ecode3 = SWIG_AsVal_int(obj2, &val3);
34891 if (!SWIG_IsOK(ecode3)) {
34892 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34893 }
34894 arg3 = static_cast< int >(val3);
34895 {
34896 PyThreadState* __tstate = wxPyBeginAllowThreads();
34897 result = (bool)(arg1)->OnDrop(arg2,arg3);
34898 wxPyEndAllowThreads(__tstate);
34899 if (PyErr_Occurred()) SWIG_fail;
34900 }
34901 {
34902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34903 }
34904 return resultobj;
34905 fail:
34906 return NULL;
34907 }
34908
34909
34910 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34911 PyObject *resultobj = 0;
34912 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34913 int arg2 ;
34914 int arg3 ;
34915 wxDragResult arg4 ;
34916 wxDragResult result;
34917 void *argp1 = 0 ;
34918 int res1 = 0 ;
34919 int val2 ;
34920 int ecode2 = 0 ;
34921 int val3 ;
34922 int ecode3 = 0 ;
34923 int val4 ;
34924 int ecode4 = 0 ;
34925 PyObject * obj0 = 0 ;
34926 PyObject * obj1 = 0 ;
34927 PyObject * obj2 = 0 ;
34928 PyObject * obj3 = 0 ;
34929 char * kwnames[] = {
34930 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34931 };
34932
34933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34935 if (!SWIG_IsOK(res1)) {
34936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34937 }
34938 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34939 ecode2 = SWIG_AsVal_int(obj1, &val2);
34940 if (!SWIG_IsOK(ecode2)) {
34941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34942 }
34943 arg2 = static_cast< int >(val2);
34944 ecode3 = SWIG_AsVal_int(obj2, &val3);
34945 if (!SWIG_IsOK(ecode3)) {
34946 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34947 }
34948 arg3 = static_cast< int >(val3);
34949 ecode4 = SWIG_AsVal_int(obj3, &val4);
34950 if (!SWIG_IsOK(ecode4)) {
34951 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34952 }
34953 arg4 = static_cast< wxDragResult >(val4);
34954 {
34955 PyThreadState* __tstate = wxPyBeginAllowThreads();
34956 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34957 wxPyEndAllowThreads(__tstate);
34958 if (PyErr_Occurred()) SWIG_fail;
34959 }
34960 resultobj = SWIG_From_int(static_cast< int >(result));
34961 return resultobj;
34962 fail:
34963 return NULL;
34964 }
34965
34966
34967 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34968 PyObject *obj;
34969 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34970 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34971 return SWIG_Py_Void();
34972 }
34973
34974 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34975 return SWIG_Python_InitShadowInstance(args);
34976 }
34977
34978 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34979 PyObject *resultobj = 0;
34980 wxPyFileDropTarget *result = 0 ;
34981
34982 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34983 {
34984 PyThreadState* __tstate = wxPyBeginAllowThreads();
34985 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34986 wxPyEndAllowThreads(__tstate);
34987 if (PyErr_Occurred()) SWIG_fail;
34988 }
34989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34990 return resultobj;
34991 fail:
34992 return NULL;
34993 }
34994
34995
34996 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34997 PyObject *resultobj = 0;
34998 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34999 PyObject *arg2 = (PyObject *) 0 ;
35000 PyObject *arg3 = (PyObject *) 0 ;
35001 void *argp1 = 0 ;
35002 int res1 = 0 ;
35003 PyObject * obj0 = 0 ;
35004 PyObject * obj1 = 0 ;
35005 PyObject * obj2 = 0 ;
35006 char * kwnames[] = {
35007 (char *) "self",(char *) "self",(char *) "_class", NULL
35008 };
35009
35010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35012 if (!SWIG_IsOK(res1)) {
35013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35014 }
35015 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35016 arg2 = obj1;
35017 arg3 = obj2;
35018 {
35019 PyThreadState* __tstate = wxPyBeginAllowThreads();
35020 (arg1)->_setCallbackInfo(arg2,arg3);
35021 wxPyEndAllowThreads(__tstate);
35022 if (PyErr_Occurred()) SWIG_fail;
35023 }
35024 resultobj = SWIG_Py_Void();
35025 return resultobj;
35026 fail:
35027 return NULL;
35028 }
35029
35030
35031 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35032 PyObject *resultobj = 0;
35033 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35034 int arg2 ;
35035 int arg3 ;
35036 wxArrayString *arg4 = 0 ;
35037 bool result;
35038 void *argp1 = 0 ;
35039 int res1 = 0 ;
35040 int val2 ;
35041 int ecode2 = 0 ;
35042 int val3 ;
35043 int ecode3 = 0 ;
35044 bool temp4 = false ;
35045 PyObject * obj0 = 0 ;
35046 PyObject * obj1 = 0 ;
35047 PyObject * obj2 = 0 ;
35048 PyObject * obj3 = 0 ;
35049 char * kwnames[] = {
35050 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
35051 };
35052
35053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35055 if (!SWIG_IsOK(res1)) {
35056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35057 }
35058 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35059 ecode2 = SWIG_AsVal_int(obj1, &val2);
35060 if (!SWIG_IsOK(ecode2)) {
35061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
35062 }
35063 arg2 = static_cast< int >(val2);
35064 ecode3 = SWIG_AsVal_int(obj2, &val3);
35065 if (!SWIG_IsOK(ecode3)) {
35066 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
35067 }
35068 arg3 = static_cast< int >(val3);
35069 {
35070 if (! PySequence_Check(obj3)) {
35071 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
35072 SWIG_fail;
35073 }
35074 arg4 = new wxArrayString;
35075 temp4 = true;
35076 int i, len=PySequence_Length(obj3);
35077 for (i=0; i<len; i++) {
35078 PyObject* item = PySequence_GetItem(obj3, i);
35079 wxString* s = wxString_in_helper(item);
35080 if (PyErr_Occurred()) SWIG_fail;
35081 arg4->Add(*s);
35082 delete s;
35083 Py_DECREF(item);
35084 }
35085 }
35086 {
35087 PyThreadState* __tstate = wxPyBeginAllowThreads();
35088 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
35089 wxPyEndAllowThreads(__tstate);
35090 if (PyErr_Occurred()) SWIG_fail;
35091 }
35092 {
35093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35094 }
35095 {
35096 if (temp4) delete arg4;
35097 }
35098 return resultobj;
35099 fail:
35100 {
35101 if (temp4) delete arg4;
35102 }
35103 return NULL;
35104 }
35105
35106
35107 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35108 PyObject *resultobj = 0;
35109 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35110 int arg2 ;
35111 int arg3 ;
35112 wxDragResult arg4 ;
35113 wxDragResult result;
35114 void *argp1 = 0 ;
35115 int res1 = 0 ;
35116 int val2 ;
35117 int ecode2 = 0 ;
35118 int val3 ;
35119 int ecode3 = 0 ;
35120 int val4 ;
35121 int ecode4 = 0 ;
35122 PyObject * obj0 = 0 ;
35123 PyObject * obj1 = 0 ;
35124 PyObject * obj2 = 0 ;
35125 PyObject * obj3 = 0 ;
35126 char * kwnames[] = {
35127 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35128 };
35129
35130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35132 if (!SWIG_IsOK(res1)) {
35133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35134 }
35135 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35136 ecode2 = SWIG_AsVal_int(obj1, &val2);
35137 if (!SWIG_IsOK(ecode2)) {
35138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
35139 }
35140 arg2 = static_cast< int >(val2);
35141 ecode3 = SWIG_AsVal_int(obj2, &val3);
35142 if (!SWIG_IsOK(ecode3)) {
35143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
35144 }
35145 arg3 = static_cast< int >(val3);
35146 ecode4 = SWIG_AsVal_int(obj3, &val4);
35147 if (!SWIG_IsOK(ecode4)) {
35148 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35149 }
35150 arg4 = static_cast< wxDragResult >(val4);
35151 {
35152 PyThreadState* __tstate = wxPyBeginAllowThreads();
35153 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
35154 wxPyEndAllowThreads(__tstate);
35155 if (PyErr_Occurred()) SWIG_fail;
35156 }
35157 resultobj = SWIG_From_int(static_cast< int >(result));
35158 return resultobj;
35159 fail:
35160 return NULL;
35161 }
35162
35163
35164 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35165 PyObject *resultobj = 0;
35166 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35167 int arg2 ;
35168 int arg3 ;
35169 wxDragResult arg4 ;
35170 wxDragResult result;
35171 void *argp1 = 0 ;
35172 int res1 = 0 ;
35173 int val2 ;
35174 int ecode2 = 0 ;
35175 int val3 ;
35176 int ecode3 = 0 ;
35177 int val4 ;
35178 int ecode4 = 0 ;
35179 PyObject * obj0 = 0 ;
35180 PyObject * obj1 = 0 ;
35181 PyObject * obj2 = 0 ;
35182 PyObject * obj3 = 0 ;
35183 char * kwnames[] = {
35184 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35185 };
35186
35187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35189 if (!SWIG_IsOK(res1)) {
35190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35191 }
35192 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35193 ecode2 = SWIG_AsVal_int(obj1, &val2);
35194 if (!SWIG_IsOK(ecode2)) {
35195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35196 }
35197 arg2 = static_cast< int >(val2);
35198 ecode3 = SWIG_AsVal_int(obj2, &val3);
35199 if (!SWIG_IsOK(ecode3)) {
35200 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35201 }
35202 arg3 = static_cast< int >(val3);
35203 ecode4 = SWIG_AsVal_int(obj3, &val4);
35204 if (!SWIG_IsOK(ecode4)) {
35205 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35206 }
35207 arg4 = static_cast< wxDragResult >(val4);
35208 {
35209 PyThreadState* __tstate = wxPyBeginAllowThreads();
35210 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35211 wxPyEndAllowThreads(__tstate);
35212 if (PyErr_Occurred()) SWIG_fail;
35213 }
35214 resultobj = SWIG_From_int(static_cast< int >(result));
35215 return resultobj;
35216 fail:
35217 return NULL;
35218 }
35219
35220
35221 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35222 PyObject *resultobj = 0;
35223 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35224 void *argp1 = 0 ;
35225 int res1 = 0 ;
35226 PyObject *swig_obj[1] ;
35227
35228 if (!args) SWIG_fail;
35229 swig_obj[0] = args;
35230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35231 if (!SWIG_IsOK(res1)) {
35232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35233 }
35234 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35235 {
35236 PyThreadState* __tstate = wxPyBeginAllowThreads();
35237 (arg1)->OnLeave();
35238 wxPyEndAllowThreads(__tstate);
35239 if (PyErr_Occurred()) SWIG_fail;
35240 }
35241 resultobj = SWIG_Py_Void();
35242 return resultobj;
35243 fail:
35244 return NULL;
35245 }
35246
35247
35248 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35249 PyObject *resultobj = 0;
35250 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35251 int arg2 ;
35252 int arg3 ;
35253 bool result;
35254 void *argp1 = 0 ;
35255 int res1 = 0 ;
35256 int val2 ;
35257 int ecode2 = 0 ;
35258 int val3 ;
35259 int ecode3 = 0 ;
35260 PyObject * obj0 = 0 ;
35261 PyObject * obj1 = 0 ;
35262 PyObject * obj2 = 0 ;
35263 char * kwnames[] = {
35264 (char *) "self",(char *) "x",(char *) "y", NULL
35265 };
35266
35267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35269 if (!SWIG_IsOK(res1)) {
35270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35271 }
35272 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35273 ecode2 = SWIG_AsVal_int(obj1, &val2);
35274 if (!SWIG_IsOK(ecode2)) {
35275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35276 }
35277 arg2 = static_cast< int >(val2);
35278 ecode3 = SWIG_AsVal_int(obj2, &val3);
35279 if (!SWIG_IsOK(ecode3)) {
35280 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35281 }
35282 arg3 = static_cast< int >(val3);
35283 {
35284 PyThreadState* __tstate = wxPyBeginAllowThreads();
35285 result = (bool)(arg1)->OnDrop(arg2,arg3);
35286 wxPyEndAllowThreads(__tstate);
35287 if (PyErr_Occurred()) SWIG_fail;
35288 }
35289 {
35290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35291 }
35292 return resultobj;
35293 fail:
35294 return NULL;
35295 }
35296
35297
35298 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35299 PyObject *resultobj = 0;
35300 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35301 int arg2 ;
35302 int arg3 ;
35303 wxDragResult arg4 ;
35304 wxDragResult result;
35305 void *argp1 = 0 ;
35306 int res1 = 0 ;
35307 int val2 ;
35308 int ecode2 = 0 ;
35309 int val3 ;
35310 int ecode3 = 0 ;
35311 int val4 ;
35312 int ecode4 = 0 ;
35313 PyObject * obj0 = 0 ;
35314 PyObject * obj1 = 0 ;
35315 PyObject * obj2 = 0 ;
35316 PyObject * obj3 = 0 ;
35317 char * kwnames[] = {
35318 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35319 };
35320
35321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35323 if (!SWIG_IsOK(res1)) {
35324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35325 }
35326 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35327 ecode2 = SWIG_AsVal_int(obj1, &val2);
35328 if (!SWIG_IsOK(ecode2)) {
35329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35330 }
35331 arg2 = static_cast< int >(val2);
35332 ecode3 = SWIG_AsVal_int(obj2, &val3);
35333 if (!SWIG_IsOK(ecode3)) {
35334 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35335 }
35336 arg3 = static_cast< int >(val3);
35337 ecode4 = SWIG_AsVal_int(obj3, &val4);
35338 if (!SWIG_IsOK(ecode4)) {
35339 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35340 }
35341 arg4 = static_cast< wxDragResult >(val4);
35342 {
35343 PyThreadState* __tstate = wxPyBeginAllowThreads();
35344 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35345 wxPyEndAllowThreads(__tstate);
35346 if (PyErr_Occurred()) SWIG_fail;
35347 }
35348 resultobj = SWIG_From_int(static_cast< int >(result));
35349 return resultobj;
35350 fail:
35351 return NULL;
35352 }
35353
35354
35355 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35356 PyObject *obj;
35357 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35358 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35359 return SWIG_Py_Void();
35360 }
35361
35362 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35363 return SWIG_Python_InitShadowInstance(args);
35364 }
35365
35366 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35367 PyObject *resultobj = 0;
35368 wxClipboard *result = 0 ;
35369
35370 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35371 {
35372 PyThreadState* __tstate = wxPyBeginAllowThreads();
35373 result = (wxClipboard *)new wxClipboard();
35374 wxPyEndAllowThreads(__tstate);
35375 if (PyErr_Occurred()) SWIG_fail;
35376 }
35377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35378 return resultobj;
35379 fail:
35380 return NULL;
35381 }
35382
35383
35384 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35385 PyObject *resultobj = 0;
35386 wxClipboard *arg1 = (wxClipboard *) 0 ;
35387 void *argp1 = 0 ;
35388 int res1 = 0 ;
35389 PyObject *swig_obj[1] ;
35390
35391 if (!args) SWIG_fail;
35392 swig_obj[0] = args;
35393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35394 if (!SWIG_IsOK(res1)) {
35395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35396 }
35397 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35398 {
35399 PyThreadState* __tstate = wxPyBeginAllowThreads();
35400 delete arg1;
35401
35402 wxPyEndAllowThreads(__tstate);
35403 if (PyErr_Occurred()) SWIG_fail;
35404 }
35405 resultobj = SWIG_Py_Void();
35406 return resultobj;
35407 fail:
35408 return NULL;
35409 }
35410
35411
35412 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35413 PyObject *resultobj = 0;
35414 wxClipboard *arg1 = (wxClipboard *) 0 ;
35415 bool result;
35416 void *argp1 = 0 ;
35417 int res1 = 0 ;
35418 PyObject *swig_obj[1] ;
35419
35420 if (!args) SWIG_fail;
35421 swig_obj[0] = args;
35422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35423 if (!SWIG_IsOK(res1)) {
35424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35425 }
35426 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35427 {
35428 PyThreadState* __tstate = wxPyBeginAllowThreads();
35429 result = (bool)(arg1)->Open();
35430 wxPyEndAllowThreads(__tstate);
35431 if (PyErr_Occurred()) SWIG_fail;
35432 }
35433 {
35434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35435 }
35436 return resultobj;
35437 fail:
35438 return NULL;
35439 }
35440
35441
35442 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35443 PyObject *resultobj = 0;
35444 wxClipboard *arg1 = (wxClipboard *) 0 ;
35445 void *argp1 = 0 ;
35446 int res1 = 0 ;
35447 PyObject *swig_obj[1] ;
35448
35449 if (!args) SWIG_fail;
35450 swig_obj[0] = args;
35451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35452 if (!SWIG_IsOK(res1)) {
35453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35454 }
35455 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35456 {
35457 PyThreadState* __tstate = wxPyBeginAllowThreads();
35458 (arg1)->Close();
35459 wxPyEndAllowThreads(__tstate);
35460 if (PyErr_Occurred()) SWIG_fail;
35461 }
35462 resultobj = SWIG_Py_Void();
35463 return resultobj;
35464 fail:
35465 return NULL;
35466 }
35467
35468
35469 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35470 PyObject *resultobj = 0;
35471 wxClipboard *arg1 = (wxClipboard *) 0 ;
35472 bool result;
35473 void *argp1 = 0 ;
35474 int res1 = 0 ;
35475 PyObject *swig_obj[1] ;
35476
35477 if (!args) SWIG_fail;
35478 swig_obj[0] = args;
35479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35480 if (!SWIG_IsOK(res1)) {
35481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35482 }
35483 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35484 {
35485 PyThreadState* __tstate = wxPyBeginAllowThreads();
35486 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35487 wxPyEndAllowThreads(__tstate);
35488 if (PyErr_Occurred()) SWIG_fail;
35489 }
35490 {
35491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35492 }
35493 return resultobj;
35494 fail:
35495 return NULL;
35496 }
35497
35498
35499 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35500 PyObject *resultobj = 0;
35501 wxClipboard *arg1 = (wxClipboard *) 0 ;
35502 wxDataObject *arg2 = (wxDataObject *) 0 ;
35503 bool result;
35504 void *argp1 = 0 ;
35505 int res1 = 0 ;
35506 int res2 = 0 ;
35507 PyObject * obj0 = 0 ;
35508 PyObject * obj1 = 0 ;
35509 char * kwnames[] = {
35510 (char *) "self",(char *) "data", NULL
35511 };
35512
35513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35515 if (!SWIG_IsOK(res1)) {
35516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35517 }
35518 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35519 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35520 if (!SWIG_IsOK(res2)) {
35521 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35522 }
35523 {
35524 PyThreadState* __tstate = wxPyBeginAllowThreads();
35525 result = (bool)(arg1)->AddData(arg2);
35526 wxPyEndAllowThreads(__tstate);
35527 if (PyErr_Occurred()) SWIG_fail;
35528 }
35529 {
35530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35531 }
35532 return resultobj;
35533 fail:
35534 return NULL;
35535 }
35536
35537
35538 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35539 PyObject *resultobj = 0;
35540 wxClipboard *arg1 = (wxClipboard *) 0 ;
35541 wxDataObject *arg2 = (wxDataObject *) 0 ;
35542 bool result;
35543 void *argp1 = 0 ;
35544 int res1 = 0 ;
35545 int res2 = 0 ;
35546 PyObject * obj0 = 0 ;
35547 PyObject * obj1 = 0 ;
35548 char * kwnames[] = {
35549 (char *) "self",(char *) "data", NULL
35550 };
35551
35552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35554 if (!SWIG_IsOK(res1)) {
35555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35556 }
35557 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35558 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35559 if (!SWIG_IsOK(res2)) {
35560 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35561 }
35562 {
35563 PyThreadState* __tstate = wxPyBeginAllowThreads();
35564 result = (bool)(arg1)->SetData(arg2);
35565 wxPyEndAllowThreads(__tstate);
35566 if (PyErr_Occurred()) SWIG_fail;
35567 }
35568 {
35569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35570 }
35571 return resultobj;
35572 fail:
35573 return NULL;
35574 }
35575
35576
35577 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35578 PyObject *resultobj = 0;
35579 wxClipboard *arg1 = (wxClipboard *) 0 ;
35580 wxDataFormat *arg2 = 0 ;
35581 bool result;
35582 void *argp1 = 0 ;
35583 int res1 = 0 ;
35584 void *argp2 = 0 ;
35585 int res2 = 0 ;
35586 PyObject * obj0 = 0 ;
35587 PyObject * obj1 = 0 ;
35588 char * kwnames[] = {
35589 (char *) "self",(char *) "format", NULL
35590 };
35591
35592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35594 if (!SWIG_IsOK(res1)) {
35595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35596 }
35597 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35598 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35599 if (!SWIG_IsOK(res2)) {
35600 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35601 }
35602 if (!argp2) {
35603 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35604 }
35605 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35606 {
35607 PyThreadState* __tstate = wxPyBeginAllowThreads();
35608 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35609 wxPyEndAllowThreads(__tstate);
35610 if (PyErr_Occurred()) SWIG_fail;
35611 }
35612 {
35613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35614 }
35615 return resultobj;
35616 fail:
35617 return NULL;
35618 }
35619
35620
35621 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35622 PyObject *resultobj = 0;
35623 wxClipboard *arg1 = (wxClipboard *) 0 ;
35624 wxDataObject *arg2 = 0 ;
35625 bool result;
35626 void *argp1 = 0 ;
35627 int res1 = 0 ;
35628 void *argp2 = 0 ;
35629 int res2 = 0 ;
35630 PyObject * obj0 = 0 ;
35631 PyObject * obj1 = 0 ;
35632 char * kwnames[] = {
35633 (char *) "self",(char *) "data", NULL
35634 };
35635
35636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35638 if (!SWIG_IsOK(res1)) {
35639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35640 }
35641 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35642 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35643 if (!SWIG_IsOK(res2)) {
35644 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35645 }
35646 if (!argp2) {
35647 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35648 }
35649 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35650 {
35651 PyThreadState* __tstate = wxPyBeginAllowThreads();
35652 result = (bool)(arg1)->GetData(*arg2);
35653 wxPyEndAllowThreads(__tstate);
35654 if (PyErr_Occurred()) SWIG_fail;
35655 }
35656 {
35657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35658 }
35659 return resultobj;
35660 fail:
35661 return NULL;
35662 }
35663
35664
35665 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35666 PyObject *resultobj = 0;
35667 wxClipboard *arg1 = (wxClipboard *) 0 ;
35668 void *argp1 = 0 ;
35669 int res1 = 0 ;
35670 PyObject *swig_obj[1] ;
35671
35672 if (!args) SWIG_fail;
35673 swig_obj[0] = args;
35674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35675 if (!SWIG_IsOK(res1)) {
35676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35677 }
35678 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35679 {
35680 PyThreadState* __tstate = wxPyBeginAllowThreads();
35681 (arg1)->Clear();
35682 wxPyEndAllowThreads(__tstate);
35683 if (PyErr_Occurred()) SWIG_fail;
35684 }
35685 resultobj = SWIG_Py_Void();
35686 return resultobj;
35687 fail:
35688 return NULL;
35689 }
35690
35691
35692 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35693 PyObject *resultobj = 0;
35694 wxClipboard *arg1 = (wxClipboard *) 0 ;
35695 bool result;
35696 void *argp1 = 0 ;
35697 int res1 = 0 ;
35698 PyObject *swig_obj[1] ;
35699
35700 if (!args) SWIG_fail;
35701 swig_obj[0] = args;
35702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35703 if (!SWIG_IsOK(res1)) {
35704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35705 }
35706 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35707 {
35708 PyThreadState* __tstate = wxPyBeginAllowThreads();
35709 result = (bool)(arg1)->Flush();
35710 wxPyEndAllowThreads(__tstate);
35711 if (PyErr_Occurred()) SWIG_fail;
35712 }
35713 {
35714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35715 }
35716 return resultobj;
35717 fail:
35718 return NULL;
35719 }
35720
35721
35722 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35723 PyObject *resultobj = 0;
35724 wxClipboard *arg1 = (wxClipboard *) 0 ;
35725 bool arg2 = (bool) true ;
35726 void *argp1 = 0 ;
35727 int res1 = 0 ;
35728 bool val2 ;
35729 int ecode2 = 0 ;
35730 PyObject * obj0 = 0 ;
35731 PyObject * obj1 = 0 ;
35732 char * kwnames[] = {
35733 (char *) "self",(char *) "primary", NULL
35734 };
35735
35736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35738 if (!SWIG_IsOK(res1)) {
35739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35740 }
35741 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35742 if (obj1) {
35743 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35744 if (!SWIG_IsOK(ecode2)) {
35745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35746 }
35747 arg2 = static_cast< bool >(val2);
35748 }
35749 {
35750 PyThreadState* __tstate = wxPyBeginAllowThreads();
35751 (arg1)->UsePrimarySelection(arg2);
35752 wxPyEndAllowThreads(__tstate);
35753 if (PyErr_Occurred()) SWIG_fail;
35754 }
35755 resultobj = SWIG_Py_Void();
35756 return resultobj;
35757 fail:
35758 return NULL;
35759 }
35760
35761
35762 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35763 PyObject *resultobj = 0;
35764 wxClipboard *result = 0 ;
35765
35766 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35767 {
35768 PyThreadState* __tstate = wxPyBeginAllowThreads();
35769 result = (wxClipboard *)wxClipboard::Get();
35770 wxPyEndAllowThreads(__tstate);
35771 if (PyErr_Occurred()) SWIG_fail;
35772 }
35773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35774 return resultobj;
35775 fail:
35776 return NULL;
35777 }
35778
35779
35780 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35781 PyObject *obj;
35782 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35783 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35784 return SWIG_Py_Void();
35785 }
35786
35787 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35788 return SWIG_Python_InitShadowInstance(args);
35789 }
35790
35791 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35792 PyObject *resultobj = 0;
35793 wxClipboard *arg1 = (wxClipboard *) NULL ;
35794 wxClipboardLocker *result = 0 ;
35795 void *argp1 = 0 ;
35796 int res1 = 0 ;
35797 PyObject * obj0 = 0 ;
35798 char * kwnames[] = {
35799 (char *) "clipboard", NULL
35800 };
35801
35802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35803 if (obj0) {
35804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35805 if (!SWIG_IsOK(res1)) {
35806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35807 }
35808 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35809 }
35810 {
35811 PyThreadState* __tstate = wxPyBeginAllowThreads();
35812 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35813 wxPyEndAllowThreads(__tstate);
35814 if (PyErr_Occurred()) SWIG_fail;
35815 }
35816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35817 return resultobj;
35818 fail:
35819 return NULL;
35820 }
35821
35822
35823 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35824 PyObject *resultobj = 0;
35825 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35826 void *argp1 = 0 ;
35827 int res1 = 0 ;
35828 PyObject *swig_obj[1] ;
35829
35830 if (!args) SWIG_fail;
35831 swig_obj[0] = args;
35832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35833 if (!SWIG_IsOK(res1)) {
35834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35835 }
35836 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35837 {
35838 PyThreadState* __tstate = wxPyBeginAllowThreads();
35839 delete arg1;
35840
35841 wxPyEndAllowThreads(__tstate);
35842 if (PyErr_Occurred()) SWIG_fail;
35843 }
35844 resultobj = SWIG_Py_Void();
35845 return resultobj;
35846 fail:
35847 return NULL;
35848 }
35849
35850
35851 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35852 PyObject *resultobj = 0;
35853 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35854 bool result;
35855 void *argp1 = 0 ;
35856 int res1 = 0 ;
35857 PyObject *swig_obj[1] ;
35858
35859 if (!args) SWIG_fail;
35860 swig_obj[0] = args;
35861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35862 if (!SWIG_IsOK(res1)) {
35863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35864 }
35865 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35866 {
35867 PyThreadState* __tstate = wxPyBeginAllowThreads();
35868 result = (bool)wxClipboardLocker___nonzero__(arg1);
35869 wxPyEndAllowThreads(__tstate);
35870 if (PyErr_Occurred()) SWIG_fail;
35871 }
35872 {
35873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35874 }
35875 return resultobj;
35876 fail:
35877 return NULL;
35878 }
35879
35880
35881 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35882 PyObject *obj;
35883 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35884 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35885 return SWIG_Py_Void();
35886 }
35887
35888 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35889 return SWIG_Python_InitShadowInstance(args);
35890 }
35891
35892 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35893 PyObject *resultobj = 0;
35894 int arg1 = (int) 0 ;
35895 int arg2 = (int) 0 ;
35896 int arg3 = (int) 0 ;
35897 int arg4 = (int) 0 ;
35898 wxVideoMode *result = 0 ;
35899 int val1 ;
35900 int ecode1 = 0 ;
35901 int val2 ;
35902 int ecode2 = 0 ;
35903 int val3 ;
35904 int ecode3 = 0 ;
35905 int val4 ;
35906 int ecode4 = 0 ;
35907 PyObject * obj0 = 0 ;
35908 PyObject * obj1 = 0 ;
35909 PyObject * obj2 = 0 ;
35910 PyObject * obj3 = 0 ;
35911 char * kwnames[] = {
35912 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35913 };
35914
35915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35916 if (obj0) {
35917 ecode1 = SWIG_AsVal_int(obj0, &val1);
35918 if (!SWIG_IsOK(ecode1)) {
35919 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35920 }
35921 arg1 = static_cast< int >(val1);
35922 }
35923 if (obj1) {
35924 ecode2 = SWIG_AsVal_int(obj1, &val2);
35925 if (!SWIG_IsOK(ecode2)) {
35926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35927 }
35928 arg2 = static_cast< int >(val2);
35929 }
35930 if (obj2) {
35931 ecode3 = SWIG_AsVal_int(obj2, &val3);
35932 if (!SWIG_IsOK(ecode3)) {
35933 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35934 }
35935 arg3 = static_cast< int >(val3);
35936 }
35937 if (obj3) {
35938 ecode4 = SWIG_AsVal_int(obj3, &val4);
35939 if (!SWIG_IsOK(ecode4)) {
35940 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35941 }
35942 arg4 = static_cast< int >(val4);
35943 }
35944 {
35945 PyThreadState* __tstate = wxPyBeginAllowThreads();
35946 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35947 wxPyEndAllowThreads(__tstate);
35948 if (PyErr_Occurred()) SWIG_fail;
35949 }
35950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35951 return resultobj;
35952 fail:
35953 return NULL;
35954 }
35955
35956
35957 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35958 PyObject *resultobj = 0;
35959 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35960 void *argp1 = 0 ;
35961 int res1 = 0 ;
35962 PyObject *swig_obj[1] ;
35963
35964 if (!args) SWIG_fail;
35965 swig_obj[0] = args;
35966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35967 if (!SWIG_IsOK(res1)) {
35968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35969 }
35970 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35971 {
35972 PyThreadState* __tstate = wxPyBeginAllowThreads();
35973 delete arg1;
35974
35975 wxPyEndAllowThreads(__tstate);
35976 if (PyErr_Occurred()) SWIG_fail;
35977 }
35978 resultobj = SWIG_Py_Void();
35979 return resultobj;
35980 fail:
35981 return NULL;
35982 }
35983
35984
35985 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35986 PyObject *resultobj = 0;
35987 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35988 wxVideoMode *arg2 = 0 ;
35989 bool result;
35990 void *argp1 = 0 ;
35991 int res1 = 0 ;
35992 void *argp2 = 0 ;
35993 int res2 = 0 ;
35994 PyObject * obj0 = 0 ;
35995 PyObject * obj1 = 0 ;
35996 char * kwnames[] = {
35997 (char *) "self",(char *) "other", NULL
35998 };
35999
36000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
36001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36002 if (!SWIG_IsOK(res1)) {
36003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36004 }
36005 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36006 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36007 if (!SWIG_IsOK(res2)) {
36008 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36009 }
36010 if (!argp2) {
36011 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36012 }
36013 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36014 {
36015 PyThreadState* __tstate = wxPyBeginAllowThreads();
36016 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
36017 wxPyEndAllowThreads(__tstate);
36018 if (PyErr_Occurred()) SWIG_fail;
36019 }
36020 {
36021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36022 }
36023 return resultobj;
36024 fail:
36025 return NULL;
36026 }
36027
36028
36029 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36030 PyObject *resultobj = 0;
36031 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36032 int result;
36033 void *argp1 = 0 ;
36034 int res1 = 0 ;
36035 PyObject *swig_obj[1] ;
36036
36037 if (!args) SWIG_fail;
36038 swig_obj[0] = args;
36039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36040 if (!SWIG_IsOK(res1)) {
36041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36042 }
36043 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36044 {
36045 PyThreadState* __tstate = wxPyBeginAllowThreads();
36046 result = (int)((wxVideoMode const *)arg1)->GetWidth();
36047 wxPyEndAllowThreads(__tstate);
36048 if (PyErr_Occurred()) SWIG_fail;
36049 }
36050 resultobj = SWIG_From_int(static_cast< int >(result));
36051 return resultobj;
36052 fail:
36053 return NULL;
36054 }
36055
36056
36057 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36058 PyObject *resultobj = 0;
36059 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36060 int result;
36061 void *argp1 = 0 ;
36062 int res1 = 0 ;
36063 PyObject *swig_obj[1] ;
36064
36065 if (!args) SWIG_fail;
36066 swig_obj[0] = args;
36067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36068 if (!SWIG_IsOK(res1)) {
36069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36070 }
36071 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36072 {
36073 PyThreadState* __tstate = wxPyBeginAllowThreads();
36074 result = (int)((wxVideoMode const *)arg1)->GetHeight();
36075 wxPyEndAllowThreads(__tstate);
36076 if (PyErr_Occurred()) SWIG_fail;
36077 }
36078 resultobj = SWIG_From_int(static_cast< int >(result));
36079 return resultobj;
36080 fail:
36081 return NULL;
36082 }
36083
36084
36085 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36086 PyObject *resultobj = 0;
36087 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36088 int result;
36089 void *argp1 = 0 ;
36090 int res1 = 0 ;
36091 PyObject *swig_obj[1] ;
36092
36093 if (!args) SWIG_fail;
36094 swig_obj[0] = args;
36095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36096 if (!SWIG_IsOK(res1)) {
36097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36098 }
36099 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36100 {
36101 PyThreadState* __tstate = wxPyBeginAllowThreads();
36102 result = (int)((wxVideoMode const *)arg1)->GetDepth();
36103 wxPyEndAllowThreads(__tstate);
36104 if (PyErr_Occurred()) SWIG_fail;
36105 }
36106 resultobj = SWIG_From_int(static_cast< int >(result));
36107 return resultobj;
36108 fail:
36109 return NULL;
36110 }
36111
36112
36113 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36114 PyObject *resultobj = 0;
36115 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36116 bool result;
36117 void *argp1 = 0 ;
36118 int res1 = 0 ;
36119 PyObject *swig_obj[1] ;
36120
36121 if (!args) SWIG_fail;
36122 swig_obj[0] = args;
36123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36124 if (!SWIG_IsOK(res1)) {
36125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36126 }
36127 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36128 {
36129 PyThreadState* __tstate = wxPyBeginAllowThreads();
36130 result = (bool)((wxVideoMode const *)arg1)->IsOk();
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___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36144 PyObject *resultobj = 0;
36145 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36146 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36147 bool result;
36148 void *argp1 = 0 ;
36149 int res1 = 0 ;
36150 void *argp2 = 0 ;
36151 int res2 = 0 ;
36152 PyObject * obj0 = 0 ;
36153 PyObject * obj1 = 0 ;
36154 char * kwnames[] = {
36155 (char *) "self",(char *) "other", NULL
36156 };
36157
36158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36160 if (!SWIG_IsOK(res1)) {
36161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36162 }
36163 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36164 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36165 if (!SWIG_IsOK(res2)) {
36166 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36167 }
36168 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36169 {
36170 PyThreadState* __tstate = wxPyBeginAllowThreads();
36171 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36172 wxPyEndAllowThreads(__tstate);
36173 if (PyErr_Occurred()) SWIG_fail;
36174 }
36175 {
36176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36177 }
36178 return resultobj;
36179 fail:
36180 return NULL;
36181 }
36182
36183
36184 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36185 PyObject *resultobj = 0;
36186 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36187 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36188 bool result;
36189 void *argp1 = 0 ;
36190 int res1 = 0 ;
36191 void *argp2 = 0 ;
36192 int res2 = 0 ;
36193 PyObject * obj0 = 0 ;
36194 PyObject * obj1 = 0 ;
36195 char * kwnames[] = {
36196 (char *) "self",(char *) "other", NULL
36197 };
36198
36199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36201 if (!SWIG_IsOK(res1)) {
36202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36203 }
36204 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36205 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36206 if (!SWIG_IsOK(res2)) {
36207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36208 }
36209 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36210 {
36211 PyThreadState* __tstate = wxPyBeginAllowThreads();
36212 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36213 wxPyEndAllowThreads(__tstate);
36214 if (PyErr_Occurred()) SWIG_fail;
36215 }
36216 {
36217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36218 }
36219 return resultobj;
36220 fail:
36221 return NULL;
36222 }
36223
36224
36225 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36226 PyObject *resultobj = 0;
36227 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36228 int arg2 ;
36229 void *argp1 = 0 ;
36230 int res1 = 0 ;
36231 int val2 ;
36232 int ecode2 = 0 ;
36233 PyObject *swig_obj[2] ;
36234
36235 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
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_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36239 }
36240 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36241 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36242 if (!SWIG_IsOK(ecode2)) {
36243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36244 }
36245 arg2 = static_cast< int >(val2);
36246 if (arg1) (arg1)->w = arg2;
36247
36248 resultobj = SWIG_Py_Void();
36249 return resultobj;
36250 fail:
36251 return NULL;
36252 }
36253
36254
36255 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36256 PyObject *resultobj = 0;
36257 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36258 int result;
36259 void *argp1 = 0 ;
36260 int res1 = 0 ;
36261 PyObject *swig_obj[1] ;
36262
36263 if (!args) SWIG_fail;
36264 swig_obj[0] = args;
36265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36266 if (!SWIG_IsOK(res1)) {
36267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36268 }
36269 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36270 result = (int) ((arg1)->w);
36271 resultobj = SWIG_From_int(static_cast< int >(result));
36272 return resultobj;
36273 fail:
36274 return NULL;
36275 }
36276
36277
36278 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36279 PyObject *resultobj = 0;
36280 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36281 int arg2 ;
36282 void *argp1 = 0 ;
36283 int res1 = 0 ;
36284 int val2 ;
36285 int ecode2 = 0 ;
36286 PyObject *swig_obj[2] ;
36287
36288 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
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_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36292 }
36293 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36294 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36295 if (!SWIG_IsOK(ecode2)) {
36296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36297 }
36298 arg2 = static_cast< int >(val2);
36299 if (arg1) (arg1)->h = arg2;
36300
36301 resultobj = SWIG_Py_Void();
36302 return resultobj;
36303 fail:
36304 return NULL;
36305 }
36306
36307
36308 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36309 PyObject *resultobj = 0;
36310 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36311 int result;
36312 void *argp1 = 0 ;
36313 int res1 = 0 ;
36314 PyObject *swig_obj[1] ;
36315
36316 if (!args) SWIG_fail;
36317 swig_obj[0] = args;
36318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36319 if (!SWIG_IsOK(res1)) {
36320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36321 }
36322 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36323 result = (int) ((arg1)->h);
36324 resultobj = SWIG_From_int(static_cast< int >(result));
36325 return resultobj;
36326 fail:
36327 return NULL;
36328 }
36329
36330
36331 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36332 PyObject *resultobj = 0;
36333 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36334 int arg2 ;
36335 void *argp1 = 0 ;
36336 int res1 = 0 ;
36337 int val2 ;
36338 int ecode2 = 0 ;
36339 PyObject *swig_obj[2] ;
36340
36341 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
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_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36345 }
36346 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36347 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36348 if (!SWIG_IsOK(ecode2)) {
36349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36350 }
36351 arg2 = static_cast< int >(val2);
36352 if (arg1) (arg1)->bpp = arg2;
36353
36354 resultobj = SWIG_Py_Void();
36355 return resultobj;
36356 fail:
36357 return NULL;
36358 }
36359
36360
36361 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36362 PyObject *resultobj = 0;
36363 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36364 int result;
36365 void *argp1 = 0 ;
36366 int res1 = 0 ;
36367 PyObject *swig_obj[1] ;
36368
36369 if (!args) SWIG_fail;
36370 swig_obj[0] = args;
36371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36372 if (!SWIG_IsOK(res1)) {
36373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36374 }
36375 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36376 result = (int) ((arg1)->bpp);
36377 resultobj = SWIG_From_int(static_cast< int >(result));
36378 return resultobj;
36379 fail:
36380 return NULL;
36381 }
36382
36383
36384 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36385 PyObject *resultobj = 0;
36386 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36387 int arg2 ;
36388 void *argp1 = 0 ;
36389 int res1 = 0 ;
36390 int val2 ;
36391 int ecode2 = 0 ;
36392 PyObject *swig_obj[2] ;
36393
36394 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36396 if (!SWIG_IsOK(res1)) {
36397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36398 }
36399 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36400 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36401 if (!SWIG_IsOK(ecode2)) {
36402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36403 }
36404 arg2 = static_cast< int >(val2);
36405 if (arg1) (arg1)->refresh = arg2;
36406
36407 resultobj = SWIG_Py_Void();
36408 return resultobj;
36409 fail:
36410 return NULL;
36411 }
36412
36413
36414 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36415 PyObject *resultobj = 0;
36416 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36417 int result;
36418 void *argp1 = 0 ;
36419 int res1 = 0 ;
36420 PyObject *swig_obj[1] ;
36421
36422 if (!args) SWIG_fail;
36423 swig_obj[0] = args;
36424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36425 if (!SWIG_IsOK(res1)) {
36426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36427 }
36428 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36429 result = (int) ((arg1)->refresh);
36430 resultobj = SWIG_From_int(static_cast< int >(result));
36431 return resultobj;
36432 fail:
36433 return NULL;
36434 }
36435
36436
36437 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36438 PyObject *obj;
36439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36440 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36441 return SWIG_Py_Void();
36442 }
36443
36444 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36445 return SWIG_Python_InitShadowInstance(args);
36446 }
36447
36448 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36449 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36450 return 1;
36451 }
36452
36453
36454 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36455 PyObject *pyobj = 0;
36456
36457 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36458 return pyobj;
36459 }
36460
36461
36462 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36463 PyObject *resultobj = 0;
36464 unsigned int arg1 = (unsigned int) 0 ;
36465 wxDisplay *result = 0 ;
36466 unsigned int val1 ;
36467 int ecode1 = 0 ;
36468 PyObject * obj0 = 0 ;
36469 char * kwnames[] = {
36470 (char *) "index", NULL
36471 };
36472
36473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36474 if (obj0) {
36475 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36476 if (!SWIG_IsOK(ecode1)) {
36477 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36478 }
36479 arg1 = static_cast< unsigned int >(val1);
36480 }
36481 {
36482 PyThreadState* __tstate = wxPyBeginAllowThreads();
36483 result = (wxDisplay *)new wxDisplay(arg1);
36484 wxPyEndAllowThreads(__tstate);
36485 if (PyErr_Occurred()) SWIG_fail;
36486 }
36487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36488 return resultobj;
36489 fail:
36490 return NULL;
36491 }
36492
36493
36494 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36495 PyObject *resultobj = 0;
36496 wxDisplay *arg1 = (wxDisplay *) 0 ;
36497 void *argp1 = 0 ;
36498 int res1 = 0 ;
36499 PyObject *swig_obj[1] ;
36500
36501 if (!args) SWIG_fail;
36502 swig_obj[0] = args;
36503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36504 if (!SWIG_IsOK(res1)) {
36505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36506 }
36507 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36508 {
36509 PyThreadState* __tstate = wxPyBeginAllowThreads();
36510 delete arg1;
36511
36512 wxPyEndAllowThreads(__tstate);
36513 if (PyErr_Occurred()) SWIG_fail;
36514 }
36515 resultobj = SWIG_Py_Void();
36516 return resultobj;
36517 fail:
36518 return NULL;
36519 }
36520
36521
36522 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36523 PyObject *resultobj = 0;
36524 unsigned int result;
36525
36526 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36527 {
36528 PyThreadState* __tstate = wxPyBeginAllowThreads();
36529 result = (unsigned int)wxDisplay::GetCount();
36530 wxPyEndAllowThreads(__tstate);
36531 if (PyErr_Occurred()) SWIG_fail;
36532 }
36533 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36534 return resultobj;
36535 fail:
36536 return NULL;
36537 }
36538
36539
36540 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36541 PyObject *resultobj = 0;
36542 wxPoint *arg1 = 0 ;
36543 int result;
36544 wxPoint temp1 ;
36545 PyObject * obj0 = 0 ;
36546 char * kwnames[] = {
36547 (char *) "pt", NULL
36548 };
36549
36550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36551 {
36552 arg1 = &temp1;
36553 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36554 }
36555 {
36556 PyThreadState* __tstate = wxPyBeginAllowThreads();
36557 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36558 wxPyEndAllowThreads(__tstate);
36559 if (PyErr_Occurred()) SWIG_fail;
36560 }
36561 resultobj = SWIG_From_int(static_cast< int >(result));
36562 return resultobj;
36563 fail:
36564 return NULL;
36565 }
36566
36567
36568 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36569 PyObject *resultobj = 0;
36570 wxWindow *arg1 = (wxWindow *) 0 ;
36571 int result;
36572 void *argp1 = 0 ;
36573 int res1 = 0 ;
36574 PyObject * obj0 = 0 ;
36575 char * kwnames[] = {
36576 (char *) "window", NULL
36577 };
36578
36579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36581 if (!SWIG_IsOK(res1)) {
36582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36583 }
36584 arg1 = reinterpret_cast< wxWindow * >(argp1);
36585 {
36586 PyThreadState* __tstate = wxPyBeginAllowThreads();
36587 result = (int)wxDisplay::GetFromWindow(arg1);
36588 wxPyEndAllowThreads(__tstate);
36589 if (PyErr_Occurred()) SWIG_fail;
36590 }
36591 resultobj = SWIG_From_int(static_cast< int >(result));
36592 return resultobj;
36593 fail:
36594 return NULL;
36595 }
36596
36597
36598 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36599 PyObject *resultobj = 0;
36600 wxDisplay *arg1 = (wxDisplay *) 0 ;
36601 bool result;
36602 void *argp1 = 0 ;
36603 int res1 = 0 ;
36604 PyObject *swig_obj[1] ;
36605
36606 if (!args) SWIG_fail;
36607 swig_obj[0] = args;
36608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36609 if (!SWIG_IsOK(res1)) {
36610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36611 }
36612 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36613 {
36614 PyThreadState* __tstate = wxPyBeginAllowThreads();
36615 result = (bool)((wxDisplay const *)arg1)->IsOk();
36616 wxPyEndAllowThreads(__tstate);
36617 if (PyErr_Occurred()) SWIG_fail;
36618 }
36619 {
36620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36621 }
36622 return resultobj;
36623 fail:
36624 return NULL;
36625 }
36626
36627
36628 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36629 PyObject *resultobj = 0;
36630 wxDisplay *arg1 = (wxDisplay *) 0 ;
36631 wxRect result;
36632 void *argp1 = 0 ;
36633 int res1 = 0 ;
36634 PyObject *swig_obj[1] ;
36635
36636 if (!args) SWIG_fail;
36637 swig_obj[0] = args;
36638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36639 if (!SWIG_IsOK(res1)) {
36640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36641 }
36642 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36643 {
36644 PyThreadState* __tstate = wxPyBeginAllowThreads();
36645 result = ((wxDisplay const *)arg1)->GetGeometry();
36646 wxPyEndAllowThreads(__tstate);
36647 if (PyErr_Occurred()) SWIG_fail;
36648 }
36649 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36650 return resultobj;
36651 fail:
36652 return NULL;
36653 }
36654
36655
36656 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36657 PyObject *resultobj = 0;
36658 wxDisplay *arg1 = (wxDisplay *) 0 ;
36659 wxRect result;
36660 void *argp1 = 0 ;
36661 int res1 = 0 ;
36662 PyObject *swig_obj[1] ;
36663
36664 if (!args) SWIG_fail;
36665 swig_obj[0] = args;
36666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36667 if (!SWIG_IsOK(res1)) {
36668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36669 }
36670 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36671 {
36672 PyThreadState* __tstate = wxPyBeginAllowThreads();
36673 result = ((wxDisplay const *)arg1)->GetClientArea();
36674 wxPyEndAllowThreads(__tstate);
36675 if (PyErr_Occurred()) SWIG_fail;
36676 }
36677 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36678 return resultobj;
36679 fail:
36680 return NULL;
36681 }
36682
36683
36684 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36685 PyObject *resultobj = 0;
36686 wxDisplay *arg1 = (wxDisplay *) 0 ;
36687 wxString result;
36688 void *argp1 = 0 ;
36689 int res1 = 0 ;
36690 PyObject *swig_obj[1] ;
36691
36692 if (!args) SWIG_fail;
36693 swig_obj[0] = args;
36694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36695 if (!SWIG_IsOK(res1)) {
36696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36697 }
36698 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36699 {
36700 PyThreadState* __tstate = wxPyBeginAllowThreads();
36701 result = ((wxDisplay const *)arg1)->GetName();
36702 wxPyEndAllowThreads(__tstate);
36703 if (PyErr_Occurred()) SWIG_fail;
36704 }
36705 {
36706 #if wxUSE_UNICODE
36707 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36708 #else
36709 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36710 #endif
36711 }
36712 return resultobj;
36713 fail:
36714 return NULL;
36715 }
36716
36717
36718 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36719 PyObject *resultobj = 0;
36720 wxDisplay *arg1 = (wxDisplay *) 0 ;
36721 bool result;
36722 void *argp1 = 0 ;
36723 int res1 = 0 ;
36724 PyObject *swig_obj[1] ;
36725
36726 if (!args) SWIG_fail;
36727 swig_obj[0] = args;
36728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36729 if (!SWIG_IsOK(res1)) {
36730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36731 }
36732 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36733 {
36734 PyThreadState* __tstate = wxPyBeginAllowThreads();
36735 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36736 wxPyEndAllowThreads(__tstate);
36737 if (PyErr_Occurred()) SWIG_fail;
36738 }
36739 {
36740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36741 }
36742 return resultobj;
36743 fail:
36744 return NULL;
36745 }
36746
36747
36748 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36749 PyObject *resultobj = 0;
36750 wxDisplay *arg1 = (wxDisplay *) 0 ;
36751 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36752 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36753 PyObject *result = 0 ;
36754 void *argp1 = 0 ;
36755 int res1 = 0 ;
36756 void *argp2 = 0 ;
36757 int res2 = 0 ;
36758 PyObject * obj0 = 0 ;
36759 PyObject * obj1 = 0 ;
36760 char * kwnames[] = {
36761 (char *) "self",(char *) "mode", NULL
36762 };
36763
36764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36766 if (!SWIG_IsOK(res1)) {
36767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36768 }
36769 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36770 if (obj1) {
36771 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36772 if (!SWIG_IsOK(res2)) {
36773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36774 }
36775 if (!argp2) {
36776 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36777 }
36778 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36779 }
36780 {
36781 PyThreadState* __tstate = wxPyBeginAllowThreads();
36782 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36783 wxPyEndAllowThreads(__tstate);
36784 if (PyErr_Occurred()) SWIG_fail;
36785 }
36786 resultobj = result;
36787 return resultobj;
36788 fail:
36789 return NULL;
36790 }
36791
36792
36793 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36794 PyObject *resultobj = 0;
36795 wxDisplay *arg1 = (wxDisplay *) 0 ;
36796 wxVideoMode result;
36797 void *argp1 = 0 ;
36798 int res1 = 0 ;
36799 PyObject *swig_obj[1] ;
36800
36801 if (!args) SWIG_fail;
36802 swig_obj[0] = args;
36803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36804 if (!SWIG_IsOK(res1)) {
36805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36806 }
36807 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36808 {
36809 PyThreadState* __tstate = wxPyBeginAllowThreads();
36810 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36811 wxPyEndAllowThreads(__tstate);
36812 if (PyErr_Occurred()) SWIG_fail;
36813 }
36814 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36815 return resultobj;
36816 fail:
36817 return NULL;
36818 }
36819
36820
36821 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36822 PyObject *resultobj = 0;
36823 wxDisplay *arg1 = (wxDisplay *) 0 ;
36824 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36825 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36826 bool result;
36827 void *argp1 = 0 ;
36828 int res1 = 0 ;
36829 void *argp2 = 0 ;
36830 int res2 = 0 ;
36831 PyObject * obj0 = 0 ;
36832 PyObject * obj1 = 0 ;
36833 char * kwnames[] = {
36834 (char *) "self",(char *) "mode", NULL
36835 };
36836
36837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36839 if (!SWIG_IsOK(res1)) {
36840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36841 }
36842 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36843 if (obj1) {
36844 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36845 if (!SWIG_IsOK(res2)) {
36846 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36847 }
36848 if (!argp2) {
36849 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36850 }
36851 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36852 }
36853 {
36854 PyThreadState* __tstate = wxPyBeginAllowThreads();
36855 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36856 wxPyEndAllowThreads(__tstate);
36857 if (PyErr_Occurred()) SWIG_fail;
36858 }
36859 {
36860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36861 }
36862 return resultobj;
36863 fail:
36864 return NULL;
36865 }
36866
36867
36868 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36869 PyObject *resultobj = 0;
36870 wxDisplay *arg1 = (wxDisplay *) 0 ;
36871 void *argp1 = 0 ;
36872 int res1 = 0 ;
36873 PyObject *swig_obj[1] ;
36874
36875 if (!args) SWIG_fail;
36876 swig_obj[0] = args;
36877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36878 if (!SWIG_IsOK(res1)) {
36879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36880 }
36881 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36882 {
36883 PyThreadState* __tstate = wxPyBeginAllowThreads();
36884 wxDisplay_ResetMode(arg1);
36885 wxPyEndAllowThreads(__tstate);
36886 if (PyErr_Occurred()) SWIG_fail;
36887 }
36888 resultobj = SWIG_Py_Void();
36889 return resultobj;
36890 fail:
36891 return NULL;
36892 }
36893
36894
36895 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36896 PyObject *obj;
36897 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36898 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36899 return SWIG_Py_Void();
36900 }
36901
36902 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36903 return SWIG_Python_InitShadowInstance(args);
36904 }
36905
36906 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36907 PyObject *resultobj = 0;
36908 wxStandardPaths *result = 0 ;
36909
36910 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36911 {
36912 PyThreadState* __tstate = wxPyBeginAllowThreads();
36913 result = (wxStandardPaths *)wxStandardPaths_Get();
36914 wxPyEndAllowThreads(__tstate);
36915 if (PyErr_Occurred()) SWIG_fail;
36916 }
36917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36918 return resultobj;
36919 fail:
36920 return NULL;
36921 }
36922
36923
36924 SWIGINTERN PyObject *_wrap_StandardPaths_GetExecutablePath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36925 PyObject *resultobj = 0;
36926 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36927 wxString result;
36928 void *argp1 = 0 ;
36929 int res1 = 0 ;
36930 PyObject *swig_obj[1] ;
36931
36932 if (!args) SWIG_fail;
36933 swig_obj[0] = args;
36934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36935 if (!SWIG_IsOK(res1)) {
36936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetExecutablePath" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36937 }
36938 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36939 {
36940 PyThreadState* __tstate = wxPyBeginAllowThreads();
36941 result = ((wxStandardPaths const *)arg1)->GetExecutablePath();
36942 wxPyEndAllowThreads(__tstate);
36943 if (PyErr_Occurred()) SWIG_fail;
36944 }
36945 {
36946 #if wxUSE_UNICODE
36947 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36948 #else
36949 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36950 #endif
36951 }
36952 return resultobj;
36953 fail:
36954 return NULL;
36955 }
36956
36957
36958 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36959 PyObject *resultobj = 0;
36960 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36961 wxString result;
36962 void *argp1 = 0 ;
36963 int res1 = 0 ;
36964 PyObject *swig_obj[1] ;
36965
36966 if (!args) SWIG_fail;
36967 swig_obj[0] = args;
36968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36969 if (!SWIG_IsOK(res1)) {
36970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36971 }
36972 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36973 {
36974 PyThreadState* __tstate = wxPyBeginAllowThreads();
36975 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36976 wxPyEndAllowThreads(__tstate);
36977 if (PyErr_Occurred()) SWIG_fail;
36978 }
36979 {
36980 #if wxUSE_UNICODE
36981 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36982 #else
36983 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36984 #endif
36985 }
36986 return resultobj;
36987 fail:
36988 return NULL;
36989 }
36990
36991
36992 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36993 PyObject *resultobj = 0;
36994 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36995 wxString result;
36996 void *argp1 = 0 ;
36997 int res1 = 0 ;
36998 PyObject *swig_obj[1] ;
36999
37000 if (!args) SWIG_fail;
37001 swig_obj[0] = args;
37002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37003 if (!SWIG_IsOK(res1)) {
37004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37005 }
37006 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37007 {
37008 PyThreadState* __tstate = wxPyBeginAllowThreads();
37009 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
37010 wxPyEndAllowThreads(__tstate);
37011 if (PyErr_Occurred()) SWIG_fail;
37012 }
37013 {
37014 #if wxUSE_UNICODE
37015 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37016 #else
37017 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37018 #endif
37019 }
37020 return resultobj;
37021 fail:
37022 return NULL;
37023 }
37024
37025
37026 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37027 PyObject *resultobj = 0;
37028 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37029 wxString result;
37030 void *argp1 = 0 ;
37031 int res1 = 0 ;
37032 PyObject *swig_obj[1] ;
37033
37034 if (!args) SWIG_fail;
37035 swig_obj[0] = args;
37036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37037 if (!SWIG_IsOK(res1)) {
37038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37039 }
37040 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37041 {
37042 PyThreadState* __tstate = wxPyBeginAllowThreads();
37043 result = ((wxStandardPaths const *)arg1)->GetDataDir();
37044 wxPyEndAllowThreads(__tstate);
37045 if (PyErr_Occurred()) SWIG_fail;
37046 }
37047 {
37048 #if wxUSE_UNICODE
37049 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37050 #else
37051 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37052 #endif
37053 }
37054 return resultobj;
37055 fail:
37056 return NULL;
37057 }
37058
37059
37060 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37061 PyObject *resultobj = 0;
37062 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37063 wxString result;
37064 void *argp1 = 0 ;
37065 int res1 = 0 ;
37066 PyObject *swig_obj[1] ;
37067
37068 if (!args) SWIG_fail;
37069 swig_obj[0] = args;
37070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37071 if (!SWIG_IsOK(res1)) {
37072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37073 }
37074 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37075 {
37076 PyThreadState* __tstate = wxPyBeginAllowThreads();
37077 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
37078 wxPyEndAllowThreads(__tstate);
37079 if (PyErr_Occurred()) SWIG_fail;
37080 }
37081 {
37082 #if wxUSE_UNICODE
37083 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37084 #else
37085 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37086 #endif
37087 }
37088 return resultobj;
37089 fail:
37090 return NULL;
37091 }
37092
37093
37094 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37095 PyObject *resultobj = 0;
37096 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37097 wxString result;
37098 void *argp1 = 0 ;
37099 int res1 = 0 ;
37100 PyObject *swig_obj[1] ;
37101
37102 if (!args) SWIG_fail;
37103 swig_obj[0] = args;
37104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37105 if (!SWIG_IsOK(res1)) {
37106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37107 }
37108 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37109 {
37110 PyThreadState* __tstate = wxPyBeginAllowThreads();
37111 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
37112 wxPyEndAllowThreads(__tstate);
37113 if (PyErr_Occurred()) SWIG_fail;
37114 }
37115 {
37116 #if wxUSE_UNICODE
37117 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37118 #else
37119 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37120 #endif
37121 }
37122 return resultobj;
37123 fail:
37124 return NULL;
37125 }
37126
37127
37128 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37129 PyObject *resultobj = 0;
37130 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37131 wxString result;
37132 void *argp1 = 0 ;
37133 int res1 = 0 ;
37134 PyObject *swig_obj[1] ;
37135
37136 if (!args) SWIG_fail;
37137 swig_obj[0] = args;
37138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37139 if (!SWIG_IsOK(res1)) {
37140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37141 }
37142 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37143 {
37144 PyThreadState* __tstate = wxPyBeginAllowThreads();
37145 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
37146 wxPyEndAllowThreads(__tstate);
37147 if (PyErr_Occurred()) SWIG_fail;
37148 }
37149 {
37150 #if wxUSE_UNICODE
37151 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37152 #else
37153 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37154 #endif
37155 }
37156 return resultobj;
37157 fail:
37158 return NULL;
37159 }
37160
37161
37162 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37163 PyObject *resultobj = 0;
37164 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37165 wxString result;
37166 void *argp1 = 0 ;
37167 int res1 = 0 ;
37168 PyObject *swig_obj[1] ;
37169
37170 if (!args) SWIG_fail;
37171 swig_obj[0] = args;
37172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37173 if (!SWIG_IsOK(res1)) {
37174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37175 }
37176 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37177 {
37178 PyThreadState* __tstate = wxPyBeginAllowThreads();
37179 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37180 wxPyEndAllowThreads(__tstate);
37181 if (PyErr_Occurred()) SWIG_fail;
37182 }
37183 {
37184 #if wxUSE_UNICODE
37185 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37186 #else
37187 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37188 #endif
37189 }
37190 return resultobj;
37191 fail:
37192 return NULL;
37193 }
37194
37195
37196 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37197 PyObject *resultobj = 0;
37198 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37199 wxString result;
37200 void *argp1 = 0 ;
37201 int res1 = 0 ;
37202 PyObject *swig_obj[1] ;
37203
37204 if (!args) SWIG_fail;
37205 swig_obj[0] = args;
37206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37207 if (!SWIG_IsOK(res1)) {
37208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37209 }
37210 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37211 {
37212 PyThreadState* __tstate = wxPyBeginAllowThreads();
37213 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37214 wxPyEndAllowThreads(__tstate);
37215 if (PyErr_Occurred()) SWIG_fail;
37216 }
37217 {
37218 #if wxUSE_UNICODE
37219 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37220 #else
37221 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37222 #endif
37223 }
37224 return resultobj;
37225 fail:
37226 return NULL;
37227 }
37228
37229
37230 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37231 PyObject *resultobj = 0;
37232 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37233 wxString *arg2 = 0 ;
37234 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37235 wxString result;
37236 void *argp1 = 0 ;
37237 int res1 = 0 ;
37238 bool temp2 = false ;
37239 int val3 ;
37240 int ecode3 = 0 ;
37241 PyObject * obj0 = 0 ;
37242 PyObject * obj1 = 0 ;
37243 PyObject * obj2 = 0 ;
37244 char * kwnames[] = {
37245 (char *) "self",(char *) "lang",(char *) "category", NULL
37246 };
37247
37248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37250 if (!SWIG_IsOK(res1)) {
37251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37252 }
37253 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37254 {
37255 arg2 = wxString_in_helper(obj1);
37256 if (arg2 == NULL) SWIG_fail;
37257 temp2 = true;
37258 }
37259 if (obj2) {
37260 ecode3 = SWIG_AsVal_int(obj2, &val3);
37261 if (!SWIG_IsOK(ecode3)) {
37262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37263 }
37264 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37265 }
37266 {
37267 PyThreadState* __tstate = wxPyBeginAllowThreads();
37268 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37269 wxPyEndAllowThreads(__tstate);
37270 if (PyErr_Occurred()) SWIG_fail;
37271 }
37272 {
37273 #if wxUSE_UNICODE
37274 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37275 #else
37276 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37277 #endif
37278 }
37279 {
37280 if (temp2)
37281 delete arg2;
37282 }
37283 return resultobj;
37284 fail:
37285 {
37286 if (temp2)
37287 delete arg2;
37288 }
37289 return NULL;
37290 }
37291
37292
37293 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37294 PyObject *resultobj = 0;
37295 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37296 wxString result;
37297 void *argp1 = 0 ;
37298 int res1 = 0 ;
37299 PyObject *swig_obj[1] ;
37300
37301 if (!args) SWIG_fail;
37302 swig_obj[0] = args;
37303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37304 if (!SWIG_IsOK(res1)) {
37305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37306 }
37307 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37308 {
37309 PyThreadState* __tstate = wxPyBeginAllowThreads();
37310 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37311 wxPyEndAllowThreads(__tstate);
37312 if (PyErr_Occurred()) SWIG_fail;
37313 }
37314 {
37315 #if wxUSE_UNICODE
37316 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37317 #else
37318 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37319 #endif
37320 }
37321 return resultobj;
37322 fail:
37323 return NULL;
37324 }
37325
37326
37327 SWIGINTERN PyObject *_wrap_StandardPaths_GetTempDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37328 PyObject *resultobj = 0;
37329 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37330 wxString result;
37331 void *argp1 = 0 ;
37332 int res1 = 0 ;
37333 PyObject *swig_obj[1] ;
37334
37335 if (!args) SWIG_fail;
37336 swig_obj[0] = args;
37337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37338 if (!SWIG_IsOK(res1)) {
37339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetTempDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37340 }
37341 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37342 {
37343 PyThreadState* __tstate = wxPyBeginAllowThreads();
37344 result = ((wxStandardPaths const *)arg1)->GetTempDir();
37345 wxPyEndAllowThreads(__tstate);
37346 if (PyErr_Occurred()) SWIG_fail;
37347 }
37348 {
37349 #if wxUSE_UNICODE
37350 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37351 #else
37352 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37353 #endif
37354 }
37355 return resultobj;
37356 fail:
37357 return NULL;
37358 }
37359
37360
37361 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37362 PyObject *resultobj = 0;
37363 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37364 wxString *arg2 = 0 ;
37365 void *argp1 = 0 ;
37366 int res1 = 0 ;
37367 bool temp2 = false ;
37368 PyObject * obj0 = 0 ;
37369 PyObject * obj1 = 0 ;
37370 char * kwnames[] = {
37371 (char *) "self",(char *) "prefix", NULL
37372 };
37373
37374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37376 if (!SWIG_IsOK(res1)) {
37377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37378 }
37379 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37380 {
37381 arg2 = wxString_in_helper(obj1);
37382 if (arg2 == NULL) SWIG_fail;
37383 temp2 = true;
37384 }
37385 {
37386 PyThreadState* __tstate = wxPyBeginAllowThreads();
37387 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
37388 wxPyEndAllowThreads(__tstate);
37389 if (PyErr_Occurred()) SWIG_fail;
37390 }
37391 resultobj = SWIG_Py_Void();
37392 {
37393 if (temp2)
37394 delete arg2;
37395 }
37396 return resultobj;
37397 fail:
37398 {
37399 if (temp2)
37400 delete arg2;
37401 }
37402 return NULL;
37403 }
37404
37405
37406 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37407 PyObject *resultobj = 0;
37408 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37409 wxString result;
37410 void *argp1 = 0 ;
37411 int res1 = 0 ;
37412 PyObject *swig_obj[1] ;
37413
37414 if (!args) SWIG_fail;
37415 swig_obj[0] = args;
37416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37417 if (!SWIG_IsOK(res1)) {
37418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37419 }
37420 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37421 {
37422 PyThreadState* __tstate = wxPyBeginAllowThreads();
37423 result = wxStandardPaths_GetInstallPrefix(arg1);
37424 wxPyEndAllowThreads(__tstate);
37425 if (PyErr_Occurred()) SWIG_fail;
37426 }
37427 {
37428 #if wxUSE_UNICODE
37429 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37430 #else
37431 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37432 #endif
37433 }
37434 return resultobj;
37435 fail:
37436 return NULL;
37437 }
37438
37439
37440 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37441 PyObject *obj;
37442 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37443 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37444 return SWIG_Py_Void();
37445 }
37446
37447 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37448 PyObject *resultobj = 0;
37449 wxEventType arg1 ;
37450 wxPowerEvent *result = 0 ;
37451 int val1 ;
37452 int ecode1 = 0 ;
37453 PyObject * obj0 = 0 ;
37454 char * kwnames[] = {
37455 (char *) "evtType", NULL
37456 };
37457
37458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37459 ecode1 = SWIG_AsVal_int(obj0, &val1);
37460 if (!SWIG_IsOK(ecode1)) {
37461 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37462 }
37463 arg1 = static_cast< wxEventType >(val1);
37464 {
37465 PyThreadState* __tstate = wxPyBeginAllowThreads();
37466 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37467 wxPyEndAllowThreads(__tstate);
37468 if (PyErr_Occurred()) SWIG_fail;
37469 }
37470 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37471 return resultobj;
37472 fail:
37473 return NULL;
37474 }
37475
37476
37477 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37478 PyObject *resultobj = 0;
37479 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37480 void *argp1 = 0 ;
37481 int res1 = 0 ;
37482 PyObject *swig_obj[1] ;
37483
37484 if (!args) SWIG_fail;
37485 swig_obj[0] = args;
37486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37487 if (!SWIG_IsOK(res1)) {
37488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37489 }
37490 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37491 {
37492 PyThreadState* __tstate = wxPyBeginAllowThreads();
37493 (arg1)->Veto();
37494 wxPyEndAllowThreads(__tstate);
37495 if (PyErr_Occurred()) SWIG_fail;
37496 }
37497 resultobj = SWIG_Py_Void();
37498 return resultobj;
37499 fail:
37500 return NULL;
37501 }
37502
37503
37504 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37505 PyObject *resultobj = 0;
37506 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37507 bool result;
37508 void *argp1 = 0 ;
37509 int res1 = 0 ;
37510 PyObject *swig_obj[1] ;
37511
37512 if (!args) SWIG_fail;
37513 swig_obj[0] = args;
37514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37515 if (!SWIG_IsOK(res1)) {
37516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37517 }
37518 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37519 {
37520 PyThreadState* __tstate = wxPyBeginAllowThreads();
37521 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37522 wxPyEndAllowThreads(__tstate);
37523 if (PyErr_Occurred()) SWIG_fail;
37524 }
37525 {
37526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37527 }
37528 return resultobj;
37529 fail:
37530 return NULL;
37531 }
37532
37533
37534 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37535 PyObject *obj;
37536 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37537 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37538 return SWIG_Py_Void();
37539 }
37540
37541 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37542 return SWIG_Python_InitShadowInstance(args);
37543 }
37544
37545 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37546 PyObject *resultobj = 0;
37547 wxPowerType result;
37548
37549 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37550 {
37551 PyThreadState* __tstate = wxPyBeginAllowThreads();
37552 result = (wxPowerType)wxGetPowerType();
37553 wxPyEndAllowThreads(__tstate);
37554 if (PyErr_Occurred()) SWIG_fail;
37555 }
37556 resultobj = SWIG_From_int(static_cast< int >(result));
37557 return resultobj;
37558 fail:
37559 return NULL;
37560 }
37561
37562
37563 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37564 PyObject *resultobj = 0;
37565 wxBatteryState result;
37566
37567 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37568 {
37569 PyThreadState* __tstate = wxPyBeginAllowThreads();
37570 result = (wxBatteryState)wxGetBatteryState();
37571 wxPyEndAllowThreads(__tstate);
37572 if (PyErr_Occurred()) SWIG_fail;
37573 }
37574 resultobj = SWIG_From_int(static_cast< int >(result));
37575 return resultobj;
37576 fail:
37577 return NULL;
37578 }
37579
37580
37581 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37582 PyObject *resultobj = 0;
37583 wxAboutDialogInfo *result = 0 ;
37584
37585 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37586 {
37587 PyThreadState* __tstate = wxPyBeginAllowThreads();
37588 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37589 wxPyEndAllowThreads(__tstate);
37590 if (PyErr_Occurred()) SWIG_fail;
37591 }
37592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37593 return resultobj;
37594 fail:
37595 return NULL;
37596 }
37597
37598
37599 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37600 PyObject *resultobj = 0;
37601 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37602 void *argp1 = 0 ;
37603 int res1 = 0 ;
37604 PyObject *swig_obj[1] ;
37605
37606 if (!args) SWIG_fail;
37607 swig_obj[0] = args;
37608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37609 if (!SWIG_IsOK(res1)) {
37610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37611 }
37612 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37613 {
37614 PyThreadState* __tstate = wxPyBeginAllowThreads();
37615 delete arg1;
37616
37617 wxPyEndAllowThreads(__tstate);
37618 if (PyErr_Occurred()) SWIG_fail;
37619 }
37620 resultobj = SWIG_Py_Void();
37621 return resultobj;
37622 fail:
37623 return NULL;
37624 }
37625
37626
37627 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37628 PyObject *resultobj = 0;
37629 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37630 wxString *arg2 = 0 ;
37631 void *argp1 = 0 ;
37632 int res1 = 0 ;
37633 bool temp2 = false ;
37634 PyObject * obj0 = 0 ;
37635 PyObject * obj1 = 0 ;
37636 char * kwnames[] = {
37637 (char *) "self",(char *) "name", NULL
37638 };
37639
37640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
37641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37642 if (!SWIG_IsOK(res1)) {
37643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37644 }
37645 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37646 {
37647 arg2 = wxString_in_helper(obj1);
37648 if (arg2 == NULL) SWIG_fail;
37649 temp2 = true;
37650 }
37651 {
37652 PyThreadState* __tstate = wxPyBeginAllowThreads();
37653 (arg1)->SetName((wxString const &)*arg2);
37654 wxPyEndAllowThreads(__tstate);
37655 if (PyErr_Occurred()) SWIG_fail;
37656 }
37657 resultobj = SWIG_Py_Void();
37658 {
37659 if (temp2)
37660 delete arg2;
37661 }
37662 return resultobj;
37663 fail:
37664 {
37665 if (temp2)
37666 delete arg2;
37667 }
37668 return NULL;
37669 }
37670
37671
37672 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37673 PyObject *resultobj = 0;
37674 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37675 wxString result;
37676 void *argp1 = 0 ;
37677 int res1 = 0 ;
37678 PyObject *swig_obj[1] ;
37679
37680 if (!args) SWIG_fail;
37681 swig_obj[0] = args;
37682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37683 if (!SWIG_IsOK(res1)) {
37684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37685 }
37686 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37687 {
37688 PyThreadState* __tstate = wxPyBeginAllowThreads();
37689 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37690 wxPyEndAllowThreads(__tstate);
37691 if (PyErr_Occurred()) SWIG_fail;
37692 }
37693 {
37694 #if wxUSE_UNICODE
37695 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37696 #else
37697 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37698 #endif
37699 }
37700 return resultobj;
37701 fail:
37702 return NULL;
37703 }
37704
37705
37706 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37707 PyObject *resultobj = 0;
37708 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37709 wxString *arg2 = 0 ;
37710 void *argp1 = 0 ;
37711 int res1 = 0 ;
37712 bool temp2 = false ;
37713 PyObject * obj0 = 0 ;
37714 PyObject * obj1 = 0 ;
37715 char * kwnames[] = {
37716 (char *) "self",(char *) "version", NULL
37717 };
37718
37719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37721 if (!SWIG_IsOK(res1)) {
37722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37723 }
37724 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37725 {
37726 arg2 = wxString_in_helper(obj1);
37727 if (arg2 == NULL) SWIG_fail;
37728 temp2 = true;
37729 }
37730 {
37731 PyThreadState* __tstate = wxPyBeginAllowThreads();
37732 (arg1)->SetVersion((wxString const &)*arg2);
37733 wxPyEndAllowThreads(__tstate);
37734 if (PyErr_Occurred()) SWIG_fail;
37735 }
37736 resultobj = SWIG_Py_Void();
37737 {
37738 if (temp2)
37739 delete arg2;
37740 }
37741 return resultobj;
37742 fail:
37743 {
37744 if (temp2)
37745 delete arg2;
37746 }
37747 return NULL;
37748 }
37749
37750
37751 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37752 PyObject *resultobj = 0;
37753 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37754 bool result;
37755 void *argp1 = 0 ;
37756 int res1 = 0 ;
37757 PyObject *swig_obj[1] ;
37758
37759 if (!args) SWIG_fail;
37760 swig_obj[0] = args;
37761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37762 if (!SWIG_IsOK(res1)) {
37763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37764 }
37765 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37766 {
37767 PyThreadState* __tstate = wxPyBeginAllowThreads();
37768 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37769 wxPyEndAllowThreads(__tstate);
37770 if (PyErr_Occurred()) SWIG_fail;
37771 }
37772 {
37773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37774 }
37775 return resultobj;
37776 fail:
37777 return NULL;
37778 }
37779
37780
37781 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37782 PyObject *resultobj = 0;
37783 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37784 wxString result;
37785 void *argp1 = 0 ;
37786 int res1 = 0 ;
37787 PyObject *swig_obj[1] ;
37788
37789 if (!args) SWIG_fail;
37790 swig_obj[0] = args;
37791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37792 if (!SWIG_IsOK(res1)) {
37793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37794 }
37795 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37796 {
37797 PyThreadState* __tstate = wxPyBeginAllowThreads();
37798 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37799 wxPyEndAllowThreads(__tstate);
37800 if (PyErr_Occurred()) SWIG_fail;
37801 }
37802 {
37803 #if wxUSE_UNICODE
37804 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37805 #else
37806 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37807 #endif
37808 }
37809 return resultobj;
37810 fail:
37811 return NULL;
37812 }
37813
37814
37815 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37816 PyObject *resultobj = 0;
37817 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37818 wxString *arg2 = 0 ;
37819 void *argp1 = 0 ;
37820 int res1 = 0 ;
37821 bool temp2 = false ;
37822 PyObject * obj0 = 0 ;
37823 PyObject * obj1 = 0 ;
37824 char * kwnames[] = {
37825 (char *) "self",(char *) "desc", NULL
37826 };
37827
37828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37830 if (!SWIG_IsOK(res1)) {
37831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37832 }
37833 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37834 {
37835 arg2 = wxString_in_helper(obj1);
37836 if (arg2 == NULL) SWIG_fail;
37837 temp2 = true;
37838 }
37839 {
37840 PyThreadState* __tstate = wxPyBeginAllowThreads();
37841 (arg1)->SetDescription((wxString const &)*arg2);
37842 wxPyEndAllowThreads(__tstate);
37843 if (PyErr_Occurred()) SWIG_fail;
37844 }
37845 resultobj = SWIG_Py_Void();
37846 {
37847 if (temp2)
37848 delete arg2;
37849 }
37850 return resultobj;
37851 fail:
37852 {
37853 if (temp2)
37854 delete arg2;
37855 }
37856 return NULL;
37857 }
37858
37859
37860 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37861 PyObject *resultobj = 0;
37862 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37863 bool result;
37864 void *argp1 = 0 ;
37865 int res1 = 0 ;
37866 PyObject *swig_obj[1] ;
37867
37868 if (!args) SWIG_fail;
37869 swig_obj[0] = args;
37870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37871 if (!SWIG_IsOK(res1)) {
37872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37873 }
37874 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37875 {
37876 PyThreadState* __tstate = wxPyBeginAllowThreads();
37877 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37878 wxPyEndAllowThreads(__tstate);
37879 if (PyErr_Occurred()) SWIG_fail;
37880 }
37881 {
37882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37883 }
37884 return resultobj;
37885 fail:
37886 return NULL;
37887 }
37888
37889
37890 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37891 PyObject *resultobj = 0;
37892 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37893 wxString result;
37894 void *argp1 = 0 ;
37895 int res1 = 0 ;
37896 PyObject *swig_obj[1] ;
37897
37898 if (!args) SWIG_fail;
37899 swig_obj[0] = args;
37900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37901 if (!SWIG_IsOK(res1)) {
37902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37903 }
37904 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37905 {
37906 PyThreadState* __tstate = wxPyBeginAllowThreads();
37907 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37908 wxPyEndAllowThreads(__tstate);
37909 if (PyErr_Occurred()) SWIG_fail;
37910 }
37911 {
37912 #if wxUSE_UNICODE
37913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37914 #else
37915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37916 #endif
37917 }
37918 return resultobj;
37919 fail:
37920 return NULL;
37921 }
37922
37923
37924 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37925 PyObject *resultobj = 0;
37926 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37927 wxString *arg2 = 0 ;
37928 void *argp1 = 0 ;
37929 int res1 = 0 ;
37930 bool temp2 = false ;
37931 PyObject * obj0 = 0 ;
37932 PyObject * obj1 = 0 ;
37933 char * kwnames[] = {
37934 (char *) "self",(char *) "copyright", NULL
37935 };
37936
37937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
37938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37939 if (!SWIG_IsOK(res1)) {
37940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37941 }
37942 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37943 {
37944 arg2 = wxString_in_helper(obj1);
37945 if (arg2 == NULL) SWIG_fail;
37946 temp2 = true;
37947 }
37948 {
37949 PyThreadState* __tstate = wxPyBeginAllowThreads();
37950 (arg1)->SetCopyright((wxString const &)*arg2);
37951 wxPyEndAllowThreads(__tstate);
37952 if (PyErr_Occurred()) SWIG_fail;
37953 }
37954 resultobj = SWIG_Py_Void();
37955 {
37956 if (temp2)
37957 delete arg2;
37958 }
37959 return resultobj;
37960 fail:
37961 {
37962 if (temp2)
37963 delete arg2;
37964 }
37965 return NULL;
37966 }
37967
37968
37969 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37970 PyObject *resultobj = 0;
37971 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37972 bool result;
37973 void *argp1 = 0 ;
37974 int res1 = 0 ;
37975 PyObject *swig_obj[1] ;
37976
37977 if (!args) SWIG_fail;
37978 swig_obj[0] = args;
37979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37980 if (!SWIG_IsOK(res1)) {
37981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37982 }
37983 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37984 {
37985 PyThreadState* __tstate = wxPyBeginAllowThreads();
37986 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
37987 wxPyEndAllowThreads(__tstate);
37988 if (PyErr_Occurred()) SWIG_fail;
37989 }
37990 {
37991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37992 }
37993 return resultobj;
37994 fail:
37995 return NULL;
37996 }
37997
37998
37999 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38000 PyObject *resultobj = 0;
38001 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38002 wxString result;
38003 void *argp1 = 0 ;
38004 int res1 = 0 ;
38005 PyObject *swig_obj[1] ;
38006
38007 if (!args) SWIG_fail;
38008 swig_obj[0] = args;
38009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38010 if (!SWIG_IsOK(res1)) {
38011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38012 }
38013 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38014 {
38015 PyThreadState* __tstate = wxPyBeginAllowThreads();
38016 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
38017 wxPyEndAllowThreads(__tstate);
38018 if (PyErr_Occurred()) SWIG_fail;
38019 }
38020 {
38021 #if wxUSE_UNICODE
38022 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38023 #else
38024 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38025 #endif
38026 }
38027 return resultobj;
38028 fail:
38029 return NULL;
38030 }
38031
38032
38033 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38034 PyObject *resultobj = 0;
38035 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38036 wxString *arg2 = 0 ;
38037 void *argp1 = 0 ;
38038 int res1 = 0 ;
38039 bool temp2 = false ;
38040 PyObject * obj0 = 0 ;
38041 PyObject * obj1 = 0 ;
38042 char * kwnames[] = {
38043 (char *) "self",(char *) "licence", NULL
38044 };
38045
38046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
38047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38048 if (!SWIG_IsOK(res1)) {
38049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38050 }
38051 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38052 {
38053 arg2 = wxString_in_helper(obj1);
38054 if (arg2 == NULL) SWIG_fail;
38055 temp2 = true;
38056 }
38057 {
38058 PyThreadState* __tstate = wxPyBeginAllowThreads();
38059 (arg1)->SetLicence((wxString const &)*arg2);
38060 wxPyEndAllowThreads(__tstate);
38061 if (PyErr_Occurred()) SWIG_fail;
38062 }
38063 resultobj = SWIG_Py_Void();
38064 {
38065 if (temp2)
38066 delete arg2;
38067 }
38068 return resultobj;
38069 fail:
38070 {
38071 if (temp2)
38072 delete arg2;
38073 }
38074 return NULL;
38075 }
38076
38077
38078 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38079 PyObject *resultobj = 0;
38080 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38081 wxString *arg2 = 0 ;
38082 void *argp1 = 0 ;
38083 int res1 = 0 ;
38084 bool temp2 = false ;
38085 PyObject * obj0 = 0 ;
38086 PyObject * obj1 = 0 ;
38087 char * kwnames[] = {
38088 (char *) "self",(char *) "licence", NULL
38089 };
38090
38091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
38092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38093 if (!SWIG_IsOK(res1)) {
38094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38095 }
38096 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38097 {
38098 arg2 = wxString_in_helper(obj1);
38099 if (arg2 == NULL) SWIG_fail;
38100 temp2 = true;
38101 }
38102 {
38103 PyThreadState* __tstate = wxPyBeginAllowThreads();
38104 (arg1)->SetLicense((wxString const &)*arg2);
38105 wxPyEndAllowThreads(__tstate);
38106 if (PyErr_Occurred()) SWIG_fail;
38107 }
38108 resultobj = SWIG_Py_Void();
38109 {
38110 if (temp2)
38111 delete arg2;
38112 }
38113 return resultobj;
38114 fail:
38115 {
38116 if (temp2)
38117 delete arg2;
38118 }
38119 return NULL;
38120 }
38121
38122
38123 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38124 PyObject *resultobj = 0;
38125 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38126 bool result;
38127 void *argp1 = 0 ;
38128 int res1 = 0 ;
38129 PyObject *swig_obj[1] ;
38130
38131 if (!args) SWIG_fail;
38132 swig_obj[0] = args;
38133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38134 if (!SWIG_IsOK(res1)) {
38135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38136 }
38137 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38138 {
38139 PyThreadState* __tstate = wxPyBeginAllowThreads();
38140 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
38141 wxPyEndAllowThreads(__tstate);
38142 if (PyErr_Occurred()) SWIG_fail;
38143 }
38144 {
38145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38146 }
38147 return resultobj;
38148 fail:
38149 return NULL;
38150 }
38151
38152
38153 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38154 PyObject *resultobj = 0;
38155 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38156 wxString result;
38157 void *argp1 = 0 ;
38158 int res1 = 0 ;
38159 PyObject *swig_obj[1] ;
38160
38161 if (!args) SWIG_fail;
38162 swig_obj[0] = args;
38163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38164 if (!SWIG_IsOK(res1)) {
38165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38166 }
38167 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38168 {
38169 PyThreadState* __tstate = wxPyBeginAllowThreads();
38170 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
38171 wxPyEndAllowThreads(__tstate);
38172 if (PyErr_Occurred()) SWIG_fail;
38173 }
38174 {
38175 #if wxUSE_UNICODE
38176 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38177 #else
38178 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38179 #endif
38180 }
38181 return resultobj;
38182 fail:
38183 return NULL;
38184 }
38185
38186
38187 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38188 PyObject *resultobj = 0;
38189 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38190 wxIcon *arg2 = 0 ;
38191 void *argp1 = 0 ;
38192 int res1 = 0 ;
38193 void *argp2 = 0 ;
38194 int res2 = 0 ;
38195 PyObject * obj0 = 0 ;
38196 PyObject * obj1 = 0 ;
38197 char * kwnames[] = {
38198 (char *) "self",(char *) "icon", NULL
38199 };
38200
38201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
38202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38203 if (!SWIG_IsOK(res1)) {
38204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38205 }
38206 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38207 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
38208 if (!SWIG_IsOK(res2)) {
38209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38210 }
38211 if (!argp2) {
38212 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38213 }
38214 arg2 = reinterpret_cast< wxIcon * >(argp2);
38215 {
38216 PyThreadState* __tstate = wxPyBeginAllowThreads();
38217 (arg1)->SetIcon((wxIcon const &)*arg2);
38218 wxPyEndAllowThreads(__tstate);
38219 if (PyErr_Occurred()) SWIG_fail;
38220 }
38221 resultobj = SWIG_Py_Void();
38222 return resultobj;
38223 fail:
38224 return NULL;
38225 }
38226
38227
38228 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38229 PyObject *resultobj = 0;
38230 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38231 bool result;
38232 void *argp1 = 0 ;
38233 int res1 = 0 ;
38234 PyObject *swig_obj[1] ;
38235
38236 if (!args) SWIG_fail;
38237 swig_obj[0] = args;
38238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38239 if (!SWIG_IsOK(res1)) {
38240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38241 }
38242 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38243 {
38244 PyThreadState* __tstate = wxPyBeginAllowThreads();
38245 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38246 wxPyEndAllowThreads(__tstate);
38247 if (PyErr_Occurred()) SWIG_fail;
38248 }
38249 {
38250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38251 }
38252 return resultobj;
38253 fail:
38254 return NULL;
38255 }
38256
38257
38258 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38259 PyObject *resultobj = 0;
38260 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38261 wxIcon result;
38262 void *argp1 = 0 ;
38263 int res1 = 0 ;
38264 PyObject *swig_obj[1] ;
38265
38266 if (!args) SWIG_fail;
38267 swig_obj[0] = args;
38268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38269 if (!SWIG_IsOK(res1)) {
38270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38271 }
38272 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38273 {
38274 PyThreadState* __tstate = wxPyBeginAllowThreads();
38275 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38276 wxPyEndAllowThreads(__tstate);
38277 if (PyErr_Occurred()) SWIG_fail;
38278 }
38279 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38280 return resultobj;
38281 fail:
38282 return NULL;
38283 }
38284
38285
38286 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38287 PyObject *resultobj = 0;
38288 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38289 wxString *arg2 = 0 ;
38290 wxString const &arg3_defvalue = wxEmptyString ;
38291 wxString *arg3 = (wxString *) &arg3_defvalue ;
38292 void *argp1 = 0 ;
38293 int res1 = 0 ;
38294 bool temp2 = false ;
38295 bool temp3 = false ;
38296 PyObject * obj0 = 0 ;
38297 PyObject * obj1 = 0 ;
38298 PyObject * obj2 = 0 ;
38299 char * kwnames[] = {
38300 (char *) "self",(char *) "url",(char *) "desc", NULL
38301 };
38302
38303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38305 if (!SWIG_IsOK(res1)) {
38306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38307 }
38308 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38309 {
38310 arg2 = wxString_in_helper(obj1);
38311 if (arg2 == NULL) SWIG_fail;
38312 temp2 = true;
38313 }
38314 if (obj2) {
38315 {
38316 arg3 = wxString_in_helper(obj2);
38317 if (arg3 == NULL) SWIG_fail;
38318 temp3 = true;
38319 }
38320 }
38321 {
38322 PyThreadState* __tstate = wxPyBeginAllowThreads();
38323 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38324 wxPyEndAllowThreads(__tstate);
38325 if (PyErr_Occurred()) SWIG_fail;
38326 }
38327 resultobj = SWIG_Py_Void();
38328 {
38329 if (temp2)
38330 delete arg2;
38331 }
38332 {
38333 if (temp3)
38334 delete arg3;
38335 }
38336 return resultobj;
38337 fail:
38338 {
38339 if (temp2)
38340 delete arg2;
38341 }
38342 {
38343 if (temp3)
38344 delete arg3;
38345 }
38346 return NULL;
38347 }
38348
38349
38350 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38351 PyObject *resultobj = 0;
38352 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38353 wxString result;
38354 void *argp1 = 0 ;
38355 int res1 = 0 ;
38356 PyObject *swig_obj[1] ;
38357
38358 if (!args) SWIG_fail;
38359 swig_obj[0] = args;
38360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38361 if (!SWIG_IsOK(res1)) {
38362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38363 }
38364 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38365 {
38366 PyThreadState* __tstate = wxPyBeginAllowThreads();
38367 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38368 wxPyEndAllowThreads(__tstate);
38369 if (PyErr_Occurred()) SWIG_fail;
38370 }
38371 {
38372 #if wxUSE_UNICODE
38373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38374 #else
38375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38376 #endif
38377 }
38378 return resultobj;
38379 fail:
38380 return NULL;
38381 }
38382
38383
38384 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38385 PyObject *resultobj = 0;
38386 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38387 wxString result;
38388 void *argp1 = 0 ;
38389 int res1 = 0 ;
38390 PyObject *swig_obj[1] ;
38391
38392 if (!args) SWIG_fail;
38393 swig_obj[0] = args;
38394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38395 if (!SWIG_IsOK(res1)) {
38396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38397 }
38398 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38399 {
38400 PyThreadState* __tstate = wxPyBeginAllowThreads();
38401 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38402 wxPyEndAllowThreads(__tstate);
38403 if (PyErr_Occurred()) SWIG_fail;
38404 }
38405 {
38406 #if wxUSE_UNICODE
38407 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38408 #else
38409 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38410 #endif
38411 }
38412 return resultobj;
38413 fail:
38414 return NULL;
38415 }
38416
38417
38418 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38419 PyObject *resultobj = 0;
38420 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38421 bool result;
38422 void *argp1 = 0 ;
38423 int res1 = 0 ;
38424 PyObject *swig_obj[1] ;
38425
38426 if (!args) SWIG_fail;
38427 swig_obj[0] = args;
38428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38429 if (!SWIG_IsOK(res1)) {
38430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38431 }
38432 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38433 {
38434 PyThreadState* __tstate = wxPyBeginAllowThreads();
38435 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38436 wxPyEndAllowThreads(__tstate);
38437 if (PyErr_Occurred()) SWIG_fail;
38438 }
38439 {
38440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38441 }
38442 return resultobj;
38443 fail:
38444 return NULL;
38445 }
38446
38447
38448 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38449 PyObject *resultobj = 0;
38450 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38451 wxArrayString *arg2 = 0 ;
38452 void *argp1 = 0 ;
38453 int res1 = 0 ;
38454 bool temp2 = false ;
38455 PyObject * obj0 = 0 ;
38456 PyObject * obj1 = 0 ;
38457 char * kwnames[] = {
38458 (char *) "self",(char *) "developers", NULL
38459 };
38460
38461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38463 if (!SWIG_IsOK(res1)) {
38464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38465 }
38466 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38467 {
38468 if (! PySequence_Check(obj1)) {
38469 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38470 SWIG_fail;
38471 }
38472 arg2 = new wxArrayString;
38473 temp2 = true;
38474 int i, len=PySequence_Length(obj1);
38475 for (i=0; i<len; i++) {
38476 PyObject* item = PySequence_GetItem(obj1, i);
38477 wxString* s = wxString_in_helper(item);
38478 if (PyErr_Occurred()) SWIG_fail;
38479 arg2->Add(*s);
38480 delete s;
38481 Py_DECREF(item);
38482 }
38483 }
38484 {
38485 PyThreadState* __tstate = wxPyBeginAllowThreads();
38486 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38487 wxPyEndAllowThreads(__tstate);
38488 if (PyErr_Occurred()) SWIG_fail;
38489 }
38490 resultobj = SWIG_Py_Void();
38491 {
38492 if (temp2) delete arg2;
38493 }
38494 return resultobj;
38495 fail:
38496 {
38497 if (temp2) delete arg2;
38498 }
38499 return NULL;
38500 }
38501
38502
38503 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38504 PyObject *resultobj = 0;
38505 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38506 wxString *arg2 = 0 ;
38507 void *argp1 = 0 ;
38508 int res1 = 0 ;
38509 bool temp2 = false ;
38510 PyObject * obj0 = 0 ;
38511 PyObject * obj1 = 0 ;
38512 char * kwnames[] = {
38513 (char *) "self",(char *) "developer", NULL
38514 };
38515
38516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38518 if (!SWIG_IsOK(res1)) {
38519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38520 }
38521 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38522 {
38523 arg2 = wxString_in_helper(obj1);
38524 if (arg2 == NULL) SWIG_fail;
38525 temp2 = true;
38526 }
38527 {
38528 PyThreadState* __tstate = wxPyBeginAllowThreads();
38529 (arg1)->AddDeveloper((wxString const &)*arg2);
38530 wxPyEndAllowThreads(__tstate);
38531 if (PyErr_Occurred()) SWIG_fail;
38532 }
38533 resultobj = SWIG_Py_Void();
38534 {
38535 if (temp2)
38536 delete arg2;
38537 }
38538 return resultobj;
38539 fail:
38540 {
38541 if (temp2)
38542 delete arg2;
38543 }
38544 return NULL;
38545 }
38546
38547
38548 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38549 PyObject *resultobj = 0;
38550 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38551 bool result;
38552 void *argp1 = 0 ;
38553 int res1 = 0 ;
38554 PyObject *swig_obj[1] ;
38555
38556 if (!args) SWIG_fail;
38557 swig_obj[0] = args;
38558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38559 if (!SWIG_IsOK(res1)) {
38560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38561 }
38562 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38563 {
38564 PyThreadState* __tstate = wxPyBeginAllowThreads();
38565 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38566 wxPyEndAllowThreads(__tstate);
38567 if (PyErr_Occurred()) SWIG_fail;
38568 }
38569 {
38570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38571 }
38572 return resultobj;
38573 fail:
38574 return NULL;
38575 }
38576
38577
38578 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38579 PyObject *resultobj = 0;
38580 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38581 wxArrayString *result = 0 ;
38582 void *argp1 = 0 ;
38583 int res1 = 0 ;
38584 PyObject *swig_obj[1] ;
38585
38586 if (!args) SWIG_fail;
38587 swig_obj[0] = args;
38588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38589 if (!SWIG_IsOK(res1)) {
38590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38591 }
38592 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38593 {
38594 PyThreadState* __tstate = wxPyBeginAllowThreads();
38595 {
38596 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38597 result = (wxArrayString *) &_result_ref;
38598 }
38599 wxPyEndAllowThreads(__tstate);
38600 if (PyErr_Occurred()) SWIG_fail;
38601 }
38602 {
38603 resultobj = wxArrayString2PyList_helper(*result);
38604 }
38605 return resultobj;
38606 fail:
38607 return NULL;
38608 }
38609
38610
38611 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38612 PyObject *resultobj = 0;
38613 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38614 wxArrayString *arg2 = 0 ;
38615 void *argp1 = 0 ;
38616 int res1 = 0 ;
38617 bool temp2 = false ;
38618 PyObject * obj0 = 0 ;
38619 PyObject * obj1 = 0 ;
38620 char * kwnames[] = {
38621 (char *) "self",(char *) "docwriters", NULL
38622 };
38623
38624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38626 if (!SWIG_IsOK(res1)) {
38627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38628 }
38629 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38630 {
38631 if (! PySequence_Check(obj1)) {
38632 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38633 SWIG_fail;
38634 }
38635 arg2 = new wxArrayString;
38636 temp2 = true;
38637 int i, len=PySequence_Length(obj1);
38638 for (i=0; i<len; i++) {
38639 PyObject* item = PySequence_GetItem(obj1, i);
38640 wxString* s = wxString_in_helper(item);
38641 if (PyErr_Occurred()) SWIG_fail;
38642 arg2->Add(*s);
38643 delete s;
38644 Py_DECREF(item);
38645 }
38646 }
38647 {
38648 PyThreadState* __tstate = wxPyBeginAllowThreads();
38649 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38650 wxPyEndAllowThreads(__tstate);
38651 if (PyErr_Occurred()) SWIG_fail;
38652 }
38653 resultobj = SWIG_Py_Void();
38654 {
38655 if (temp2) delete arg2;
38656 }
38657 return resultobj;
38658 fail:
38659 {
38660 if (temp2) delete arg2;
38661 }
38662 return NULL;
38663 }
38664
38665
38666 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38667 PyObject *resultobj = 0;
38668 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38669 wxString *arg2 = 0 ;
38670 void *argp1 = 0 ;
38671 int res1 = 0 ;
38672 bool temp2 = false ;
38673 PyObject * obj0 = 0 ;
38674 PyObject * obj1 = 0 ;
38675 char * kwnames[] = {
38676 (char *) "self",(char *) "docwriter", NULL
38677 };
38678
38679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38681 if (!SWIG_IsOK(res1)) {
38682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38683 }
38684 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38685 {
38686 arg2 = wxString_in_helper(obj1);
38687 if (arg2 == NULL) SWIG_fail;
38688 temp2 = true;
38689 }
38690 {
38691 PyThreadState* __tstate = wxPyBeginAllowThreads();
38692 (arg1)->AddDocWriter((wxString const &)*arg2);
38693 wxPyEndAllowThreads(__tstate);
38694 if (PyErr_Occurred()) SWIG_fail;
38695 }
38696 resultobj = SWIG_Py_Void();
38697 {
38698 if (temp2)
38699 delete arg2;
38700 }
38701 return resultobj;
38702 fail:
38703 {
38704 if (temp2)
38705 delete arg2;
38706 }
38707 return NULL;
38708 }
38709
38710
38711 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38712 PyObject *resultobj = 0;
38713 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38714 bool result;
38715 void *argp1 = 0 ;
38716 int res1 = 0 ;
38717 PyObject *swig_obj[1] ;
38718
38719 if (!args) SWIG_fail;
38720 swig_obj[0] = args;
38721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38722 if (!SWIG_IsOK(res1)) {
38723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38724 }
38725 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38726 {
38727 PyThreadState* __tstate = wxPyBeginAllowThreads();
38728 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38729 wxPyEndAllowThreads(__tstate);
38730 if (PyErr_Occurred()) SWIG_fail;
38731 }
38732 {
38733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38734 }
38735 return resultobj;
38736 fail:
38737 return NULL;
38738 }
38739
38740
38741 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38742 PyObject *resultobj = 0;
38743 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38744 wxArrayString *result = 0 ;
38745 void *argp1 = 0 ;
38746 int res1 = 0 ;
38747 PyObject *swig_obj[1] ;
38748
38749 if (!args) SWIG_fail;
38750 swig_obj[0] = args;
38751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38752 if (!SWIG_IsOK(res1)) {
38753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38754 }
38755 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38756 {
38757 PyThreadState* __tstate = wxPyBeginAllowThreads();
38758 {
38759 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38760 result = (wxArrayString *) &_result_ref;
38761 }
38762 wxPyEndAllowThreads(__tstate);
38763 if (PyErr_Occurred()) SWIG_fail;
38764 }
38765 {
38766 resultobj = wxArrayString2PyList_helper(*result);
38767 }
38768 return resultobj;
38769 fail:
38770 return NULL;
38771 }
38772
38773
38774 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38775 PyObject *resultobj = 0;
38776 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38777 wxArrayString *arg2 = 0 ;
38778 void *argp1 = 0 ;
38779 int res1 = 0 ;
38780 bool temp2 = false ;
38781 PyObject * obj0 = 0 ;
38782 PyObject * obj1 = 0 ;
38783 char * kwnames[] = {
38784 (char *) "self",(char *) "artists", NULL
38785 };
38786
38787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38789 if (!SWIG_IsOK(res1)) {
38790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38791 }
38792 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38793 {
38794 if (! PySequence_Check(obj1)) {
38795 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38796 SWIG_fail;
38797 }
38798 arg2 = new wxArrayString;
38799 temp2 = true;
38800 int i, len=PySequence_Length(obj1);
38801 for (i=0; i<len; i++) {
38802 PyObject* item = PySequence_GetItem(obj1, i);
38803 wxString* s = wxString_in_helper(item);
38804 if (PyErr_Occurred()) SWIG_fail;
38805 arg2->Add(*s);
38806 delete s;
38807 Py_DECREF(item);
38808 }
38809 }
38810 {
38811 PyThreadState* __tstate = wxPyBeginAllowThreads();
38812 (arg1)->SetArtists((wxArrayString const &)*arg2);
38813 wxPyEndAllowThreads(__tstate);
38814 if (PyErr_Occurred()) SWIG_fail;
38815 }
38816 resultobj = SWIG_Py_Void();
38817 {
38818 if (temp2) delete arg2;
38819 }
38820 return resultobj;
38821 fail:
38822 {
38823 if (temp2) delete arg2;
38824 }
38825 return NULL;
38826 }
38827
38828
38829 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38830 PyObject *resultobj = 0;
38831 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38832 wxString *arg2 = 0 ;
38833 void *argp1 = 0 ;
38834 int res1 = 0 ;
38835 bool temp2 = false ;
38836 PyObject * obj0 = 0 ;
38837 PyObject * obj1 = 0 ;
38838 char * kwnames[] = {
38839 (char *) "self",(char *) "artist", NULL
38840 };
38841
38842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38844 if (!SWIG_IsOK(res1)) {
38845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38846 }
38847 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38848 {
38849 arg2 = wxString_in_helper(obj1);
38850 if (arg2 == NULL) SWIG_fail;
38851 temp2 = true;
38852 }
38853 {
38854 PyThreadState* __tstate = wxPyBeginAllowThreads();
38855 (arg1)->AddArtist((wxString const &)*arg2);
38856 wxPyEndAllowThreads(__tstate);
38857 if (PyErr_Occurred()) SWIG_fail;
38858 }
38859 resultobj = SWIG_Py_Void();
38860 {
38861 if (temp2)
38862 delete arg2;
38863 }
38864 return resultobj;
38865 fail:
38866 {
38867 if (temp2)
38868 delete arg2;
38869 }
38870 return NULL;
38871 }
38872
38873
38874 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38875 PyObject *resultobj = 0;
38876 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38877 bool result;
38878 void *argp1 = 0 ;
38879 int res1 = 0 ;
38880 PyObject *swig_obj[1] ;
38881
38882 if (!args) SWIG_fail;
38883 swig_obj[0] = args;
38884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38885 if (!SWIG_IsOK(res1)) {
38886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38887 }
38888 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38889 {
38890 PyThreadState* __tstate = wxPyBeginAllowThreads();
38891 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38892 wxPyEndAllowThreads(__tstate);
38893 if (PyErr_Occurred()) SWIG_fail;
38894 }
38895 {
38896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38897 }
38898 return resultobj;
38899 fail:
38900 return NULL;
38901 }
38902
38903
38904 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38905 PyObject *resultobj = 0;
38906 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38907 wxArrayString *result = 0 ;
38908 void *argp1 = 0 ;
38909 int res1 = 0 ;
38910 PyObject *swig_obj[1] ;
38911
38912 if (!args) SWIG_fail;
38913 swig_obj[0] = args;
38914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38915 if (!SWIG_IsOK(res1)) {
38916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38917 }
38918 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38919 {
38920 PyThreadState* __tstate = wxPyBeginAllowThreads();
38921 {
38922 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
38923 result = (wxArrayString *) &_result_ref;
38924 }
38925 wxPyEndAllowThreads(__tstate);
38926 if (PyErr_Occurred()) SWIG_fail;
38927 }
38928 {
38929 resultobj = wxArrayString2PyList_helper(*result);
38930 }
38931 return resultobj;
38932 fail:
38933 return NULL;
38934 }
38935
38936
38937 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38938 PyObject *resultobj = 0;
38939 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38940 wxArrayString *arg2 = 0 ;
38941 void *argp1 = 0 ;
38942 int res1 = 0 ;
38943 bool temp2 = false ;
38944 PyObject * obj0 = 0 ;
38945 PyObject * obj1 = 0 ;
38946 char * kwnames[] = {
38947 (char *) "self",(char *) "translators", NULL
38948 };
38949
38950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
38951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38952 if (!SWIG_IsOK(res1)) {
38953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38954 }
38955 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38956 {
38957 if (! PySequence_Check(obj1)) {
38958 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38959 SWIG_fail;
38960 }
38961 arg2 = new wxArrayString;
38962 temp2 = true;
38963 int i, len=PySequence_Length(obj1);
38964 for (i=0; i<len; i++) {
38965 PyObject* item = PySequence_GetItem(obj1, i);
38966 wxString* s = wxString_in_helper(item);
38967 if (PyErr_Occurred()) SWIG_fail;
38968 arg2->Add(*s);
38969 delete s;
38970 Py_DECREF(item);
38971 }
38972 }
38973 {
38974 PyThreadState* __tstate = wxPyBeginAllowThreads();
38975 (arg1)->SetTranslators((wxArrayString const &)*arg2);
38976 wxPyEndAllowThreads(__tstate);
38977 if (PyErr_Occurred()) SWIG_fail;
38978 }
38979 resultobj = SWIG_Py_Void();
38980 {
38981 if (temp2) delete arg2;
38982 }
38983 return resultobj;
38984 fail:
38985 {
38986 if (temp2) delete arg2;
38987 }
38988 return NULL;
38989 }
38990
38991
38992 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38993 PyObject *resultobj = 0;
38994 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38995 wxString *arg2 = 0 ;
38996 void *argp1 = 0 ;
38997 int res1 = 0 ;
38998 bool temp2 = false ;
38999 PyObject * obj0 = 0 ;
39000 PyObject * obj1 = 0 ;
39001 char * kwnames[] = {
39002 (char *) "self",(char *) "translator", NULL
39003 };
39004
39005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
39006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39007 if (!SWIG_IsOK(res1)) {
39008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
39009 }
39010 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39011 {
39012 arg2 = wxString_in_helper(obj1);
39013 if (arg2 == NULL) SWIG_fail;
39014 temp2 = true;
39015 }
39016 {
39017 PyThreadState* __tstate = wxPyBeginAllowThreads();
39018 (arg1)->AddTranslator((wxString const &)*arg2);
39019 wxPyEndAllowThreads(__tstate);
39020 if (PyErr_Occurred()) SWIG_fail;
39021 }
39022 resultobj = SWIG_Py_Void();
39023 {
39024 if (temp2)
39025 delete arg2;
39026 }
39027 return resultobj;
39028 fail:
39029 {
39030 if (temp2)
39031 delete arg2;
39032 }
39033 return NULL;
39034 }
39035
39036
39037 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39038 PyObject *resultobj = 0;
39039 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39040 bool result;
39041 void *argp1 = 0 ;
39042 int res1 = 0 ;
39043 PyObject *swig_obj[1] ;
39044
39045 if (!args) SWIG_fail;
39046 swig_obj[0] = args;
39047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39048 if (!SWIG_IsOK(res1)) {
39049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39050 }
39051 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39052 {
39053 PyThreadState* __tstate = wxPyBeginAllowThreads();
39054 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
39055 wxPyEndAllowThreads(__tstate);
39056 if (PyErr_Occurred()) SWIG_fail;
39057 }
39058 {
39059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39060 }
39061 return resultobj;
39062 fail:
39063 return NULL;
39064 }
39065
39066
39067 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39068 PyObject *resultobj = 0;
39069 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39070 wxArrayString *result = 0 ;
39071 void *argp1 = 0 ;
39072 int res1 = 0 ;
39073 PyObject *swig_obj[1] ;
39074
39075 if (!args) SWIG_fail;
39076 swig_obj[0] = args;
39077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39078 if (!SWIG_IsOK(res1)) {
39079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39080 }
39081 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39082 {
39083 PyThreadState* __tstate = wxPyBeginAllowThreads();
39084 {
39085 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
39086 result = (wxArrayString *) &_result_ref;
39087 }
39088 wxPyEndAllowThreads(__tstate);
39089 if (PyErr_Occurred()) SWIG_fail;
39090 }
39091 {
39092 resultobj = wxArrayString2PyList_helper(*result);
39093 }
39094 return resultobj;
39095 fail:
39096 return NULL;
39097 }
39098
39099
39100 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39101 PyObject *resultobj = 0;
39102 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39103 bool result;
39104 void *argp1 = 0 ;
39105 int res1 = 0 ;
39106 PyObject *swig_obj[1] ;
39107
39108 if (!args) SWIG_fail;
39109 swig_obj[0] = args;
39110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39111 if (!SWIG_IsOK(res1)) {
39112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39113 }
39114 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39115 {
39116 PyThreadState* __tstate = wxPyBeginAllowThreads();
39117 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
39118 wxPyEndAllowThreads(__tstate);
39119 if (PyErr_Occurred()) SWIG_fail;
39120 }
39121 {
39122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39123 }
39124 return resultobj;
39125 fail:
39126 return NULL;
39127 }
39128
39129
39130 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39131 PyObject *resultobj = 0;
39132 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39133 wxString result;
39134 void *argp1 = 0 ;
39135 int res1 = 0 ;
39136 PyObject *swig_obj[1] ;
39137
39138 if (!args) SWIG_fail;
39139 swig_obj[0] = args;
39140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39141 if (!SWIG_IsOK(res1)) {
39142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39143 }
39144 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39145 {
39146 PyThreadState* __tstate = wxPyBeginAllowThreads();
39147 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
39148 wxPyEndAllowThreads(__tstate);
39149 if (PyErr_Occurred()) SWIG_fail;
39150 }
39151 {
39152 #if wxUSE_UNICODE
39153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39154 #else
39155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39156 #endif
39157 }
39158 return resultobj;
39159 fail:
39160 return NULL;
39161 }
39162
39163
39164 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39165 PyObject *obj;
39166 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39167 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
39168 return SWIG_Py_Void();
39169 }
39170
39171 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39172 return SWIG_Python_InitShadowInstance(args);
39173 }
39174
39175 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39176 PyObject *resultobj = 0;
39177 wxAboutDialogInfo *arg1 = 0 ;
39178 void *argp1 = 0 ;
39179 int res1 = 0 ;
39180 PyObject * obj0 = 0 ;
39181 char * kwnames[] = {
39182 (char *) "info", NULL
39183 };
39184
39185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
39186 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
39187 if (!SWIG_IsOK(res1)) {
39188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39189 }
39190 if (!argp1) {
39191 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39192 }
39193 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39194 {
39195 PyThreadState* __tstate = wxPyBeginAllowThreads();
39196 wxAboutBox((wxAboutDialogInfo const &)*arg1);
39197 wxPyEndAllowThreads(__tstate);
39198 if (PyErr_Occurred()) SWIG_fail;
39199 }
39200 resultobj = SWIG_Py_Void();
39201 return resultobj;
39202 fail:
39203 return NULL;
39204 }
39205
39206
39207 static PyMethodDef SwigMethods[] = {
39208 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
39209 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
39210 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
39211 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
39212 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
39213 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
39214 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
39215 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
39216 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39217 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39218 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39219 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39220 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
39221 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
39222 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
39223 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
39224 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
39225 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
39226 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
39227 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
39228 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39229 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39230 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
39231 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
39232 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
39233 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
39234 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39235 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39236 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39237 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
39238 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39239 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39240 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39241 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39242 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39243 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39244 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39245 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39246 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39247 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39248 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39249 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39250 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39251 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39252 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39253 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39254 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39255 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39256 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39257 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39258 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39259 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39260 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39261 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39262 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39263 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39264 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39265 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39266 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39267 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39268 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39269 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39270 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39271 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39272 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39273 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39274 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39275 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39276 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39277 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39278 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39279 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39280 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39281 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39282 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39283 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39284 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39285 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39286 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39287 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39288 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39289 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39290 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39291 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39292 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39293 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39294 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39295 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39296 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39297 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39298 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39299 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39300 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39301 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39302 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39303 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39304 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39305 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39306 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39307 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39308 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39309 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39310 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39311 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39312 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39313 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39314 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39315 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39316 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39317 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39318 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39319 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39320 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39321 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39322 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39323 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39324 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39325 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39326 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39327 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39328 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39329 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39330 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39331 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39332 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39333 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39334 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39335 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39336 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39337 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39338 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39339 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39340 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39341 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39342 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39343 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39344 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39345 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39346 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39347 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39348 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39349 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39350 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39351 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39352 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39353 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39354 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39355 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39356 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39357 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39358 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39359 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39360 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39361 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39362 { (char *)"delete_StopWatch", (PyCFunction)_wrap_delete_StopWatch, METH_O, NULL},
39363 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39364 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39365 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39366 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39367 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39368 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39369 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39370 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39371 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39372 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39373 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39374 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39375 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39376 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39377 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39378 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39379 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39380 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39381 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39382 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39383 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39384 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39385 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39386 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39387 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39388 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39389 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39390 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39391 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39392 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39393 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39394 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39395 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39396 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39397 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39398 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39399 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39400 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39401 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39402 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39403 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39404 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39405 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39406 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39407 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39408 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39409 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39410 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39411 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39412 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39413 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39414 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39415 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39416 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39417 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39418 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39419 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39420 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39421 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39422 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39423 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39424 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39425 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39426 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39427 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39428 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39429 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39430 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39431 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39432 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39433 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39434 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39435 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39436 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39437 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39438 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39439 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39440 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39441 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39442 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39443 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39444 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39445 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39446 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39447 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39448 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39449 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39450 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39451 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39452 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39453 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39454 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39455 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39456 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39457 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39458 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39459 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39460 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39461 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39462 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39463 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39464 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39465 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39466 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39467 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39468 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39469 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39470 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39471 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39472 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39473 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39474 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39475 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39476 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39477 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39478 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39479 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39480 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39481 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39482 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39483 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39484 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39485 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39486 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39487 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39488 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39489 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39490 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39491 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39492 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39493 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39494 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39495 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39496 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39497 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39498 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39499 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39500 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39501 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39502 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39503 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39504 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39505 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39506 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39507 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39508 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39509 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39510 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39511 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39512 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39513 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39514 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39515 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39516 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39517 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39518 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39519 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39520 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39521 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39522 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39523 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39524 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39525 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39526 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39527 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39528 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39529 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39530 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39531 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39532 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39533 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39534 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39535 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39536 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39537 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39538 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39539 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39540 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39541 { (char *)"delete_Process", (PyCFunction)_wrap_delete_Process, METH_O, NULL},
39542 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39543 { (char *)"Process_GetPid", (PyCFunction)_wrap_Process_GetPid, METH_O, NULL},
39544 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39545 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39546 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39547 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39548 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39549 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39550 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39551 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39552 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39553 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39554 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39555 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39556 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39557 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39558 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39559 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39560 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39561 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39562 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39563 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39564 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39565 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39566 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39567 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39568 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39569 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39570 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39571 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39572 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39573 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39574 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39575 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39576 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39577 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39578 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39579 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39580 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39581 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39582 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39583 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39584 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39585 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39586 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39587 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39588 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39589 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39590 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39591 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39592 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39593 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39594 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39595 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39596 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39597 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39598 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39599 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39600 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39601 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39602 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39603 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39604 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39605 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39606 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39607 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39608 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39609 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39610 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39611 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39612 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39613 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39614 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39615 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39616 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39617 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39618 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39619 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39620 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39621 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39622 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39623 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39624 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39625 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39626 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39627 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39628 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39629 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39630 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39631 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39632 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39633 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39634 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39635 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39636 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39637 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39638 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39639 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39640 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39641 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39642 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39643 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39644 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39645 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39646 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39647 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39648 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39649 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39650 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39651 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39652 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39653 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39654 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39655 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39656 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39657 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39658 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39659 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39660 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39661 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39662 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39663 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39664 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39665 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39666 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39667 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39668 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39669 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39670 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39671 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39672 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39673 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39674 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39675 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39676 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39677 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39678 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39679 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39680 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39681 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39682 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39683 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39684 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39685 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39686 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39687 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39688 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39689 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39690 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39691 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39692 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39693 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39694 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39695 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39696 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39697 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39698 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39699 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39700 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39701 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39702 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39703 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39704 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39705 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39706 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39707 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39708 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39709 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39710 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39711 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39712 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39713 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39714 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39715 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39716 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39717 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39718 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39719 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39720 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39721 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39722 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39723 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39724 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39725 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39726 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39727 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39728 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39729 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39730 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39731 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39732 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39733 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39734 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39735 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39736 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39737 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39738 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39739 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39740 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39741 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39742 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39743 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39744 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39745 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39746 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39747 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39748 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39749 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39750 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39751 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39752 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39753 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39754 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39755 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39756 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39757 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39758 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39759 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39760 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39761 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39762 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39763 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39764 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39765 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39766 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39767 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39768 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39769 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39770 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39771 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39772 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39773 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39774 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39775 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39776 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39777 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39778 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39779 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39780 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39781 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39782 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39783 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39784 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39785 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39786 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39787 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39788 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39789 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39790 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39791 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39792 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39793 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39794 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39795 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39797 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39798 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39799 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39800 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39801 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39802 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39803 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39804 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39805 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39806 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39807 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39808 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39809 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39810 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39811 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39812 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39813 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39814 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39815 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39816 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39817 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39818 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39819 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39820 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39821 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39822 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39823 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39824 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39825 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39826 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39827 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39828 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39829 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39830 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39831 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39832 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39833 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39834 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39835 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39836 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39837 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39838 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39839 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39840 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39841 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39842 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39843 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39844 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39845 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39846 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39847 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39848 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39849 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39850 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39851 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39852 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39853 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39854 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39855 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39856 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39857 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39858 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39859 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39860 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39861 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39862 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39863 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39864 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39865 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39866 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39867 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39868 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39869 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39870 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39871 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39872 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39873 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39874 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39875 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39876 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39877 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39878 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39879 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39880 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39881 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39882 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39883 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39884 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39885 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39886 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39887 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39888 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39889 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39890 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39891 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39892 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39893 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39894 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39895 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39896 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39897 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39898 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39899 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39900 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39901 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39902 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39903 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39904 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39905 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39906 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39907 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39908 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39909 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39910 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39911 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39912 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39913 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39914 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39915 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39916 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39917 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39918 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39919 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39920 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
39921 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39922 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
39923 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
39924 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
39925 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
39926 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
39927 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
39928 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39929 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
39930 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
39931 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39932 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
39933 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39934 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
39935 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39936 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
39937 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
39938 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
39939 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
39940 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
39941 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
39942 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
39943 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
39944 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
39945 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
39946 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
39947 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
39948 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
39949 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
39950 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39951 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39952 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
39953 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39954 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39955 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39956 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
39957 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39958 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39959 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39960 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39961 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39962 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39963 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39964 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
39965 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
39966 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
39967 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
39968 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
39969 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
39970 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39971 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39972 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
39973 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
39974 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
39975 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
39976 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
39977 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
39978 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
39979 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
39980 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
39981 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
39982 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39983 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
39984 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39985 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
39986 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
39987 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
39988 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39989 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
39990 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39991 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
39992 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39993 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
39994 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
39995 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39996 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
39997 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
39998 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39999 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40000 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
40001 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
40002 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
40003 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
40004 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
40005 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
40006 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
40007 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40008 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
40009 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
40010 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
40011 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
40012 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
40013 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40014 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40015 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
40016 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
40017 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40018 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
40019 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
40020 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
40021 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
40022 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40023 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40024 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
40025 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
40026 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
40027 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
40028 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
40029 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
40030 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
40031 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
40032 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40033 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
40034 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
40035 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
40036 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
40037 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40038 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
40039 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
40040 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
40041 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
40042 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
40043 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
40044 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
40045 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
40046 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
40047 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
40048 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
40049 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40050 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
40051 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40052 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
40053 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
40054 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40055 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
40056 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
40057 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
40058 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
40059 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40060 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
40061 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
40062 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40063 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40064 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40065 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
40066 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40067 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
40068 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
40069 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
40070 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
40071 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
40072 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
40073 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40074 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
40075 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40076 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40077 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
40078 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40079 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40080 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
40081 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
40082 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
40083 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40084 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
40085 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40086 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40087 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
40088 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40089 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40090 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
40091 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
40092 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
40093 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
40094 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
40095 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
40096 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
40097 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
40098 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40099 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
40100 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
40101 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
40102 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
40103 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
40104 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
40105 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
40106 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
40107 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
40108 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
40109 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
40110 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
40111 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
40112 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
40113 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
40114 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
40115 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
40116 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
40117 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
40118 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
40119 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
40120 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
40121 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
40122 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
40123 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
40124 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
40125 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
40126 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
40127 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
40128 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
40129 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
40130 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
40131 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
40132 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
40133 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
40134 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
40135 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
40136 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
40137 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
40138 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
40139 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
40140 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
40141 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
40142 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
40143 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
40144 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
40145 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
40146 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
40147 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
40148 { (char *)"StandardPaths_GetExecutablePath", (PyCFunction)_wrap_StandardPaths_GetExecutablePath, METH_O, NULL},
40149 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
40150 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
40151 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
40152 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
40153 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
40154 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
40155 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
40156 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
40157 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
40158 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
40159 { (char *)"StandardPaths_GetTempDir", (PyCFunction)_wrap_StandardPaths_GetTempDir, METH_O, NULL},
40160 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
40161 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
40162 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
40163 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
40164 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
40165 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
40166 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
40167 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
40168 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
40169 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
40170 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
40171 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
40172 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
40173 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
40174 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
40175 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
40176 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
40177 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
40178 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
40179 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
40180 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
40181 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
40182 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
40183 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
40184 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
40185 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
40186 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
40187 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
40188 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
40189 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
40190 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
40191 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
40192 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
40193 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
40194 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
40195 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
40196 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
40197 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
40198 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
40199 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
40200 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
40201 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
40202 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
40203 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
40204 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
40205 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
40206 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
40207 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
40208 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
40209 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
40210 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
40211 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
40212 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
40213 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
40214 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
40215 { NULL, NULL, 0, NULL }
40216 };
40217
40218
40219 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
40220
40221 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
40222 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
40223 }
40224 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
40225 return (void *)((wxEvent *) ((wxMenuEvent *) x));
40226 }
40227 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
40228 return (void *)((wxEvent *) ((wxCloseEvent *) x));
40229 }
40230 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
40231 return (void *)((wxEvent *) ((wxMouseEvent *) x));
40232 }
40233 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
40234 return (void *)((wxEvent *) ((wxEraseEvent *) x));
40235 }
40236 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
40237 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
40238 }
40239 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
40240 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40241 }
40242 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40243 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40244 }
40245 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40246 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40247 }
40248 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40249 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40250 }
40251 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40252 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40253 }
40254 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40255 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40256 }
40257 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40258 return (void *)((wxEvent *) ((wxPyEvent *) x));
40259 }
40260 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40261 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40262 }
40263 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40264 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40265 }
40266 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40267 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40268 }
40269 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40270 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40271 }
40272 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40273 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40274 }
40275 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40276 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40277 }
40278 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40279 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40280 }
40281 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40282 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40283 }
40284 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40285 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40286 }
40287 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40288 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40289 }
40290 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40291 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40292 }
40293 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40294 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40295 }
40296 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40297 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40298 }
40299 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40300 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40301 }
40302 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40303 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40304 }
40305 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40306 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40307 }
40308 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40309 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40310 }
40311 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40312 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40313 }
40314 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40315 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40316 }
40317 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40318 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40319 }
40320 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40321 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40322 }
40323 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40324 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40325 }
40326 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40327 return (void *)((wxEvent *) ((wxShowEvent *) x));
40328 }
40329 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40330 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40331 }
40332 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40333 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40334 }
40335 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40336 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40337 }
40338 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40339 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40340 }
40341 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40342 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40343 }
40344 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40345 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40346 }
40347 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40348 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40349 }
40350 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40351 return (void *)((wxConfigBase *) ((wxConfig *) x));
40352 }
40353 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40354 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40355 }
40356 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40357 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40358 }
40359 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40360 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40361 }
40362 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40363 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40364 }
40365 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40366 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40367 }
40368 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40369 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40370 }
40371 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40372 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40373 }
40374 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40375 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40376 }
40377 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40378 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40379 }
40380 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40381 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40382 }
40383 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40384 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40385 }
40386 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40387 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40388 }
40389 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40390 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40391 }
40392 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40393 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40394 }
40395 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40396 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40397 }
40398 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40399 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40400 }
40401 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40402 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40403 }
40404 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40405 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40406 }
40407 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40408 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40409 }
40410 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40411 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40412 }
40413 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40414 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40415 }
40416 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40417 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40418 }
40419 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40420 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40421 }
40422 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40423 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40424 }
40425 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40426 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40427 }
40428 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40429 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40430 }
40431 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40432 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40433 }
40434 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40435 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40436 }
40437 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40438 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40439 }
40440 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40441 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40442 }
40443 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40444 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40445 }
40446 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40447 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40448 }
40449 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40450 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40451 }
40452 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40453 return (void *)((wxObject *) ((wxSizerItem *) x));
40454 }
40455 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40456 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40457 }
40458 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40459 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40460 }
40461 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40462 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40463 }
40464 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40465 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40466 }
40467 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40468 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40469 }
40470 static void *_p_wxSizerTo_p_wxObject(void *x) {
40471 return (void *)((wxObject *) ((wxSizer *) x));
40472 }
40473 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40474 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40475 }
40476 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40477 return (void *)((wxObject *) ((wxFileHistory *) x));
40478 }
40479 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40480 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40481 }
40482 static void *_p_wxEventTo_p_wxObject(void *x) {
40483 return (void *)((wxObject *) ((wxEvent *) x));
40484 }
40485 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40486 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40487 }
40488 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40489 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40490 }
40491 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40492 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40493 }
40494 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40495 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40496 }
40497 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40498 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40499 }
40500 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40501 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40502 }
40503 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40504 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40505 }
40506 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40507 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40508 }
40509 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40510 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40511 }
40512 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40513 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40514 }
40515 static void *_p_wxControlTo_p_wxObject(void *x) {
40516 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40517 }
40518 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40519 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40520 }
40521 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40522 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40523 }
40524 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40525 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40526 }
40527 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40528 return (void *)((wxObject *) ((wxFSFile *) x));
40529 }
40530 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40531 return (void *)((wxObject *) ((wxClipboard *) x));
40532 }
40533 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40534 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40535 }
40536 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40537 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40538 }
40539 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40540 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40541 }
40542 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40543 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40544 }
40545 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40546 return (void *)((wxObject *) ((wxToolTip *) x));
40547 }
40548 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40549 return (void *)((wxObject *) ((wxMenuItem *) x));
40550 }
40551 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40552 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40553 }
40554 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40555 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40556 }
40557 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40558 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40559 }
40560 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40561 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40562 }
40563 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40564 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40565 }
40566 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40567 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40568 }
40569 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40570 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40571 }
40572 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40573 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40574 }
40575 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40576 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40577 }
40578 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40579 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40580 }
40581 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40582 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40583 }
40584 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40585 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40586 }
40587 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40588 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40589 }
40590 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40591 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40592 }
40593 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40594 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40595 }
40596 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40597 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40598 }
40599 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40600 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40601 }
40602 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40603 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40604 }
40605 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40606 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40607 }
40608 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40609 return (void *)((wxObject *) ((wxImageHandler *) x));
40610 }
40611 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40612 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40613 }
40614 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40615 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40616 }
40617 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
40618 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
40619 }
40620 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40621 return (void *)((wxObject *) ((wxEvtHandler *) x));
40622 }
40623 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40624 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40625 }
40626 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40627 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40628 }
40629 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40630 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40631 }
40632 static void *_p_wxImageTo_p_wxObject(void *x) {
40633 return (void *)((wxObject *) ((wxImage *) x));
40634 }
40635 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40636 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40637 }
40638 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40639 return (void *)((wxObject *) ((wxSystemOptions *) x));
40640 }
40641 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40642 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40643 }
40644 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40645 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40646 }
40647 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40648 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40649 }
40650 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40651 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40652 }
40653 static void *_p_wxWindowTo_p_wxObject(void *x) {
40654 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40655 }
40656 static void *_p_wxMenuTo_p_wxObject(void *x) {
40657 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40658 }
40659 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40660 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40661 }
40662 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40663 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40664 }
40665 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40666 return (void *)((wxObject *) ((wxFileSystem *) x));
40667 }
40668 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40669 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40670 }
40671 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40672 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40673 }
40674 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40675 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40676 }
40677 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40678 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40679 }
40680 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40681 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40682 }
40683 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40684 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40685 }
40686 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40687 return (void *)((wxObject *) ((wxBusyInfo *) x));
40688 }
40689 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40690 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40691 }
40692 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40693 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40694 }
40695 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40696 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40697 }
40698 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40699 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40700 }
40701 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40702 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40703 }
40704 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40705 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40706 }
40707 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40708 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40709 }
40710 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40711 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40712 }
40713 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40714 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40715 }
40716 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40717 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40718 }
40719 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40720 return (void *)((wxLog *) ((wxLogBuffer *) x));
40721 }
40722 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40723 return (void *)((wxLog *) ((wxLogStderr *) x));
40724 }
40725 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40726 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40727 }
40728 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40729 return (void *)((wxLog *) ((wxLogWindow *) x));
40730 }
40731 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40732 return (void *)((wxLog *) ((wxLogChain *) x));
40733 }
40734 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40735 return (void *)((wxLog *) ((wxLogGui *) x));
40736 }
40737 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40738 return (void *)((wxLog *) ((wxPyLog *) x));
40739 }
40740 static void *_p_wxControlTo_p_wxWindow(void *x) {
40741 return (void *)((wxWindow *) ((wxControl *) x));
40742 }
40743 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40744 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40745 }
40746 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40747 return (void *)((wxWindow *) ((wxMenuBar *) x));
40748 }
40749 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40750 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40751 }
40752 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40753 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40754 }
40755 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40756 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};
40757 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40758 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40759 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40760 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40761 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40762 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40763 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40764 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40765 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40766 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40767 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40768 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40769 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40770 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40771 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40772 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40773 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40774 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40775 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40776 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40777 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40778 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40779 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40780 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40781 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40782 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40783 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40784 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40785 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40786 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40787 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40788 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40789 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40790 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40791 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40792 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40793 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40794 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40795 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40796 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40797 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40798 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40799 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40800 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40801 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40802 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40803 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40804 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40805 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40806 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40807 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40808 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40809 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40810 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40811 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40812 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40813 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40814 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40815 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40816 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40817 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40818 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40819 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40820 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40821 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40822 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40823 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40824 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40825 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40826 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40827 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40828 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40829 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40830 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40831 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40832 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40833 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40834 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40835 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40836 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40837 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40838 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40839 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40840 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40841 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40842 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40843 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40844 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40845 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40846 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40847 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40848 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40849 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40850 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40851 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40852 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40853 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40854 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
40855 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40856 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40857 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40858 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40859 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40860 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40861 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40862 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40863 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40864 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40865 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40866 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40867 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40868 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40869 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40870 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40871 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40872 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40873 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40874 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40875 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
40876 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40877 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40878 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40879 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40880 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40881 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40882 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40883 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40884 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40885 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40886 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40887 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40888 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40889 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40890 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40891 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40892 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40893 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40894 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40895 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40896 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40897 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40898 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40899 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40900 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40901 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40902 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40903 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40904 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40905 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40906 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40907 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40908 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40909 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
40910 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
40911 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
40912 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
40913 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
40914 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
40915 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
40916 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
40917 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
40918 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
40919 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
40920 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
40921 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
40922 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
40923 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
40924 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
40925 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
40926 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
40927 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
40928 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
40929 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
40930
40931 static swig_type_info *swig_type_initial[] = {
40932 &_swigt__p_char,
40933 &_swigt__p_form_ops_t,
40934 &_swigt__p_int,
40935 &_swigt__p_unsigned_char,
40936 &_swigt__p_unsigned_int,
40937 &_swigt__p_unsigned_long,
40938 &_swigt__p_void,
40939 &_swigt__p_wxANIHandler,
40940 &_swigt__p_wxAboutDialogInfo,
40941 &_swigt__p_wxAcceleratorTable,
40942 &_swigt__p_wxActivateEvent,
40943 &_swigt__p_wxArrayString,
40944 &_swigt__p_wxBMPHandler,
40945 &_swigt__p_wxBitmap,
40946 &_swigt__p_wxBitmapDataObject,
40947 &_swigt__p_wxBoxSizer,
40948 &_swigt__p_wxBusyCursor,
40949 &_swigt__p_wxBusyInfo,
40950 &_swigt__p_wxCURHandler,
40951 &_swigt__p_wxCaret,
40952 &_swigt__p_wxChar,
40953 &_swigt__p_wxChildFocusEvent,
40954 &_swigt__p_wxClipboard,
40955 &_swigt__p_wxClipboardLocker,
40956 &_swigt__p_wxClipboardTextEvent,
40957 &_swigt__p_wxCloseEvent,
40958 &_swigt__p_wxColour,
40959 &_swigt__p_wxCommandEvent,
40960 &_swigt__p_wxConfig,
40961 &_swigt__p_wxConfigBase,
40962 &_swigt__p_wxConfigPathChanger,
40963 &_swigt__p_wxContextMenuEvent,
40964 &_swigt__p_wxControl,
40965 &_swigt__p_wxControlWithItems,
40966 &_swigt__p_wxCursor,
40967 &_swigt__p_wxCustomDataObject,
40968 &_swigt__p_wxDC,
40969 &_swigt__p_wxDataFormat,
40970 &_swigt__p_wxDataObject,
40971 &_swigt__p_wxDataObjectComposite,
40972 &_swigt__p_wxDataObjectSimple,
40973 &_swigt__p_wxDateEvent,
40974 &_swigt__p_wxDateSpan,
40975 &_swigt__p_wxDateTime,
40976 &_swigt__p_wxDateTime__TimeZone,
40977 &_swigt__p_wxDisplay,
40978 &_swigt__p_wxDisplayChangedEvent,
40979 &_swigt__p_wxDropFilesEvent,
40980 &_swigt__p_wxDuplexMode,
40981 &_swigt__p_wxEraseEvent,
40982 &_swigt__p_wxEvent,
40983 &_swigt__p_wxEvtHandler,
40984 &_swigt__p_wxFSFile,
40985 &_swigt__p_wxFileConfig,
40986 &_swigt__p_wxFileDataObject,
40987 &_swigt__p_wxFileHistory,
40988 &_swigt__p_wxFileSystem,
40989 &_swigt__p_wxFileType,
40990 &_swigt__p_wxFileTypeInfo,
40991 &_swigt__p_wxFlexGridSizer,
40992 &_swigt__p_wxFocusEvent,
40993 &_swigt__p_wxFont,
40994 &_swigt__p_wxFrame,
40995 &_swigt__p_wxGBSizerItem,
40996 &_swigt__p_wxGIFHandler,
40997 &_swigt__p_wxGridBagSizer,
40998 &_swigt__p_wxGridSizer,
40999 &_swigt__p_wxICOHandler,
41000 &_swigt__p_wxIcon,
41001 &_swigt__p_wxIconizeEvent,
41002 &_swigt__p_wxIdleEvent,
41003 &_swigt__p_wxImage,
41004 &_swigt__p_wxImageHandler,
41005 &_swigt__p_wxIndividualLayoutConstraint,
41006 &_swigt__p_wxInitDialogEvent,
41007 &_swigt__p_wxJPEGHandler,
41008 &_swigt__p_wxJoystick,
41009 &_swigt__p_wxJoystickEvent,
41010 &_swigt__p_wxKeyEvent,
41011 &_swigt__p_wxKillError,
41012 &_swigt__p_wxLayoutConstraints,
41013 &_swigt__p_wxLog,
41014 &_swigt__p_wxLogBuffer,
41015 &_swigt__p_wxLogChain,
41016 &_swigt__p_wxLogGui,
41017 &_swigt__p_wxLogNull,
41018 &_swigt__p_wxLogStderr,
41019 &_swigt__p_wxLogTextCtrl,
41020 &_swigt__p_wxLogWindow,
41021 &_swigt__p_wxMaximizeEvent,
41022 &_swigt__p_wxMenu,
41023 &_swigt__p_wxMenuBar,
41024 &_swigt__p_wxMenuEvent,
41025 &_swigt__p_wxMenuItem,
41026 &_swigt__p_wxMetafile,
41027 &_swigt__p_wxMetafileDataObject,
41028 &_swigt__p_wxMimeTypesManager,
41029 &_swigt__p_wxMouseCaptureChangedEvent,
41030 &_swigt__p_wxMouseCaptureLostEvent,
41031 &_swigt__p_wxMouseEvent,
41032 &_swigt__p_wxMouseState,
41033 &_swigt__p_wxMoveEvent,
41034 &_swigt__p_wxMutexGuiLocker,
41035 &_swigt__p_wxNavigationKeyEvent,
41036 &_swigt__p_wxNcPaintEvent,
41037 &_swigt__p_wxNotifyEvent,
41038 &_swigt__p_wxObject,
41039 &_swigt__p_wxOutputStream,
41040 &_swigt__p_wxPCXHandler,
41041 &_swigt__p_wxPNGHandler,
41042 &_swigt__p_wxPNMHandler,
41043 &_swigt__p_wxPaintEvent,
41044 &_swigt__p_wxPaletteChangedEvent,
41045 &_swigt__p_wxPaperSize,
41046 &_swigt__p_wxPlatformInfo,
41047 &_swigt__p_wxPoint,
41048 &_swigt__p_wxPowerEvent,
41049 &_swigt__p_wxProcessEvent,
41050 &_swigt__p_wxPyApp,
41051 &_swigt__p_wxPyArtProvider,
41052 &_swigt__p_wxPyBitmapDataObject,
41053 &_swigt__p_wxPyCommandEvent,
41054 &_swigt__p_wxPyDataObjectSimple,
41055 &_swigt__p_wxPyDropSource,
41056 &_swigt__p_wxPyDropTarget,
41057 &_swigt__p_wxPyEvent,
41058 &_swigt__p_wxPyFileDropTarget,
41059 &_swigt__p_wxPyImageHandler,
41060 &_swigt__p_wxPyLog,
41061 &_swigt__p_wxPyProcess,
41062 &_swigt__p_wxPySizer,
41063 &_swigt__p_wxPyTextDataObject,
41064 &_swigt__p_wxPyTextDropTarget,
41065 &_swigt__p_wxPyTimer,
41066 &_swigt__p_wxPyTipProvider,
41067 &_swigt__p_wxPyValidator,
41068 &_swigt__p_wxQueryNewPaletteEvent,
41069 &_swigt__p_wxRect,
41070 &_swigt__p_wxScrollEvent,
41071 &_swigt__p_wxScrollWinEvent,
41072 &_swigt__p_wxSetCursorEvent,
41073 &_swigt__p_wxShowEvent,
41074 &_swigt__p_wxSingleInstanceChecker,
41075 &_swigt__p_wxSize,
41076 &_swigt__p_wxSizeEvent,
41077 &_swigt__p_wxSizer,
41078 &_swigt__p_wxSizerItem,
41079 &_swigt__p_wxSound,
41080 &_swigt__p_wxStandardPaths,
41081 &_swigt__p_wxStaticBoxSizer,
41082 &_swigt__p_wxStdDialogButtonSizer,
41083 &_swigt__p_wxStopWatch,
41084 &_swigt__p_wxString,
41085 &_swigt__p_wxSysColourChangedEvent,
41086 &_swigt__p_wxSystemOptions,
41087 &_swigt__p_wxSystemSettings,
41088 &_swigt__p_wxTGAHandler,
41089 &_swigt__p_wxTIFFHandler,
41090 &_swigt__p_wxTextCtrl,
41091 &_swigt__p_wxTextDataObject,
41092 &_swigt__p_wxTimeSpan,
41093 &_swigt__p_wxTimer,
41094 &_swigt__p_wxTimerEvent,
41095 &_swigt__p_wxTimerRunner,
41096 &_swigt__p_wxTipProvider,
41097 &_swigt__p_wxToolTip,
41098 &_swigt__p_wxURLDataObject,
41099 &_swigt__p_wxUpdateUIEvent,
41100 &_swigt__p_wxValidator,
41101 &_swigt__p_wxVideoMode,
41102 &_swigt__p_wxWindow,
41103 &_swigt__p_wxWindowCreateEvent,
41104 &_swigt__p_wxWindowDestroyEvent,
41105 &_swigt__p_wxWindowDisabler,
41106 &_swigt__p_wxXPMHandler,
41107 };
41108
41109 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
41110 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
41111 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
41112 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
41113 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
41114 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
41115 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
41116 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
41117 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
41118 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
41119 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}};
41120 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
41121 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
41122 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
41123 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
41124 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
41125 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
41126 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
41127 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
41128 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}};
41129 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
41130 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
41131 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
41132 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
41133 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
41134 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}};
41135 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
41136 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}};
41137 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
41138 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
41139 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
41140 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
41141 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
41142 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41143 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41144 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
41145 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
41146 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
41147 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
41148 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
41149 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
41150 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
41151 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
41152 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
41153 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
41154 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
41155 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
41156 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41157 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41158 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
41159 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41160 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
41161 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
41162 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41163 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41164 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
41165 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
41166 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41167 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41168 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41169 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41170 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
41171 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41172 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41173 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
41174 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41175 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41176 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
41177 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41178 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41179 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
41180 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}};
41181 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
41182 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
41183 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
41184 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
41185 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
41186 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
41187 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}};
41188 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
41189 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41190 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
41191 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
41192 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
41193 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
41194 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
41195 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
41196 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
41197 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
41198 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
41199 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}};
41200 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
41201 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
41202 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
41203 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
41204 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
41205 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41206 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
41207 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
41208 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
41209 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41210 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
41211 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
41212 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
41213 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
41214 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41215 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41216 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
41217 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41218 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41219 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
41220 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
41221 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41222 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41223 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
41224 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
41225 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
41226 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
41227 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
41228 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
41229 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41230 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41231 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
41232 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
41233 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
41234 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
41235 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
41236 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
41237 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
41238 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
41239 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
41240 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
41241 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
41242 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
41243 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
41244 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_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_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}};
41245 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
41246 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
41247 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
41248 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
41249 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41250 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41251 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41252 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41253 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41254 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41255 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}};
41256 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41257 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41258 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41259 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41260 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41261 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41262 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41263 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41264 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41265 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41266 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41267 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41268 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41269 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41270 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41271 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41272 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41273 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}};
41274 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41275 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41276 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41277 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41278 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}};
41279 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41280 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41281 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41282 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}};
41283 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41284
41285 static swig_cast_info *swig_cast_initial[] = {
41286 _swigc__p_char,
41287 _swigc__p_form_ops_t,
41288 _swigc__p_int,
41289 _swigc__p_unsigned_char,
41290 _swigc__p_unsigned_int,
41291 _swigc__p_unsigned_long,
41292 _swigc__p_void,
41293 _swigc__p_wxANIHandler,
41294 _swigc__p_wxAboutDialogInfo,
41295 _swigc__p_wxAcceleratorTable,
41296 _swigc__p_wxActivateEvent,
41297 _swigc__p_wxArrayString,
41298 _swigc__p_wxBMPHandler,
41299 _swigc__p_wxBitmap,
41300 _swigc__p_wxBitmapDataObject,
41301 _swigc__p_wxBoxSizer,
41302 _swigc__p_wxBusyCursor,
41303 _swigc__p_wxBusyInfo,
41304 _swigc__p_wxCURHandler,
41305 _swigc__p_wxCaret,
41306 _swigc__p_wxChar,
41307 _swigc__p_wxChildFocusEvent,
41308 _swigc__p_wxClipboard,
41309 _swigc__p_wxClipboardLocker,
41310 _swigc__p_wxClipboardTextEvent,
41311 _swigc__p_wxCloseEvent,
41312 _swigc__p_wxColour,
41313 _swigc__p_wxCommandEvent,
41314 _swigc__p_wxConfig,
41315 _swigc__p_wxConfigBase,
41316 _swigc__p_wxConfigPathChanger,
41317 _swigc__p_wxContextMenuEvent,
41318 _swigc__p_wxControl,
41319 _swigc__p_wxControlWithItems,
41320 _swigc__p_wxCursor,
41321 _swigc__p_wxCustomDataObject,
41322 _swigc__p_wxDC,
41323 _swigc__p_wxDataFormat,
41324 _swigc__p_wxDataObject,
41325 _swigc__p_wxDataObjectComposite,
41326 _swigc__p_wxDataObjectSimple,
41327 _swigc__p_wxDateEvent,
41328 _swigc__p_wxDateSpan,
41329 _swigc__p_wxDateTime,
41330 _swigc__p_wxDateTime__TimeZone,
41331 _swigc__p_wxDisplay,
41332 _swigc__p_wxDisplayChangedEvent,
41333 _swigc__p_wxDropFilesEvent,
41334 _swigc__p_wxDuplexMode,
41335 _swigc__p_wxEraseEvent,
41336 _swigc__p_wxEvent,
41337 _swigc__p_wxEvtHandler,
41338 _swigc__p_wxFSFile,
41339 _swigc__p_wxFileConfig,
41340 _swigc__p_wxFileDataObject,
41341 _swigc__p_wxFileHistory,
41342 _swigc__p_wxFileSystem,
41343 _swigc__p_wxFileType,
41344 _swigc__p_wxFileTypeInfo,
41345 _swigc__p_wxFlexGridSizer,
41346 _swigc__p_wxFocusEvent,
41347 _swigc__p_wxFont,
41348 _swigc__p_wxFrame,
41349 _swigc__p_wxGBSizerItem,
41350 _swigc__p_wxGIFHandler,
41351 _swigc__p_wxGridBagSizer,
41352 _swigc__p_wxGridSizer,
41353 _swigc__p_wxICOHandler,
41354 _swigc__p_wxIcon,
41355 _swigc__p_wxIconizeEvent,
41356 _swigc__p_wxIdleEvent,
41357 _swigc__p_wxImage,
41358 _swigc__p_wxImageHandler,
41359 _swigc__p_wxIndividualLayoutConstraint,
41360 _swigc__p_wxInitDialogEvent,
41361 _swigc__p_wxJPEGHandler,
41362 _swigc__p_wxJoystick,
41363 _swigc__p_wxJoystickEvent,
41364 _swigc__p_wxKeyEvent,
41365 _swigc__p_wxKillError,
41366 _swigc__p_wxLayoutConstraints,
41367 _swigc__p_wxLog,
41368 _swigc__p_wxLogBuffer,
41369 _swigc__p_wxLogChain,
41370 _swigc__p_wxLogGui,
41371 _swigc__p_wxLogNull,
41372 _swigc__p_wxLogStderr,
41373 _swigc__p_wxLogTextCtrl,
41374 _swigc__p_wxLogWindow,
41375 _swigc__p_wxMaximizeEvent,
41376 _swigc__p_wxMenu,
41377 _swigc__p_wxMenuBar,
41378 _swigc__p_wxMenuEvent,
41379 _swigc__p_wxMenuItem,
41380 _swigc__p_wxMetafile,
41381 _swigc__p_wxMetafileDataObject,
41382 _swigc__p_wxMimeTypesManager,
41383 _swigc__p_wxMouseCaptureChangedEvent,
41384 _swigc__p_wxMouseCaptureLostEvent,
41385 _swigc__p_wxMouseEvent,
41386 _swigc__p_wxMouseState,
41387 _swigc__p_wxMoveEvent,
41388 _swigc__p_wxMutexGuiLocker,
41389 _swigc__p_wxNavigationKeyEvent,
41390 _swigc__p_wxNcPaintEvent,
41391 _swigc__p_wxNotifyEvent,
41392 _swigc__p_wxObject,
41393 _swigc__p_wxOutputStream,
41394 _swigc__p_wxPCXHandler,
41395 _swigc__p_wxPNGHandler,
41396 _swigc__p_wxPNMHandler,
41397 _swigc__p_wxPaintEvent,
41398 _swigc__p_wxPaletteChangedEvent,
41399 _swigc__p_wxPaperSize,
41400 _swigc__p_wxPlatformInfo,
41401 _swigc__p_wxPoint,
41402 _swigc__p_wxPowerEvent,
41403 _swigc__p_wxProcessEvent,
41404 _swigc__p_wxPyApp,
41405 _swigc__p_wxPyArtProvider,
41406 _swigc__p_wxPyBitmapDataObject,
41407 _swigc__p_wxPyCommandEvent,
41408 _swigc__p_wxPyDataObjectSimple,
41409 _swigc__p_wxPyDropSource,
41410 _swigc__p_wxPyDropTarget,
41411 _swigc__p_wxPyEvent,
41412 _swigc__p_wxPyFileDropTarget,
41413 _swigc__p_wxPyImageHandler,
41414 _swigc__p_wxPyLog,
41415 _swigc__p_wxPyProcess,
41416 _swigc__p_wxPySizer,
41417 _swigc__p_wxPyTextDataObject,
41418 _swigc__p_wxPyTextDropTarget,
41419 _swigc__p_wxPyTimer,
41420 _swigc__p_wxPyTipProvider,
41421 _swigc__p_wxPyValidator,
41422 _swigc__p_wxQueryNewPaletteEvent,
41423 _swigc__p_wxRect,
41424 _swigc__p_wxScrollEvent,
41425 _swigc__p_wxScrollWinEvent,
41426 _swigc__p_wxSetCursorEvent,
41427 _swigc__p_wxShowEvent,
41428 _swigc__p_wxSingleInstanceChecker,
41429 _swigc__p_wxSize,
41430 _swigc__p_wxSizeEvent,
41431 _swigc__p_wxSizer,
41432 _swigc__p_wxSizerItem,
41433 _swigc__p_wxSound,
41434 _swigc__p_wxStandardPaths,
41435 _swigc__p_wxStaticBoxSizer,
41436 _swigc__p_wxStdDialogButtonSizer,
41437 _swigc__p_wxStopWatch,
41438 _swigc__p_wxString,
41439 _swigc__p_wxSysColourChangedEvent,
41440 _swigc__p_wxSystemOptions,
41441 _swigc__p_wxSystemSettings,
41442 _swigc__p_wxTGAHandler,
41443 _swigc__p_wxTIFFHandler,
41444 _swigc__p_wxTextCtrl,
41445 _swigc__p_wxTextDataObject,
41446 _swigc__p_wxTimeSpan,
41447 _swigc__p_wxTimer,
41448 _swigc__p_wxTimerEvent,
41449 _swigc__p_wxTimerRunner,
41450 _swigc__p_wxTipProvider,
41451 _swigc__p_wxToolTip,
41452 _swigc__p_wxURLDataObject,
41453 _swigc__p_wxUpdateUIEvent,
41454 _swigc__p_wxValidator,
41455 _swigc__p_wxVideoMode,
41456 _swigc__p_wxWindow,
41457 _swigc__p_wxWindowCreateEvent,
41458 _swigc__p_wxWindowDestroyEvent,
41459 _swigc__p_wxWindowDisabler,
41460 _swigc__p_wxXPMHandler,
41461 };
41462
41463
41464 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41465
41466 static swig_const_info swig_const_table[] = {
41467 {0, 0, 0, 0.0, 0, 0}};
41468
41469 #ifdef __cplusplus
41470 }
41471 #endif
41472 /* -----------------------------------------------------------------------------
41473 * Type initialization:
41474 * This problem is tough by the requirement that no dynamic
41475 * memory is used. Also, since swig_type_info structures store pointers to
41476 * swig_cast_info structures and swig_cast_info structures store pointers back
41477 * to swig_type_info structures, we need some lookup code at initialization.
41478 * The idea is that swig generates all the structures that are needed.
41479 * The runtime then collects these partially filled structures.
41480 * The SWIG_InitializeModule function takes these initial arrays out of
41481 * swig_module, and does all the lookup, filling in the swig_module.types
41482 * array with the correct data and linking the correct swig_cast_info
41483 * structures together.
41484 *
41485 * The generated swig_type_info structures are assigned staticly to an initial
41486 * array. We just loop though that array, and handle each type individually.
41487 * First we lookup if this type has been already loaded, and if so, use the
41488 * loaded structure instead of the generated one. Then we have to fill in the
41489 * cast linked list. The cast data is initially stored in something like a
41490 * two-dimensional array. Each row corresponds to a type (there are the same
41491 * number of rows as there are in the swig_type_initial array). Each entry in
41492 * a column is one of the swig_cast_info structures for that type.
41493 * The cast_initial array is actually an array of arrays, because each row has
41494 * a variable number of columns. So to actually build the cast linked list,
41495 * we find the array of casts associated with the type, and loop through it
41496 * adding the casts to the list. The one last trick we need to do is making
41497 * sure the type pointer in the swig_cast_info struct is correct.
41498 *
41499 * First off, we lookup the cast->type name to see if it is already loaded.
41500 * There are three cases to handle:
41501 * 1) If the cast->type has already been loaded AND the type we are adding
41502 * casting info to has not been loaded (it is in this module), THEN we
41503 * replace the cast->type pointer with the type pointer that has already
41504 * been loaded.
41505 * 2) If BOTH types (the one we are adding casting info to, and the
41506 * cast->type) are loaded, THEN the cast info has already been loaded by
41507 * the previous module so we just ignore it.
41508 * 3) Finally, if cast->type has not already been loaded, then we add that
41509 * swig_cast_info to the linked list (because the cast->type) pointer will
41510 * be correct.
41511 * ----------------------------------------------------------------------------- */
41512
41513 #ifdef __cplusplus
41514 extern "C" {
41515 #if 0
41516 } /* c-mode */
41517 #endif
41518 #endif
41519
41520 #if 0
41521 #define SWIGRUNTIME_DEBUG
41522 #endif
41523
41524 SWIGRUNTIME void
41525 SWIG_InitializeModule(void *clientdata) {
41526 size_t i;
41527 swig_module_info *module_head;
41528 static int init_run = 0;
41529
41530 clientdata = clientdata;
41531
41532 if (init_run) return;
41533 init_run = 1;
41534
41535 /* Initialize the swig_module */
41536 swig_module.type_initial = swig_type_initial;
41537 swig_module.cast_initial = swig_cast_initial;
41538
41539 /* Try and load any already created modules */
41540 module_head = SWIG_GetModule(clientdata);
41541 if (module_head) {
41542 swig_module.next = module_head->next;
41543 module_head->next = &swig_module;
41544 } else {
41545 /* This is the first module loaded */
41546 swig_module.next = &swig_module;
41547 SWIG_SetModule(clientdata, &swig_module);
41548 }
41549
41550 /* Now work on filling in swig_module.types */
41551 #ifdef SWIGRUNTIME_DEBUG
41552 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41553 #endif
41554 for (i = 0; i < swig_module.size; ++i) {
41555 swig_type_info *type = 0;
41556 swig_type_info *ret;
41557 swig_cast_info *cast;
41558
41559 #ifdef SWIGRUNTIME_DEBUG
41560 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41561 #endif
41562
41563 /* if there is another module already loaded */
41564 if (swig_module.next != &swig_module) {
41565 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41566 }
41567 if (type) {
41568 /* Overwrite clientdata field */
41569 #ifdef SWIGRUNTIME_DEBUG
41570 printf("SWIG_InitializeModule: found type %s\n", type->name);
41571 #endif
41572 if (swig_module.type_initial[i]->clientdata) {
41573 type->clientdata = swig_module.type_initial[i]->clientdata;
41574 #ifdef SWIGRUNTIME_DEBUG
41575 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41576 #endif
41577 }
41578 } else {
41579 type = swig_module.type_initial[i];
41580 }
41581
41582 /* Insert casting types */
41583 cast = swig_module.cast_initial[i];
41584 while (cast->type) {
41585 /* Don't need to add information already in the list */
41586 ret = 0;
41587 #ifdef SWIGRUNTIME_DEBUG
41588 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41589 #endif
41590 if (swig_module.next != &swig_module) {
41591 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41592 #ifdef SWIGRUNTIME_DEBUG
41593 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41594 #endif
41595 }
41596 if (ret) {
41597 if (type == swig_module.type_initial[i]) {
41598 #ifdef SWIGRUNTIME_DEBUG
41599 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41600 #endif
41601 cast->type = ret;
41602 ret = 0;
41603 } else {
41604 /* Check for casting already in the list */
41605 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41606 #ifdef SWIGRUNTIME_DEBUG
41607 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41608 #endif
41609 if (!ocast) ret = 0;
41610 }
41611 }
41612
41613 if (!ret) {
41614 #ifdef SWIGRUNTIME_DEBUG
41615 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41616 #endif
41617 if (type->cast) {
41618 type->cast->prev = cast;
41619 cast->next = type->cast;
41620 }
41621 type->cast = cast;
41622 }
41623 cast++;
41624 }
41625 /* Set entry in modules->types array equal to the type */
41626 swig_module.types[i] = type;
41627 }
41628 swig_module.types[i] = 0;
41629
41630 #ifdef SWIGRUNTIME_DEBUG
41631 printf("**** SWIG_InitializeModule: Cast List ******\n");
41632 for (i = 0; i < swig_module.size; ++i) {
41633 int j = 0;
41634 swig_cast_info *cast = swig_module.cast_initial[i];
41635 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41636 while (cast->type) {
41637 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41638 cast++;
41639 ++j;
41640 }
41641 printf("---- Total casts: %d\n",j);
41642 }
41643 printf("**** SWIG_InitializeModule: Cast List ******\n");
41644 #endif
41645 }
41646
41647 /* This function will propagate the clientdata field of type to
41648 * any new swig_type_info structures that have been added into the list
41649 * of equivalent types. It is like calling
41650 * SWIG_TypeClientData(type, clientdata) a second time.
41651 */
41652 SWIGRUNTIME void
41653 SWIG_PropagateClientData(void) {
41654 size_t i;
41655 swig_cast_info *equiv;
41656 static int init_run = 0;
41657
41658 if (init_run) return;
41659 init_run = 1;
41660
41661 for (i = 0; i < swig_module.size; i++) {
41662 if (swig_module.types[i]->clientdata) {
41663 equiv = swig_module.types[i]->cast;
41664 while (equiv) {
41665 if (!equiv->converter) {
41666 if (equiv->type && !equiv->type->clientdata)
41667 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41668 }
41669 equiv = equiv->next;
41670 }
41671 }
41672 }
41673 }
41674
41675 #ifdef __cplusplus
41676 #if 0
41677 {
41678 /* c-mode */
41679 #endif
41680 }
41681 #endif
41682
41683
41684
41685 #ifdef __cplusplus
41686 extern "C" {
41687 #endif
41688
41689 /* Python-specific SWIG API */
41690 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41691 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41692 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41693
41694 /* -----------------------------------------------------------------------------
41695 * global variable support code.
41696 * ----------------------------------------------------------------------------- */
41697
41698 typedef struct swig_globalvar {
41699 char *name; /* Name of global variable */
41700 PyObject *(*get_attr)(void); /* Return the current value */
41701 int (*set_attr)(PyObject *); /* Set the value */
41702 struct swig_globalvar *next;
41703 } swig_globalvar;
41704
41705 typedef struct swig_varlinkobject {
41706 PyObject_HEAD
41707 swig_globalvar *vars;
41708 } swig_varlinkobject;
41709
41710 SWIGINTERN PyObject *
41711 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41712 return PyString_FromString("<Swig global variables>");
41713 }
41714
41715 SWIGINTERN PyObject *
41716 swig_varlink_str(swig_varlinkobject *v) {
41717 PyObject *str = PyString_FromString("(");
41718 swig_globalvar *var;
41719 for (var = v->vars; var; var=var->next) {
41720 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41721 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41722 }
41723 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41724 return str;
41725 }
41726
41727 SWIGINTERN int
41728 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41729 PyObject *str = swig_varlink_str(v);
41730 fprintf(fp,"Swig global variables ");
41731 fprintf(fp,"%s\n", PyString_AsString(str));
41732 Py_DECREF(str);
41733 return 0;
41734 }
41735
41736 SWIGINTERN void
41737 swig_varlink_dealloc(swig_varlinkobject *v) {
41738 swig_globalvar *var = v->vars;
41739 while (var) {
41740 swig_globalvar *n = var->next;
41741 free(var->name);
41742 free(var);
41743 var = n;
41744 }
41745 }
41746
41747 SWIGINTERN PyObject *
41748 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41749 PyObject *res = NULL;
41750 swig_globalvar *var = v->vars;
41751 while (var) {
41752 if (strcmp(var->name,n) == 0) {
41753 res = (*var->get_attr)();
41754 break;
41755 }
41756 var = var->next;
41757 }
41758 if (res == NULL && !PyErr_Occurred()) {
41759 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41760 }
41761 return res;
41762 }
41763
41764 SWIGINTERN int
41765 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41766 int res = 1;
41767 swig_globalvar *var = v->vars;
41768 while (var) {
41769 if (strcmp(var->name,n) == 0) {
41770 res = (*var->set_attr)(p);
41771 break;
41772 }
41773 var = var->next;
41774 }
41775 if (res == 1 && !PyErr_Occurred()) {
41776 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41777 }
41778 return res;
41779 }
41780
41781 SWIGINTERN PyTypeObject*
41782 swig_varlink_type(void) {
41783 static char varlink__doc__[] = "Swig var link object";
41784 static PyTypeObject varlink_type;
41785 static int type_init = 0;
41786 if (!type_init) {
41787 const PyTypeObject tmp
41788 = {
41789 PyObject_HEAD_INIT(NULL)
41790 0, /* Number of items in variable part (ob_size) */
41791 (char *)"swigvarlink", /* Type name (tp_name) */
41792 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41793 0, /* Itemsize (tp_itemsize) */
41794 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41795 (printfunc) swig_varlink_print, /* Print (tp_print) */
41796 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41797 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41798 0, /* tp_compare */
41799 (reprfunc) swig_varlink_repr, /* tp_repr */
41800 0, /* tp_as_number */
41801 0, /* tp_as_sequence */
41802 0, /* tp_as_mapping */
41803 0, /* tp_hash */
41804 0, /* tp_call */
41805 (reprfunc)swig_varlink_str, /* tp_str */
41806 0, /* tp_getattro */
41807 0, /* tp_setattro */
41808 0, /* tp_as_buffer */
41809 0, /* tp_flags */
41810 varlink__doc__, /* tp_doc */
41811 0, /* tp_traverse */
41812 0, /* tp_clear */
41813 0, /* tp_richcompare */
41814 0, /* tp_weaklistoffset */
41815 #if PY_VERSION_HEX >= 0x02020000
41816 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41817 #endif
41818 #if PY_VERSION_HEX >= 0x02030000
41819 0, /* tp_del */
41820 #endif
41821 #ifdef COUNT_ALLOCS
41822 0,0,0,0 /* tp_alloc -> tp_next */
41823 #endif
41824 };
41825 varlink_type = tmp;
41826 varlink_type.ob_type = &PyType_Type;
41827 type_init = 1;
41828 }
41829 return &varlink_type;
41830 }
41831
41832 /* Create a variable linking object for use later */
41833 SWIGINTERN PyObject *
41834 SWIG_Python_newvarlink(void) {
41835 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41836 if (result) {
41837 result->vars = 0;
41838 }
41839 return ((PyObject*) result);
41840 }
41841
41842 SWIGINTERN void
41843 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41844 swig_varlinkobject *v = (swig_varlinkobject *) p;
41845 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41846 if (gv) {
41847 size_t size = strlen(name)+1;
41848 gv->name = (char *)malloc(size);
41849 if (gv->name) {
41850 strncpy(gv->name,name,size);
41851 gv->get_attr = get_attr;
41852 gv->set_attr = set_attr;
41853 gv->next = v->vars;
41854 }
41855 }
41856 v->vars = gv;
41857 }
41858
41859 SWIGINTERN PyObject *
41860 SWIG_globals() {
41861 static PyObject *_SWIG_globals = 0;
41862 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41863 return _SWIG_globals;
41864 }
41865
41866 /* -----------------------------------------------------------------------------
41867 * constants/methods manipulation
41868 * ----------------------------------------------------------------------------- */
41869
41870 /* Install Constants */
41871 SWIGINTERN void
41872 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41873 PyObject *obj = 0;
41874 size_t i;
41875 for (i = 0; constants[i].type; ++i) {
41876 switch(constants[i].type) {
41877 case SWIG_PY_POINTER:
41878 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41879 break;
41880 case SWIG_PY_BINARY:
41881 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41882 break;
41883 default:
41884 obj = 0;
41885 break;
41886 }
41887 if (obj) {
41888 PyDict_SetItemString(d, constants[i].name, obj);
41889 Py_DECREF(obj);
41890 }
41891 }
41892 }
41893
41894 /* -----------------------------------------------------------------------------*/
41895 /* Fix SwigMethods to carry the callback ptrs when needed */
41896 /* -----------------------------------------------------------------------------*/
41897
41898 SWIGINTERN void
41899 SWIG_Python_FixMethods(PyMethodDef *methods,
41900 swig_const_info *const_table,
41901 swig_type_info **types,
41902 swig_type_info **types_initial) {
41903 size_t i;
41904 for (i = 0; methods[i].ml_name; ++i) {
41905 const char *c = methods[i].ml_doc;
41906 if (c && (c = strstr(c, "swig_ptr: "))) {
41907 int j;
41908 swig_const_info *ci = 0;
41909 const char *name = c + 10;
41910 for (j = 0; const_table[j].type; ++j) {
41911 if (strncmp(const_table[j].name, name,
41912 strlen(const_table[j].name)) == 0) {
41913 ci = &(const_table[j]);
41914 break;
41915 }
41916 }
41917 if (ci) {
41918 size_t shift = (ci->ptype) - types;
41919 swig_type_info *ty = types_initial[shift];
41920 size_t ldoc = (c - methods[i].ml_doc);
41921 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
41922 char *ndoc = (char*)malloc(ldoc + lptr + 10);
41923 if (ndoc) {
41924 char *buff = ndoc;
41925 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
41926 if (ptr) {
41927 strncpy(buff, methods[i].ml_doc, ldoc);
41928 buff += ldoc;
41929 strncpy(buff, "swig_ptr: ", 10);
41930 buff += 10;
41931 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
41932 methods[i].ml_doc = ndoc;
41933 }
41934 }
41935 }
41936 }
41937 }
41938 }
41939
41940 #ifdef __cplusplus
41941 }
41942 #endif
41943
41944 /* -----------------------------------------------------------------------------*
41945 * Partial Init method
41946 * -----------------------------------------------------------------------------*/
41947
41948 #ifdef __cplusplus
41949 extern "C"
41950 #endif
41951 SWIGEXPORT void SWIG_init(void) {
41952 PyObject *m, *d;
41953
41954 /* Fix SwigMethods to carry the callback ptrs when needed */
41955 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
41956
41957 m = Py_InitModule((char *) SWIG_name, SwigMethods);
41958 d = PyModule_GetDict(m);
41959
41960 SWIG_InitializeModule(0);
41961 SWIG_InstallConstants(d,swig_const_table);
41962
41963
41964 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
41965 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
41966 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
41967 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
41968 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
41969 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
41970 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
41971 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
41972 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
41973 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
41974 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
41975 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
41976 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
41977 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
41978 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
41979 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
41980 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
41981 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
41982 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
41983 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
41984 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
41985 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
41986 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
41987 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
41988 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
41989 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
41990 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
41991 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
41992 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
41993 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
41994 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
41995 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
41996 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
41997 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
41998 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
41999 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
42000 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
42001 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
42002 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
42003 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
42004 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
42005 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
42006 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
42007 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
42008 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
42009 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
42010 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
42011 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
42012 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
42013 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
42014 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
42015 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
42016 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
42017 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
42018 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
42019 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
42020 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
42021 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
42022 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
42023 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
42024 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
42025 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
42026 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
42027 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
42028 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
42029 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
42030 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
42031 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
42032 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
42033 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
42034 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
42035 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
42036 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
42037 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
42038 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
42039 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
42040 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
42041 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
42042 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
42043 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
42044 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
42045 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
42046 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
42047 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
42048 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
42049 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
42050 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
42051 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
42052 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
42053 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
42054 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
42055 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
42056 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
42057 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
42058 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
42059 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
42060 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
42061 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
42062 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
42063 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
42064 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
42065 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
42066 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
42067 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
42068 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
42069 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
42070 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
42071 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
42072 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
42073 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
42074 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
42075 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
42076 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
42077 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
42078 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
42079 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
42080 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
42081 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
42082 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
42083 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
42084 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
42085 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
42086 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
42087 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
42088 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
42089 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
42090 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
42091 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
42092 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
42093 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
42094 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
42095 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
42096 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
42097 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
42098 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
42099 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
42100 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
42101 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
42102 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
42103 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
42104 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
42105 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
42106 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
42107 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
42108 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
42109 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
42110 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
42111 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
42112
42113 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
42114
42115 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
42116 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
42117 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
42118 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
42119 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
42120 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
42121 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
42122 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
42123 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
42124 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
42125 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
42126 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
42127 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
42128 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
42129 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
42130 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
42131 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
42132 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
42133 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
42134 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
42135 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
42136 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
42137 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
42138 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
42139 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
42140 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
42141 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
42142 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
42143 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
42144 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
42145 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
42146 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
42147 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
42148 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
42149 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
42150 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
42151 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
42152 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
42153 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
42154 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
42155 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
42156 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
42157 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
42158 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
42159 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
42160 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
42161 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
42162 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
42163 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
42164 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
42165 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
42166 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
42167 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
42168
42169 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
42170
42171 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
42172 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
42173 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
42174 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
42175 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
42176 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
42177 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
42178 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
42179 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
42180 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
42181 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
42182 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
42183 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
42184 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
42185 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
42186 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
42187 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
42188 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
42189 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
42190 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
42191 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
42192 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
42193 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
42194 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
42195 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
42196 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
42197 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
42198 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
42199 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
42200 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
42201 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
42202 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
42203 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
42204 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
42205 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
42206 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
42207 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
42208 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
42209 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
42210 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
42211 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
42212 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
42213 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
42214 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
42215 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
42216 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
42217 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
42218 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
42219 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
42220 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
42221 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
42222 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
42223 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
42224 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
42225 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
42226 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
42227 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
42228 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
42229 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
42230 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
42231 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
42232 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
42233 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
42234 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
42235 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
42236 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
42237 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
42238 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
42239 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
42240 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
42241 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
42242 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
42243 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
42244 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
42245 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
42246 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
42247
42248 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
42249
42250 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
42251 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42252 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42253 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42254 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42255 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42256 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42257 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42258 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42259 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42260 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42261 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42262 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42263 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42264 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42265 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42266 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42267 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42268 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42269 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42270 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42271 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42272 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42273 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42274 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42275 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42276 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42277 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42278 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42279 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42280 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42281 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42282 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42283 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42284 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42285 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42286 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42287 SWIG_Python_SetConstant(d, "DateTime_GMT13",SWIG_From_int(static_cast< int >(wxDateTime::GMT13)));
42288 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42289 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42290 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42291 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42292 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42293 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42294 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42295 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42296 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42297 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42298 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42299 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42300 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42301 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42302 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42303 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42304 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42305 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42306 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42307 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42308 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42309 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42310 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42311 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42312 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42313 SWIG_Python_SetConstant(d, "DateTime_NZST",SWIG_From_int(static_cast< int >(wxDateTime::NZST)));
42314 SWIG_Python_SetConstant(d, "DateTime_NZDT",SWIG_From_int(static_cast< int >(wxDateTime::NZDT)));
42315 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42316 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42317 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42318 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42319 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42320 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42321 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42322 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42323 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42324 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42325 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42326 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42327 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42328 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42329 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42330 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42331 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42332 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42333 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42334 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42335 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42336 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42337 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42338 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42339 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42340 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42341 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42342 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42343 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42344 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42345 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42346 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42347 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42348 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42349 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42350 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42351 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42352 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42353 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42354 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42355 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42356 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42357 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42358 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42359 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42360 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42361 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42362 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42363 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42364 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42365 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42366 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42367 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42368 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42369 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42370 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42371 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42372 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42373 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42374 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42375 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42376 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42377 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42378 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42379 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42380 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42381 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42382 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42383 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42384 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42385 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42386 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42387 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42388 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42389 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42390 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42391 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42392 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42393 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42394 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42395 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42396 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42397 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42398 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42399 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42400 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42401 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42402 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42403 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42404 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42405 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42406 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42407 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42408 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42409 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42410 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42411 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42412 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42413 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42414 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42415 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42416 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42417 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42418 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42419 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42420 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42421 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42422 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42423 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42424 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42425 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42426 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42427 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42428 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42429 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42430 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42431 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42432 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42433 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42434 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42435 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42436 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42437 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42438 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42439 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42440 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42441 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42442 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42443 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42444 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42445 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42446 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42447 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42448 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42449 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42450 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42451 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42452 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42453
42454 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42455 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42456 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42457 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42458
42459 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42460 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42461 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42462 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42463 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42464 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42465 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42466 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42467 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42468 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42469 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42470 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42471 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42472 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42473 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42474 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42475 }
42476
wxWidgets (Impactor)